What Is Apprise?

Apprise is a notification aggregator that sends alerts to over 100 services through a single API. Instead of writing separate integrations for Slack, Discord, Telegram, email, Pushover, and every other notification platform, you configure Apprise once and send to all of them with one HTTP call. It includes a web UI for managing notification targets and a REST API for programmatic use. Perfect for connecting your self-hosted monitoring stack to the notification channels your team actually uses.

Official site · GitHub · Supported services

Prerequisites

A Linux server (Ubuntu 22.04+ recommended)
Docker and Docker Compose installed (guide)
512 MB of free RAM
1 GB of free disk space

Docker Compose Configuration

Apprise runs as a single lightweight container with an Nginx frontend and Python backend.

Create a docker-compose.yml file:

services:
  apprise:
    image: caronc/apprise:1.3.1
    container_name: apprise
    restart: unless-stopped
    ports:
      - "8000:8000"
    volumes:
      - apprise_config:/config      # Persistent notification configurations
      - apprise_attach:/attach      # Attachment storage for file-based notifications
    environment:
      - APPRISE_STATEFUL_MODE=simple     # "simple" or "hash" — simple uses human-readable config keys
      - APPRISE_WORKER_COUNT=1           # Gunicorn workers — increase for high-volume setups
      - APPRISE_ATTACH_SIZE=15           # Max attachment size in MB
      - APPRISE_BODY_SIZE_MAX=65536      # Max notification body size in bytes

volumes:
  apprise_config:
  apprise_attach:

Start the stack:

docker compose up -d

The web UI is available immediately at http://your-server-ip:8000.

Initial Setup

Open http://your-server-ip:8000 in your browser
You’ll see the Apprise configuration manager UI
Click Configuration Manager to create notification targets
Add URLs using Apprise URL syntax (documented below)

Adding Notification Targets

Apprise uses URL-based configuration. Each notification service has a specific URL format:

Service	URL Format
Slack	`slack://TokenA/TokenB/TokenC/Channel`
Discord	`discord://WebhookID/WebhookToken`
Telegram	`tgram://BotToken/ChatID`
Email (SMTP)	`mailto://user:[email protected][email protected]`
Pushover	`pover://UserKey@AppToken`
Gotify	`gotify://hostname/token`
Ntfy	`ntfy://topic` or `ntfys://ntfy.example.com/topic`
Matrix	`matrix://user:pass@hostname/#room`
Webhook	`json://your-webhook-url`

Full list: Apprise supported services

Persistent Configuration

Store notification URLs in a named configuration using the API:

# Save a configuration called "homelab"
curl -X POST http://localhost:8000/add/homelab \
  -H "Content-Type: application/json" \
  -d '{"urls": ["discord://WebhookID/WebhookToken", "tgram://BotToken/ChatID"]}'

Sending Notifications

Via REST API

# Send to a saved configuration
curl -X POST http://localhost:8000/notify/homelab \
  -H "Content-Type: application/json" \
  -d '{"title": "Server Alert", "body": "Disk usage at 90%", "type": "warning"}'

Via Stateless API (no saved config needed)

curl -X POST http://localhost:8000/notify \
  -H "Content-Type: application/json" \
  -d '{
    "urls": ["discord://WebhookID/WebhookToken"],
    "title": "Quick Alert",
    "body": "Something happened"
  }'

Notification Types

Type	Purpose
`info`	Informational (default)
`success`	Success notification
`warning`	Warning alert
`failure`	Error/failure alert

The notification type affects formatting on services that support it — Discord embeds change color, email subjects get prefixed, etc.

Integration with Self-Hosted Monitoring

Apprise works well as a notification hub for your monitoring stack:

Monitoring Tool	Integration Method
Uptime Kuma	Built-in Apprise support (just enter the Apprise API URL)
Grafana	Webhook alert channel pointing to Apprise API
Prometheus	Alertmanager webhook receiver
Netdata	Custom notification script calling Apprise API
Shell scripts	`curl` to the Apprise REST API
Portainer	Webhook notifications to Apprise

Uptime Kuma Integration

Uptime Kuma has native Apprise support. In Uptime Kuma’s notification settings:

Select Apprise (URL) as the notification type
Enter http://apprise:8000/notify/homelab (if on the same Docker network) or the full URL
Test the notification

Configuration

Security

Apprise has no built-in authentication. For production use, place it behind a reverse proxy with authentication:

    # Add to environment if you want to restrict API access
    environment:
      - APPRISE_API_KEY=your-secret-api-key    # Requires this key in API requests

Alternatively, use Authelia or Authentik in front of Apprise via your reverse proxy.

Stateful Modes

Mode	Description
`simple`	Config keys are human-readable names (e.g., `homelab`, `alerts`)
`hash`	Config keys are SHA1 hashes of the tag name (harder to guess)

Use simple for internal homelabs. Use hash if the API is exposed beyond your LAN.

Backup

The only critical data is the config volume:

docker run --rm -v apprise_config:/data -v $(pwd):/backup alpine \
  tar czf /backup/apprise_config_$(date +%Y%m%d).tar.gz /data

Configurations are stored as text files — small and easy to back up. For automated backups, see Backup Strategy.

Troubleshooting

Notifications not arriving

Symptom: API returns 200 but no notification appears on the target service.

Fix: Check the URL syntax. Apprise silently fails on malformed URLs. Test with the web UI first — it shows error details. Also verify your service tokens/webhooks are still valid.

”Connection refused” from other containers

Symptom: Uptime Kuma or other Docker services can’t reach Apprise.

Fix: Use the Docker service name (apprise) not localhost. Ensure both services are on the same Docker network, or use the host IP.

Large attachments rejected

Symptom: File-based notifications fail with size errors.

Fix: Increase APPRISE_ATTACH_SIZE (default 15 MB). Also check your reverse proxy’s upload limit.

Resource Requirements

RAM: ~50 MB idle, ~150 MB under load
CPU: Minimal — notification sending is I/O-bound, not CPU-bound
Disk: <100 MB for the application, plus attachment storage

Apprise is one of the lightest self-hosted services you can run. It’s a good candidate for running alongside other services on resource-constrained hardware like a Raspberry Pi.

Verdict

Apprise solves the “too many notification services” problem cleanly. Instead of configuring Slack webhooks, Discord bots, Telegram bots, and email alerts separately in every monitoring tool, you point everything at Apprise and manage notification targets in one place. The REST API is dead simple, and the URL-based configuration means you can version-control your notification setup.

The main limitation is the lack of built-in authentication — you’ll want a reverse proxy for anything internet-facing. For push notifications to your phone specifically, Ntfy is more focused. For a full notification relay with persistent message storage, Gotify is better. But as a universal notification aggregator that ties your entire homelab together, Apprise is unmatched.