Monitoring Apprise API with Vigilmon

Apprise is the de-facto open-source multi-notification hub: a single POST request fans out to Slack, Discord, Telegram, PagerDuty, email, Pushover, Ntfy, Gotify, Matrix, and 90+ other channels. The self-hosted apprise-api server exposes a REST HTTP interface so any script or application can send notifications by calling one endpoint rather than integrating with each service directly. When the Apprise API server is unavailable — whether due to a container restart, a misconfigured reverse proxy, or a silently broken notification channel — your alerting pipeline fails without any immediate signal. Vigilmon gives you external monitoring for Apprise API web UI availability, REST health endpoint responses, notification delivery health, and SSL certificate expiry so you catch Apprise failures before they mean missed alerts.

What You'll Set Up

• Apprise API web UI availability via HTTP monitor
• /status/ health endpoint availability and JSON response validation
• Notification delivery health via /notify/ POST endpoint heartbeat probe
• SSL certificate expiry alerts for HTTPS-proxied Apprise deployments
• Scheduled notification channel reachability via Apprise Stateful Tags heartbeat

Prerequisites

• Apprise API server (apprise-api) running via Docker or pip, accessible on port 8000
• A configured notification key (Apprise stateful configuration key) set up for at least one notification channel
• A free Vigilmon account

Step 1: Monitor Apprise API Web UI Availability

The Apprise API web UI serves a browser-based interface at the root path and also exposes a /apprise/ health check path depending on your reverse proxy configuration. Monitor the HTTP endpoint to confirm the API server is accepting requests:

1. In Vigilmon, click Add Monitor → HTTP/HTTPS.
2. Enter your Apprise API URL: http://your-server:8000/ (or https://apprise.yourdomain.com/ if proxied).
3. Set Check interval to 2 minutes.
4. Set Expected HTTP status to 200.
5. Set Alert channels to your preferred notification method.
6. Click Save.

If you proxy Apprise behind Nginx or Traefik with a path prefix, the health check URL is typically https://apprise.yourdomain.com/apprise/. Verify by visiting the URL in a browser and confirming the Apprise API welcome page loads.

Vigilmon checks this URL from multiple probe regions — a 200 response that comes from multiple geographically distributed probes confirms the API is genuinely reachable, not just accessible from your local network.

Step 2: Monitor the /status/ Health Endpoint

Apprise API exposes a dedicated /status/ endpoint that returns a JSON response confirming the server is running and accepting requests. This is more authoritative than checking the root path because it exercises the API's request processing path directly:

1. In Vigilmon, click Add Monitor → HTTP/HTTPS.
2. Enter the URL: http://your-server:8000/status/
3. Set Check interval to 2 minutes.
4. Set Expected HTTP status to 200.
5. Under Response body check, add a keyword match: "status": "ok" (or the exact JSON key your Apprise API version returns).
6. Click Save.

To find the exact response format your server returns, query it directly:

curl -s http://your-server:8000/status/ | python3 -m json.tool

A healthy response looks like:

{
  "status": "ok",
  "version": "0.9.9"
}

If the body check keyword is missing — meaning the endpoint returns 200 but with unexpected content — Vigilmon triggers an alert. This catches cases where a reverse proxy intercepts the request and returns a 200 maintenance page instead of the actual Apprise API response.

Step 3: Monitor Notification Delivery via /notify/ Heartbeat Probe

The most meaningful health check for Apprise is confirming it can actually deliver notifications — not just that the API server is running. Use a Vigilmon cron heartbeat with a scheduled probe that sends a test notification through Apprise to a dedicated canary channel:

1. In Vigilmon, click Add Monitor → Cron Heartbeat.
2. Set Expected ping interval to 10 minutes.
3. Copy the heartbeat URL (e.g., https://vigilmon.online/heartbeat/abc123).

Create a delivery probe script that sends a test notification via Apprise's /notify/:key/ endpoint and pings the Vigilmon heartbeat only on success:

#!/bin/bash
# /usr/local/bin/apprise-delivery-check.sh

APPRISE_URL="http://your-server:8000"
APPRISE_KEY="your-notification-key"      # The stateful config key
HEARTBEAT_URL="https://vigilmon.online/heartbeat/abc123"
TIMEOUT=30

# Send a test notification via Apprise /notify/ endpoint
HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" \
  --max-time "$TIMEOUT" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"title": "Apprise Health Check", "body": "Vigilmon delivery probe - OK"}' \
  "${APPRISE_URL}/notify/${APPRISE_KEY}/")

if [ "$HTTP_CODE" = "200" ]; then
  echo "Apprise notification delivered via key '${APPRISE_KEY}': HTTP ${HTTP_CODE}"
  curl -s "$HEARTBEAT_URL"
else
  echo "Apprise notification delivery failed: HTTP ${HTTP_CODE}"
  exit 1
fi

Install as a cron job:

chmod +x /usr/local/bin/apprise-delivery-check.sh
(crontab -l 2>/dev/null; echo "*/10 * * * * /usr/local/bin/apprise-delivery-check.sh >> /var/log/apprise-delivery-check.log 2>&1") | crontab -

Set up a dedicated Apprise canary notification key that routes to a low-noise channel (e.g., a private Slack channel named #apprise-health or a Ntfy topic). When the Vigilmon heartbeat stops arriving, it means either the Apprise API is down, the notification key is misconfigured, or the downstream notification service (Slack, Telegram, etc.) is rejecting deliveries.

Step 4: Monitor Notification Channel Reachability via Stateful Tags

Apprise Stateful Tags let you assign persistent notification configurations to a key. If you use Apprise for scheduled notifications (e.g., nightly backup alerts, cron job completion notices), you need to verify the configured channels remain reachable over time. Channel URLs can break silently when API tokens expire or webhook URLs are rotated:

#!/bin/bash
# /usr/local/bin/apprise-channel-check.sh

APPRISE_URL="http://your-server:8000"
HEARTBEAT_URL="https://vigilmon.online/heartbeat/def456"
TIMEOUT=15

# List configured keys and verify at least one exists
HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" \
  --max-time "$TIMEOUT" \
  "${APPRISE_URL}/get/")

if [ "$HTTP_CODE" = "200" ]; then
  # Check that the config endpoint returns valid JSON with at least one key
  KEYS=$(curl -s --max-time "$TIMEOUT" "${APPRISE_URL}/get/" | python3 -c "
import sys, json
try:
    data = json.load(sys.stdin)
    print(len(data))
except:
    print(0)
" 2>/dev/null || echo 0)

  if [ "$KEYS" -gt 0 ]; then
    echo "Apprise config OK: ${KEYS} notification key(s) configured"
    curl -s "$HEARTBEAT_URL"
  else
    echo "Apprise config empty: no notification keys found"
    exit 1
  fi
else
  echo "Apprise config endpoint unreachable: HTTP ${HTTP_CODE}"
  exit 1
fi

Run this check every 15 minutes. A missing or empty configuration indicates the Apprise API's persistent storage has been reset (e.g., a container was recreated without mounting the config volume).

Step 5: SSL Certificate Monitoring for HTTPS-Proxied Apprise

Apprise API is typically deployed behind Nginx or Traefik with TLS termination. An expired SSL certificate blocks all API clients — any script calling https://apprise.yourdomain.com/notify/ will receive a certificate error and the notification will never be delivered. Set up a Vigilmon SSL monitor to alert before expiry:

1. In Vigilmon, click Add Monitor → SSL Certificate.
2. Enter your Apprise API hostname: apprise.yourdomain.com
3. Set Alert when certificate expires in less than 14 days.
4. Set Check interval to 1 day.
5. Click Save.

This tracks certificate expiry automatically. You receive an alert 14 days before expiry, giving time to renew via Let's Encrypt or your certificate authority before clients begin failing.

For Nginx deployments, verify your Apprise proxy block includes SSL properly:

server {
    listen 443 ssl;
    server_name apprise.yourdomain.com;

    ssl_certificate     /etc/letsencrypt/live/apprise.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/apprise.yourdomain.com/privkey.pem;

    location /apprise/ {
        proxy_pass         http://127.0.0.1:8000/;
        proxy_set_header   Host $host;
        proxy_set_header   X-Real-IP $remote_addr;
    }
}

If you use Traefik with automatic ACME certificate provisioning, Vigilmon's SSL monitor still provides an external second opinion — it confirms the certificate presented to external clients is valid, not just that Traefik's internal certificate store is populated.

Step 6: Set Up Alert Channels

Configure Vigilmon to route Apprise monitoring alerts to the right destination:

1. Go to Alert Channels in Vigilmon.
2. Add a webhook pointing to your Slack #infrastructure-alerts channel for web UI and health endpoint monitors.
3. Add email notification for the SSL certificate expiry monitor — certificate warnings are low urgency but should not be missed.
4. For the delivery heartbeat monitor, route alerts to PagerDuty or an on-call channel — a failed notification delivery probe means your alerting infrastructure itself is broken.

Set Consecutive failures before alert to 2 for the web UI monitor to avoid alerting on transient Docker container restarts (which complete within seconds under normal conditions).

Summary

| Monitor | Target | What It Catches | |---|---|---| | HTTP monitor (web UI) | http://your-server:8000/ | Container crash, Nginx misconfiguration, port binding failure | | HTTP monitor (/status/) | /status/ + JSON body check | API processing failure, maintenance page intercept | | Cron heartbeat (delivery) | /notify/:key/ POST probe | Notification delivery failure, broken channel URL, expired token | | Cron heartbeat (channels) | /get/ config endpoint | Lost configuration, missing volume mount | | SSL monitor | apprise.yourdomain.com | Certificate expiry, Let's Encrypt renewal failure |

Apprise's failure mode is silence — when the API server is down or a notification channel breaks, your applications continue calling the endpoint and receiving errors, but no alerts fire. Vigilmon's external monitoring makes the Apprise notification infrastructure itself observable, so a broken Apprise deployment doesn't mean broken alerting that you only discover when the next real incident occurs.

Start monitoring for free at vigilmon.online.