Novu vs Apprise vs Ntfy: Self-Hosted Notification Infrastructure Guide 2026

Every application needs a way to reach its users. Whether it’s a password reset email, an order confirmation SMS, an in-app notification badge, or a Slack alert when your server goes down — notifications are the backbone of user engagement. The problem? Most teams wire up each channel separately, managing different APIs, rate limits, and credentials for every provider.

Self-hosted notification infrastructure solves this by providing a single platform that routes, templates, and delivers messages across every channel you need. In this guide, we compare three open-source tools that represent three distinct approaches to this problem: Novu (full notification orchestration), Apprise (universal notification library), and ntfy (simple HTTP push server).

Why Self-Host Your Notification Infrastructure?

Cloud notification services like SendGrid, Twilio, OneSignal, and Firebase are easy to integrate — until they aren’t. Vendor lock-in means rewriting your notification layer every time you switch providers. Usage-based pricing scales unpredictably as your user base grows. And for teams handling sensitive data, sending every notification through a third-party API introduces compliance risk.

Self-hosted notification platforms give you:

• Full data ownership — notification logs, subscriber data, and delivery metrics stay on your servers
• Predictable costs — no per-message fees, no surprise overage charges
• Channel flexibility — swap email providers, SMS gateways, or push services without code changes
• Unified API — one integration point for every notification channel your app uses
• Offline resilience — notifications keep working even when external services have outages

What Each Tool Does

Novu — Full Notification Orchestration Platform

Novu is the most comprehensive open-source notification infrastructure available. With over 38,800 GitHub stars and active daily development, it provides a complete platform for managing notifications across email, SMS, push, chat (Slack, Discord, Teams), and in-app notification centers.

Novu’s standout feature is its provider routing system. You can configure fallback chains (e.g., “try SendGrid first, fall back to SES if it fails”) and A/B test different providers — all without changing application code. The digest system aggregates multiple notifications into a single message (e.g., “You have 5 new comments” instead of 5 separate emails), reducing notification fatigue.

Apprise — Universal Notification Aggregation Library

Apprise takes a fundamentally different approach. Rather than being a standalone service, it’s a Python library that unifies sending notifications to 80+ platforms through a single, simple API call. With 16,400 stars and a decade of maturity, it’s the Swiss Army knife of notification delivery.

Apprise shines when you need to blast the same notification to many different platforms simultaneously. A single command can notify your team on Discord, your on-call engineer via SMS, and log to a webhook — all from one apprise call. It has no UI, no subscriber management, and no template engine. It’s a delivery mechanism, not a platform.

Ntfy — Simple HTTP Push Notification Server

Ntfy is the minimalist option. A single Go binary that provides an HTTP-based pub/sub notification server. With 29,800 stars, it’s the most popular simple push notification tool in the open-source ecosystem. Send a curl command, get a notification on your phone. That’s it.

Ntfy is designed for server-to-user notifications. Monitor scripts, cron jobs, and CI pipelines send notifications via simple curl commands or HTTP POST requests. Users subscribe to topics and receive push notifications on their phone through the ntfy Android/iOS app or web UI.

Comparison Table

Installing Novu

Novu requires MongoDB and Redis as dependencies. The community edition ships with a Docker Compose setup that handles everything:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

name: novu
services:
  redis:
    image: "redis:alpine"
    container_name: redis
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  mongodb:
    image: mongo:8.0.17
    container_name: mongodb
    restart: unless-stopped
    environment:
      - MONGO_INITDB_ROOT_USERNAME=novu
      - MONGO_INITDB_ROOT_PASSWORD=novu_password_here
    volumes:
      - mongodb:/data/db
    ports:
      - 27017:27017

  api:
    image: "ghcr.io/novuhq/novu/api:3.15.0"
    depends_on:
      mongodb:
        condition: service_healthy
      redis:
        condition: service_healthy
    container_name: api
    restart: unless-stopped
    environment:
      NODE_ENV: production
      MONGO_URL: mongodb://novu:novu_password_here@mongodb:27017/novu
      REDIS_HOST: redis
      REDIS_PORT: 6379
      JWT_SECRET: your-jwt-secret-change-this
      STORE_ENCRYPTION_KEY: your-32-char-encryption-key
    ports:
      - "3000:3000"

volumes:
  mongodb:

Start the stack:

1

docker compose -f docker-compose.yml up -d

Once running, access the dashboard at http://localhost:3000. Create an organization, configure your email provider (SendGrid, SES, Mailgun, etc.), and start building notification workflows.

Sending a Notification via Novu API

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

curl -X POST http://localhost:3000/v1/events/trigger \
  -H "Authorization: ApiKey YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "order-confirmed",
    "to": {
      "subscriberId": "user_123",
      "email": "customer@example.com"
    },
    "payload": {
      "orderNumber": "ORD-2026-0421",
      "total": "$49.99"
    }
  }'

Installing Apprise

Apprise is a Python library you install via pip. There’s no server to run:

1

pip install apprise

Sending Notifications with Apprise

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

import apprise

# Create an Apprise instance
apobj = apprise.Apprise()

# Add multiple notification services in a single call
apobj.add('mailto://user:pass@gmail.com')
apobj.add('discord://webhook_id/webhook_token')
apobj.add('ntfy://ntfy.example.com/my-topic')
apobj.add('slack://tokenA/tokenB/tokenC')

# Send to all configured services
apobj.notify(
    title='Server Alert',
    body='Disk usage exceeded 90% on production-db-01',
)

Apprise also ships with a CLI tool and an optional API server (apprise api):

1
2
3
4
5
6
7
8
9

# CLI: send to multiple services at once
apprise -t "Deployment Complete" \
  -b "v2.4.1 deployed to production" \
  discord://webhook_id/webhook_token \
  mailto://user:pass@smtp.example.com \
  ntfy://ntfy.example.com/deployments

# Using a configuration file
apprise -t "Alert" -b "Message" --config=/etc/apprise.yml

A sample Apprise configuration file:

1
2
3
4
5

urls:
  - mailto://smtp.gmail.com?user=admin&pass=app_password&to=team@example.com
  - discord://webhook_id/webhook_token
  - tgram://bot_token/chat_id
  - ntfy://ntfy.example.com/alerts?priority=high

Installing Ntfy

Ntfy is a single binary — no databases, no dependencies:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Docker Compose deployment
services:
  ntfy:
    image: binwiederhier/ntfy
    container_name: ntfy
    command:
      - serve
    environment:
      - TZ=UTC
    volumes:
      - /var/cache/ntfy:/var/cache/ntfy
      - /etc/ntfy:/etc/ntfy
    ports:
      - 80:80
    restart: unless-stopped

1

docker compose up -d

Sending Notifications with Ntfy

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Simple curl-based notification
curl -d "Deployment v2.4.1 completed successfully" \
  ntfy.example.com/deployments

# With priority, tags, and title
curl \
  -H "Priority: urgent" \
  -H "Title: Build Failed" \
  -H "Tags: warning,skull" \
  -d "Unit test failures in commit abc1234" \
  ntfy.example.com/ci-alerts

# Attach a file
curl -T /var/log/app-error.log \
  ntfy.example.com/logs?filename=error.log

Ntfy also supports real-time subscriptions via Server-Sent Events and WebSocket. Subscribe to a topic from a terminal:

1
2

# Subscribe to a topic (prints notifications as they arrive)
curl -s ntfy.example.com/my-topic/sse

For mobile access, install the ntfy Android app or iOS app and subscribe to your server’s topics.

Choosing the Right Tool

The decision depends on what you’re building:

Choose Novu if:

• You’re building a SaaS product that sends notifications to end users
• You need an in-app notification center with a ready-made React widget
• You want template management, digest scheduling, and subscriber preferences
• You need multi-provider failover (e.g., SendGrid → SES fallback)
• Your team needs a visual dashboard to manage notification workflows

Choose Apprise if:

• You need to send notifications to many different platforms from scripts
• You want a lightweight, dependency-free solution
• You’re building a homelab and need alerts across Discord, email, and Telegram
• You prefer a library you embed in your code rather than a service to manage
• You need support for obscure notification channels (Pushover, Matrix, IFTTT)

Choose Ntfy if:

• You need a dead-simple push notification server for monitoring and CI/CD
• You want curl-based notifications with zero configuration
• You need real-time subscriptions (WebSocket/SSE) for live dashboards
• You want native mobile apps without setting up Firebase/FCM
• You value simplicity over features — one binary, no database required

For related reading, see our Gotify vs ntfy push notification comparison for a deeper look at simple push servers, and the webhook relay guide for routing external webhooks to self-hosted services. If you manage on-call rotations, check our incident management platforms comparison for coordinating alert response.

FAQ

Can I use Novu without MongoDB?

No. Novu uses MongoDB as its primary data store for subscribers, templates, messages, and workflows. Redis is also required for the job queue. There is no alternative database support currently. If you want to avoid MongoDB, consider Apprise (stateless, no database) or ntfy (optional SQLite).

Does Apprise support two-way communication?

No. Apprise is a one-way notification delivery tool. It sends messages but does not receive responses. If you need interactive notifications (e.g., “reply to approve deployment”), look at Novu’s in-app notification center or ntfy’s topic subscriptions with client-side reply handling.

How does ntfy handle authentication?

Ntfy supports multiple authentication modes: anonymous access (anyone can publish/subscribe to public topics), access control lists with username/password, and access tokens. You can configure per-topic permissions in /etc/ntfy/server.yml:

1
2
3
4
5
6

auth:
  authentication: true
  authorization:
    - topic: alerts
      write: ["admin", "monitoring"]
      read: ["*"]

Can Novu send notifications to Telegram or Discord?

Yes. Novu supports chat channel integrations including Slack, Discord, and Microsoft Teams. You configure the webhook URL in the Novu dashboard, then trigger notifications to the chat channel the same way you’d trigger an email or SMS. Apprise also supports these channels natively with 80+ integrations total.

Is it possible to run all three tools together?

Absolutely. A common architecture uses Novu as the primary notification platform for user-facing messages (order confirmations, password resets), Apprise embedded in deployment scripts for team alerts, and ntfy as a simple alerting channel for server monitoring. They complement each other rather than compete.

What happens to notifications if Novu goes down?

Novu has built-in retry logic with configurable retry policies per workflow. Failed deliveries are queued and retried according to your settings. For critical systems, you can configure provider fallback chains so that if your primary email provider fails, Novu automatically switches to a backup provider.

Does ntfy work behind a reverse proxy?

Yes. Ntfy works with any standard HTTP reverse proxy (Nginx, Caddy, Traefik). You’ll need to configure WebSocket proxying for real-time subscriptions to work. A basic Nginx configuration:

1
2
3
4
5
6
7
8

location / {
    proxy_pass http://localhost:80;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}