Self-hosted Pushover alternative: instant push you own with ntfy

Every backup script, every server that falls over at 3 a.m., every long-running job that finally finishes — all of it wants to tell you something. The usual answer is a hosted push service like Pushover: pay per platform, stay under the monthly message cap, and route every ping through someone else's servers. It works, but it quietly turns a one-line `curl` into a metered dependency someone else owns. ntfy is the alternative you run yourself — instant push to your phone and desktop from a plain HTTP request, with no third party in the middle.

What ntfy is

ntfy (pronounced "notify") is an open-source push notification service you host yourself. You publish a message by sending a simple HTTP request to a topic — `curl -d "Backup done" https://your-server/alerts` — and it arrives as a push notification on every phone, desktop and browser subscribed to that topic. That's the whole model. No SDK to embed, no client library required, no account needed just to fire a message.

It ships genuine mobile apps for Android and iOS, a full web app, and a server that speaks the same plain HTTP as everything else. Where Pushover sells a one-time app purchase per platform and caps its free API at a fixed number of messages a month, ntfy has no seat count and no message meter beyond whatever your own server can comfortably handle. It's the complete tool, not a trial tier waiting to upsell you.

The features that actually matter

• Publish from anything that speaks HTTP — a `curl`, a cron line, a Python script, a webhook, a home-automation rule. If it can make a request, it can notify you. No SDK, no client library, just a URL.
• Five priority levels — from min (silent, buried in the list) up to max/urgent (pops over, vibrates, keeps making noise). The 3 a.m. disk-full alert and the "your export is ready" ping don't have to feel the same.
• Titles, tags, emoji and a click action — give a message a title, attach tags that render as emoji (a green check, a rotating light, a skull), and set a tap-through URL so a notification jumps straight to the dashboard it's about.
• Action buttons — a notification can carry up to three buttons that open a URL, fire another HTTP request, or trigger an Android intent. Approve a deploy or restart a service straight from the notification shade.
• Attachments and icons — send an image, a log file or any file alongside the message, with a per-message icon. Included as standard, not a paid tier.
• Scheduled and delayed delivery — tell ntfy to deliver "in 30 min" or "tomorrow at 9 a.m." and it holds the message server-side until the moment you asked for, anywhere from ten seconds to three days out.
• Users, tokens and per-topic access control — lock a self-hosted server down with accounts, access tokens and read/write permissions per topic, so only the right scripts publish and only you subscribe.
• UnifiedPush distributor — ntfy can route push for other apps, like Matrix and Mastodon clients, through your own server instead of Google's, taking a chunk of your phone's push traffic off Google's rails.

Why self-host it instead of the hosted version

Three reasons.

Your alerts stay yours. Notifications are a map of your life and infrastructure — when your backups run, when your front door opens, when a payment lands. A hosted push service sees all of it in the clear as it passes through. On your own ntfy server, those messages never leave a machine you control.

The cost doesn't scale with you. Pushover is a per-platform purchase with a monthly ceiling on the free API, and team plans bill per user per month. A self-hosted ntfy server sends as many notifications to as many of your own devices as you like for the flat cost of the box it runs on. Add a hundred scripts and a dozen devices and the bill doesn't move.

It's yours to shape. Your own topic names, your own domain, your own retention and rate limits, your own auth policy. No app-purchase gate between you and a feature, and no vendor deciding one day that instant delivery is now a paid add-on.

Who it's for

• Homelabbers and sysadmins who want their cron jobs, backup scripts, Proxmox boxes and Docker stacks to ping them directly — no SaaS account, just a `curl` at the end of a script.
• Home-automation tinkerers running Home Assistant or Node-RED who want "the garage is still open" on their phone without wiring in a third-party push cloud.
• Developers and small teams who'd rather point a Grafana alert, a CI pipeline or a webhook at a URL they own than buy an app license per platform and watch a monthly message counter tick down.

The honest setup notes

Rolling your own ntfy is a real service, and a few things come with that. Android delivery is already Google-free — point the app at your own server and it uses ntfy's instant-delivery mode, a persistent connection you'll see as one permanent notification, with no Firebase in the loop. That costs a sliver of battery and a notification that never fully goes away, which is the trade. iOS is the sharp edge. Apple only wakes an app through its own push network, so a self-hosted server can't deliver instantly on its own — you point an `upstream-base-url` at ntfy.sh and your server forwards a tiny poll-request (just a message ID) upstream to wake the app, which then fetches the real message from your box. The content still never leaves your server; only that wake-up ping rides a shared path. Skip the config and iOS delivery drops from instant to eventually, sometimes hours later. Some of the best bits need wiring up — email publishing wants an SMTP server, and text-to-speech phone calls need a Twilio account. And like anything you host, the server wants updates, a backup of its message cache and auth database, and enough resources to stay responsive.

None of that is hard, exactly — it's just yours to keep running. Or let us run it. We handle the container, the TLS, the updates and the backups, and hand you a working ntfy server with your data intact.

Deploy it in one click

The do-it-yourself path is a Docker container, a config file, a reverse proxy with a valid TLS certificate (the browser web-app won't do push without one, and you don't want auth tokens crossing plain HTTP), a topic-permission scheme and a maintenance habit. It's well-documented and entirely doable — and it's an evening you don't get back, plus the ongoing upkeep.

On Caliber Node you deploy ntfy in one click. We stand up the server, terminate TLS on a real certificate, keep the image current and back the whole thing up on a schedule. You get a clean URL, full access to the config and logs, SFTP into the files, and the freedom to export or move your data whenever you want. The one-line-`curl` simplicity ntfy is famous for, without the server-babysitting that usually comes attached.

First run

1. Open your ntfy web app at your new server's URL and sign in with the admin account we set up for you.
2. Pick a topic name — something unguessable like `alerts-7f3a` — and subscribe to it in the web app.
3. Install the mobile app (Android or iOS), point it at your server, and subscribe to the same topic so pushes reach your pocket.
4. Fire your first notification from any terminal: `curl -d "It works" https://your-server/alerts-7f3a`. It should land on both instantly.
5. Add priority and a tag to make it real: `curl -H "Priority: high" -H "Tags: warning" -d "Backup failed" https://your-server/alerts-7f3a`, then drop that line into an actual script.

The bigger picture

Notifications are the nervous system of everything you run — the quiet channel that tells you when something needs you. Handing that channel to a service that meters it, and reads it, is a strange thing to do with information this personal. Self-hosting ntfy puts the whole nervous system back under your own roof: your topics, your rules, your devices, your data. It's a small tool that touches a surprising amount of your life, which is exactly why owning it matters.

Deploy ntfy in a few minutes →

Or browse the full app catalog.

One-click self-hosted apps, managed for you — real logs, SFTP, and your data always exportable. Never a black box.