Best Self-Hosted Notification Services

Quick Picks

Use Case	Best Choice	Why
Best overall	ntfy	UnifiedPush support, web/mobile apps, rich features, active development
Best lightweight	Gotify	Single Go binary, minimal resource usage, plugin system
Best multi-service relay	Apprise	Routes to 100+ services (Slack, Discord, Telegram, email), no built-in UI for end users
Best for homelab alerts	ntfy	Easy curl/webhook integration, topic-based pub/sub, free tier available

Why Self-Host Notifications?

Third-party push services charge per message, lock you into their ecosystem, and route your alerts through external infrastructure. Self-hosted notification services give you unlimited messages, full control over delivery, and zero dependency on someone else’s uptime.

The three main options serve different purposes. ntfy and Gotify are end-user push notification servers — they deliver messages to phones and browsers. Apprise is a notification relay — it takes one message and fans it out to dozens of services. Understanding this distinction is key to picking the right tool.

The Full Ranking

1. ntfy — Best Overall

ntfy is a pub/sub notification service built in Go. You publish messages to topics via HTTP PUT/POST, and subscribers receive them instantly on Android, iOS, or the web UI. It supports UnifiedPush, making it a drop-in replacement for Google’s FCM push infrastructure.

What makes it stand out:

• Topic-based pub/sub model — no accounts needed for basic use
• UnifiedPush provider — works with any UnifiedPush-compatible Android app
• Rich notifications: titles, priorities, tags, action buttons, file attachments
• Easy integration — a single curl command sends a notification
• Web UI, Android app (F-Droid + Play Store), iOS app
• Access control with user accounts and ACLs
• Runs on ~30 MB of RAM

Docker setup:

services:
  ntfy:
    image: binwiederhier/ntfy:v2.17.0
    container_name: ntfy
    command: serve
    volumes:
      - ntfy-cache:/var/cache/ntfy
      - ntfy-data:/var/lib/ntfy
      - ntfy-config:/etc/ntfy
    ports:
      - "8080:80"
    environment:
      - TZ=UTC
      - NTFY_BASE_URL=https://ntfy.example.com
      - NTFY_CACHE_FILE=/var/cache/ntfy/cache.db
      - NTFY_AUTH_FILE=/var/lib/ntfy/user.db
      - NTFY_AUTH_DEFAULT_ACCESS=deny-all
      - NTFY_BEHIND_PROXY=true
    restart: unless-stopped

volumes:
  ntfy-cache:
  ntfy-data:
  ntfy-config:

Pros:

• UnifiedPush support replaces Google FCM entirely
• Topic-based model is dead simple — no API keys for basic use
• Rich notification features (priorities, actions, attachments)
• Active development with frequent releases
• Low resource usage (~30 MB RAM)

Cons:

• iOS app is less mature than Android
• Access control requires manual user management
• No built-in integration with monitoring tools (need webhooks)

Best for: Anyone who wants a general-purpose push notification server. The UnifiedPush support alone makes it the default choice for de-Googled Android setups.

[Read our full guide: How to Self-Host ntfy]

2. Gotify — Best Lightweight Option

Gotify is a minimal push notification server written in Go. It focuses on doing one thing well: receiving messages via REST API and pushing them to clients. The web UI doubles as a notification inbox, and the Android app provides real-time push via WebSocket.

What sets it apart:

• Extremely lightweight — single binary, ~15 MB image
• Plugin system for extending functionality
• Application-based model — each sender gets its own API token
• WebSocket-based real-time delivery
• Markdown support in messages
• Priority levels with configurable notification behavior

Pros:

• Simplest setup of the three — one container, one port
• Lowest resource usage (~20 MB RAM idle)
• Clean, functional web UI
• Plugin architecture for custom integrations
• Application tokens provide per-sender access control

Cons:

• No UnifiedPush support
• No iOS app (Android only + web)
• No topic-based pub/sub — each integration needs its own app token
• Smaller community than ntfy

Best for: Homelab users who want the simplest possible notification server. If you don’t need UnifiedPush or iOS support, Gotify is the lightest option.

[Read our full guide: How to Self-Host Gotify]

3. Apprise — Best Notification Relay

Apprise is fundamentally different from ntfy and Gotify. It’s not a push notification server — it’s a notification relay that takes a single message and delivers it to 100+ services simultaneously. Think of it as a universal notification adapter.

Supported targets include: Slack, Discord, Telegram, Email (SMTP), Pushover, Pushbullet, ntfy, Gotify, Matrix, Mattermost, Microsoft Teams, IFTTT, AWS SNS, and dozens more.

Where Apprise shines:

• One API call → notifications on every platform you use
• URL-based configuration — each target is a single URL string
• REST API for programmatic use
• Uptime Kuma has native Apprise integration
• Supports persistent configuration files (YAML/text)

Pros:

• Unmatched breadth — 100+ notification targets
• Perfect companion to monitoring tools (Uptime Kuma, Grafana)
• Simple REST API
• Stateless — fire-and-forget design
• Configuration via URL strings is elegant

Cons:

• No end-user mobile app — it relays to OTHER services
• No message persistence — if a target is down, the message is lost
• No built-in authentication — needs reverse proxy auth for internet-facing setups
• Not a replacement for ntfy/Gotify — it complements them

Best for: Server admins who want one integration point for all their alerts. Pair Apprise with ntfy or Gotify for the best of both worlds — Apprise fans out server alerts, ntfy/Gotify delivers to your phone.

[Read our full guide: How to Self-Host Apprise]

Full Comparison Table

Feature	ntfy	Gotify	Apprise
Type	Push notification server	Push notification server	Notification relay
Language	Go	Go	Python
Docker image size	~35 MB	~15 MB	~100 MB
RAM usage (idle)	~30 MB	~20 MB	~50 MB
Web UI	Yes (notification inbox)	Yes (notification inbox)	Yes (admin/test)
Android app	Yes (Play Store + F-Droid)	Yes (F-Droid + GitHub)	No
iOS app	Yes	No	No
UnifiedPush	Yes	No	No
Message persistence	Yes (SQLite cache)	Yes (SQLite)	No (fire-and-forget)
Authentication	User accounts + ACLs	Application tokens	None (needs reverse proxy)
Notification targets	Own clients only	Own clients only	100+ external services
Attachments	Yes (up to 15 MB)	No	Via target service
Priority levels	5 levels	10 levels	Via target service
Action buttons	Yes (view, broadcast, HTTP)	No	No
Plugin system	No	Yes	No
License	Apache 2.0 / GPL 2.0	MIT	BSD 3-Clause
GitHub stars	20k+	12k+	11k+

How They Work Together

These tools aren’t mutually exclusive. The strongest notification setup combines them:

1. ntfy as your primary push notification server — receives alerts and delivers to your phone/browser
2. Apprise as a relay layer — monitoring tools send to Apprise, which fans out to ntfy + Slack + email + wherever else you want
3. Gotify as an alternative if you want something lighter than ntfy and don’t need UnifiedPush

A typical homelab notification flow:

Uptime Kuma → Apprise API → ntfy topic + Slack channel + Email
Grafana → ntfy webhook → Phone notification
Cron job → curl ntfy → Phone notification

How We Evaluated

We tested each tool in Docker on a homelab setup, focusing on: ease of setup, resource usage, notification delivery speed, mobile app quality, and integration options. All tools were tested with Uptime Kuma and manual curl commands.

Related

• How to Self-Host ntfy
• How to Self-Host Gotify
• How to Self-Host Apprise
• ntfy vs Gotify: Push Notifications Compared
• Apprise vs ntfy: Notification Tools Compared
• Apprise vs Gotify: Notification Tools Compared
• Best Self-Hosted Monitoring Tools
• Best Self-Hosted Dashboards
• Docker Compose Basics
• Reverse Proxy Setup