Gotify
$9.00 / month with a 7-day free trial and a $1.00 sign-up fee
Self-hosted push notification server — your *arr stack, Uptime Kuma, Watchtower, and any webhook-capable tool fan out alerts to one Android app on your phone.
A managed instance of Gotify on ElfHosted — the self-hosted push notification server with native Android app, simple REST API, and broad ecosystem support. Most self-host tools (Uptime Kuma, the *arr stack, Watchtower, Home Assistant) speak Gotify out of the box. BSD-3 licensed; lightweight Go binary; works without a Google or Apple push-vendor account.
Pushover wants $5/year-and-a-tier-for-each-platform. ntfy is great. Gotify is the third option that's been quietly popular since 2018, with the simpler integration story for fan-out from your existing self-host stack.
What is Gotify?
Gotify is a self-hosted push notification server. The model is straightforward: applications push messages to your Gotify server via simple HTTP POST; the official Android app (or a third-party iOS app) receives them in real time via WebSocket and surfaces them as native notifications. No Firebase Cloud Messaging, no APNs, no Google or Apple push-vendor entanglement. Lightweight Go binary, SQLite or Postgres backend, BSD-3 licensed.
Most self-host tools support Gotify natively or via webhook. Sonarr / Radarr / Prowlarr / Bazarr / Lidarr / Readarr all have Gotify connectors built in. Uptime Kuma's notification list includes Gotify. Watchtower (Docker container update tool), Home Assistant, Authelia, Vaultwarden, the *arr ecosystem, and dozens more push to Gotify out of the box. The result: one app on your phone for all the "hey, this thing happened" alerts from your self-host stack.
Features
- 📲 Official Android app — open-source, on F-Droid and Play Store, persistent WebSocket connection for real-time delivery without Firebase battery drain.
- 📱 iOS via third-party clients — apps like UnifiedPush-compatible clients (Notify, NeoPush) work with Gotify; no official iOS app, but the WebSocket protocol is simple enough that several third-party clients exist.
- 🔔 Application-scoped tokens — each pushing app gets its own token; rotate / revoke per-source if a token leaks.
- 🎚️ Per-message priority — 0-10 scale; priority 8+ overrides Do Not Disturb on Android. Set high-priority for "service down" alerts, low for "new episode downloaded".
- 📋 Plugin system — extend with first-party plugins (Telegram bridge, NTFY bridge, RSS poller) or build your own in Go.
- 🔧 Simple REST API — POST a message with a per-app token to
/message?token=...; one HTTP call from any shell script, cron job, or programming language. Easiest-possible integration story. - 🌐 WebSocket streaming — clients connect over WebSocket; messages arrive in milliseconds.
- 👥 Multi-user — separate user accounts; each user gets their own apps and clients.
- 🔓 FOSS & BSD-3-licensed — no premium tier, no per-message billing, no ad-supported free plan.
Gotify vs Other Push Notification Options
- vs. Pushover — Pushover is the polished commercial competitor; one-time $5 per platform (Android, iOS, desktop). Pushover has the better iOS story (official app, polished); Gotify has the cheaper open-source story (no per-platform fee, runs anywhere, no vendor account). For Android-first users, Gotify is structurally cheaper and equivalent in features.
- vs. ntfy.sh — ntfy is the more recently-popular self-hosted notification server; topic-based subscription model (subscribe to a URL, anyone with the URL can publish). Different model from Gotify's app-token-per-source. Ntfy is excellent for ad-hoc / "tell me when this script finishes" use; Gotify is excellent for "permanent integrations from my self-host stack" use. Many users run both for different needs.
- vs. Apprise — Apprise is a notification *router* (it speaks 100+ protocols and proxies between them). It's complementary to Gotify, not competing — Apprise can route notifications to Gotify, and Gotify is one of Apprise's many backends. Run Apprise if you want a single config that fans out to Gotify + email + Discord + Slack simultaneously.
- vs. Firebase Cloud Messaging directly — FCM is what Pushover and most commercial notification services use under the hood. Going direct to FCM means a Google Cloud account, an FCM project, server keys, signed APKs, etc. The whole point of Gotify is avoiding that.
- vs. Discord / Slack / Telegram bots — those work for "alerts on a chat channel". Gotify is "alerts on a phone notification". Different surfaces; many users send to both.
Why Run Gotify on ElfHosted?
Gotify is small (Go binary + SQLite) and easy to self-host, but the operational details matter for an always-on push surface:
- HTTPS with auto-renewing TLS — required for the Android app's WebSocket connection (browsers and mobile WebSocket libraries refuse non-HTTPS).
- External hosting — running Gotify on the same Pi that's also your media server means push notifications go offline when the media stack does (which is exactly when you want to hear about it). External hosting is the right operational shape.
- Stable hostname — your phone's WebSocket reconnect logic depends on the URL not changing. Tunneled / dynamic-DNS setups break this; ElfHosted's stable subdomain doesn't.
- Updates handled — Gotify ships releases regularly with bugfixes.
- Persistent SQLite storage; message history survives restarts.
- Single subscription: $9/month all-in.
Technical Specifications
- 🛠️ Software: Gotify (FOSS, BSD-3)
- 📲 Android client: official open-source app (F-Droid + Play Store)
- 🍎 iOS client: third-party (UnifiedPush-compatible apps)
- 🔧 API: simple HTTP POST with token; full OpenAPI spec available
- 🌐 Streaming: WebSocket for real-time delivery to clients
- 🔌 Integrations: Sonarr, Radarr, Prowlarr, Bazarr, Lidarr, Readarr, Uptime Kuma, Watchtower, Home Assistant, Authelia, Vaultwarden, plus webhook-anything-else
- 💾 Backend: SQLite (default) or Postgres
- 🔑 Subscription: $9/month — Gotify itself is fully free
- 🌐 Access: HTTPS on your own ElfHosted subdomain
- 🔄 Updates: handled by ElfHosted
Frequently Asked Questions
How do I run Gotify without self-hosting it?
Add it to your ElfHosted subscription — managed Gotify instance with HTTPS, persistent storage, automatic updates, and SSO via your ElfHosted account. Install the Android app, point it at your ElfHosted subdomain, log in.
What about iOS?
Gotify doesn't have an official iOS app. Third-party iOS clients exist (UnifiedPush-compatible apps like Notify or NeoPush; some users use a generic WebSocket app). The iOS story is genuinely weaker than the Android story. If iOS-first push is your priority, ntfy.sh has a more polished iOS app — consider that as an alternative or a complement.
Which self-host tools support Gotify out of the box?
The *arr stack (Sonarr, Radarr, Prowlarr, Bazarr, Lidarr, Readarr, Whisparr) all have Gotify built into their notification connectors. Uptime Kuma's notification options include Gotify. Watchtower (Docker container update notifications), Home Assistant, Authelia, Vaultwarden, OctoPrint, n8n — all support Gotify either natively or via simple webhook. Anything that can POST to a URL can push to Gotify.
How do I push from a shell script?
Generate an application token in the Gotify web UI for your script, then have the script make a single HTTP POST to /message?token=APP_TOKEN with form fields for message, title, and priority. Any HTTP-capable tool (curl, wget, the standard library of any language) works; the integration is intentionally trivial.
How is Gotify different from ntfy?
Different models. Gotify uses app tokens (each pushing source has a token, you create one per app/integration). Ntfy uses topics (anyone who knows the topic URL can publish; you subscribe by URL). Gotify is better for "permanent integrations from my self-host stack with rotatable tokens"; ntfy is better for "ad-hoc 'tell me when this script finishes' notifications from anywhere". Both are valid; many users run both.
Does Gotify drain my phone battery?
The Android app uses a single persistent WebSocket connection. Battery impact is comparable to any messaging app that maintains a long-lived connection (Telegram, Signal, Matrix). Significantly less than apps that poll.
How do I integrate Gotify with my whole self-host stack at once?
The cleanest pattern: install Apprise (notification router) somewhere, configure it to forward to Gotify; then point all your apps at Apprise's webhook. One config to update when you change destinations; everything fans out via Apprise.
Gotify is the self-hosted push notification server that's been quietly running in self-host stacks since 2018 — Android app, simple REST API, native integrations across the *arr ecosystem and most self-host tooling. Hosted on ElfHosted with HTTPS, persistent storage, and managed updates for $9/month.
Only logged in customers who have purchased this product may leave a review.
Related products
Homepage
Self-hosted application dashboard with live status widgets for 100+ self-host apps — the YAML-configured "one tab to rule them all" startpage that's become the de-facto standard.
A managed instance of Homepage on ElfHosted (the 30K-star gethomepage/homepage, not to be confused with older similarly-named projects). Custom dashboard with live widgets for Plex, Jellyfin, the *arr stack, Docker, Kubernetes, Home Assistant, and 100+ more services. Configured in YAML, blazingly fast, no database. GPL-3.
Uptime Kuma
Self-hosted uptime monitoring with public status pages — the open-source UptimeRobot alternative that doesn't cap your monitor count or charge for SSL alerts.
A managed instance of Uptime Kuma on ElfHosted — the 86K-star self-hosted monitoring tool. HTTP / TCP / ping / DNS / keyword / push monitors, public status pages with custom domains, 90+ notification channels (Discord, Slack, Telegram, email, ntfy, Pushover, Apprise, etc.), multi-user, 2FA. MIT-licensed; no monitor caps, no premium tier.
PairDrop
AirDrop for everyone — browser-based file sharing across iOS / Android / Mac / Windows / Linux, peer-to-peer, no app install, on your private subdomain.
A managed instance of PairDrop on ElfHosted — the cross-platform, browser-only file-sharing tool that does what AirDrop does but works between any two devices, regardless of OS. WebRTC peer-to-peer for transfers; the server only coordinates the handshake. Hosting on your own subdomain means a private namespace (no chance of bumping into strangers using the same temporary device name). GPL-3.
Donetick
Self-hosted chore tracker for households and teams — recurring tasks with rotation, point system, multi-user. The Tody / Sweepy alternative that doesn't lock you to an app store.
A managed instance of Donetick on ElfHosted — a clean, multi-user task and chore tracker. Recurring chores with auto-rotation between household members, optional point system for kid-incentive workflows, mobile-friendly PWA, no per-user paywall. AGPL-3.
HomeBox
Self-hosted home inventory — track every item by location, photo, serial number, warranty, and purchase info, so insurance claims and "where did I put it?" questions stop being painful.
A managed instance of HomeBox on ElfHosted — the actively-maintained continuation of the original Homebox project, rebuilt and led by sysadminsmedia. Track items in nested locations (House → Room → Drawer), attach photos and receipts, log serial numbers / warranties / value, generate QR codes for boxes. AGPL-3.
Reviews
Clear filtersThere are no reviews yet.