# Pocket Alert vs ntfy

> Hosted ntfy alternative: HTTP push with no server to run, retained message history, webhook call logs, JSON field mapping and scheduling up to 30 days. Free tier, iOS and Android.

<!-- source: https://pocketalert.app/alternatives/ntfy -->

ntfy is a good piece of software, and if you enjoy running your own infrastructure it is hard to argue with free and open source. Pocket Alert is the hosted version of the same idea: publish over HTTP, get a push on your phone, but with an account instead of a topic namespace, history that is kept rather than cached, and a record of every webhook call that comes in.

## Where self-hosted push gets expensive

The friction is not in sending. It is in everything around it.

- **Someone has to run it** — Self-hosting means uptime, TLS, upgrades and storage are yours. The shared instance comes with no delivery guarantee.
- **Nothing is kept** — Messages live in the server cache and are dropped roughly 12 hours after delivery. There is no history to come back to.
- **No record of calls** — There is no log of incoming requests. When an alert does not show up, you cannot see what was sent or why it failed.
- **The topic is the password** — On the public instance a topic is only as private as its name. Guessable topics are readable and writable by anyone.

## Pocket Alert vs ntfy, feature by feature

Same publish-over-HTTP model, different amount of it left running on your machines.

### Where you use it

- **iOS app** — Pocket Alert: Yes; ntfy: Yes
- **Android app** — Pocket Alert: Yes; ntfy: Yes (Play Store and F-Droid)
- **Web dashboard** — Pocket Alert: Yes (Devices, keys, apps, webhooks); ntfy: Yes (Web app)
- **Chrome extension** — Pocket Alert: Yes (Send a link or note to your phone); ntfy: No
- **Command-line tool** — Pocket Alert: Yes (Official binary for Linux, macOS, Windows); ntfy: Yes (ntfy CLI)
- **MCP server for AI agents** — Pocket Alert: Yes (10 tools); ntfy: No

### Sending alerts

- **Send via HTTP API** — Pocket Alert: Yes; ntfy: Yes
- **Inbound webhook URL per source** — Pocket Alert: Yes (One URL per service); ntfy: Yes (Topic URL with ?template=)
- **Payload mapping into the message** — Pocket Alert: Yes (%field.path% into title, body and buttons); ntfy: Yes (Go templates, built in for GitHub, Grafana, Alertmanager)
- **Scheduled delivery** — Pocket Alert: Yes (Up to 30 days, listable and cancellable); ntfy: Yes (Delay up to 3 days)
- **Priority levels** — Pocket Alert: Yes (Five, silent to critical); ntfy: Yes (Five, 1–5)
- **Critical alerts that override Do Not Disturb** — Pocket Alert: Yes (On paid plans); ntfy: Partly (Max priority, no DND override documented)
- **Action buttons on the notification** — Pocket Alert: Yes (Up to 3: open, HTTP request, copy); ntfy: Yes (view, http, broadcast, copy)
- **Attachments** — Pocket Alert: Yes (Images); ntfy: Yes (Any file, up to 1 GB on Business)
- **Grouping by source** — Pocket Alert: Yes (Applications, filtered in the app); ntfy: Yes (Topics)
- **Email delivery** — Pocket Alert: No; ntfy: Yes (Daily allowance per plan)
- **SMS or phone-call delivery** — Pocket Alert: No; ntfy: Yes (Phone calls on paid plans)

### Records and debugging

- **Message history** — Pocket Alert: Yes (Account-wide, synced to app and web); ntfy: Partly (Server cache, ~12 hours)
- **Webhook call log** — Pocket Alert: Yes (Headers, payload, rendered message, result); ntfy: No
- **History retention** — Pocket Alert: Yes (Messages until you delete them; webhook calls 7–365 days by plan); ntfy: Partly (Cache window only)
- **Delivery statistics** — Pocket Alert: Yes (Per application and per device); ntfy: No (Server metrics if you self-host)

### Account and data

- **Content encryption** — Pocket Alert: Yes (At rest with a per-account key, secrets redacted); ntfy: Partly (Your own disk when self-hosted)
- **Two-factor authentication** — Pocket Alert: Yes (TOTP with recovery codes); ntfy: No (Accounts and access tokens)
- **Open source or self-hosted** — Pocket Alert: No; ntfy: Yes (Apache 2.0 / GPLv2)

ntfy data from ntfy.sh and docs.ntfy.sh, checked October 2026.

## Pricing

- **Free plan** — Pocket Alert: 50 messages a day, no card; ntfy: 250 messages a day per IP on ntfy.sh without sign-up, or free self-hosted
- **Entry paid plan** — Pocket Alert: $6/month — 1,000 messages a day, 5 webhooks; ntfy: $6/month — 2,500 messages a day, 3 reserved topics
- **Highest tier** — Pocket Alert: $25/month — unlimited messages, 365-day history; ntfy: $25/month — 50,000 messages a day

Pocket Alert pricing as of October 2026. ntfy figures from ntfy.sh and docs.ntfy.sh.

## Coming from ntfy

1. **Install and get a key** — Install the app, sign in, and copy your API key from the dashboard.
2. **Swap the endpoint** — Replace the topic URL with the Pocket Alert endpoint and send the same JSON body.
3. **Move the mappings** — For templated or hand-formatted sources, create a webhook and map the raw payload with %field.path%.
4. **Retire the instance** — Shut down the server. Uptime, TLS renewals, upgrades and disk space stop being your problem.

### Before: ntfy

```bash
curl \
  -H 'Title: Deploy finished' \
  -H 'Priority: high' \
  -d 'main is live' \
  https://ntfy.sh/my-deploys
```

### After: Pocket Alert

```bash
curl https://api.pocketalert.app/v1/messages \
  -H 'Token: YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "title": "Deploy finished",
    "message": "main is live",
    "level": "high"
  }'
```

## FAQ

### How is Pocket Alert different from ntfy?

ntfy is an open-source pub-sub service you either self-host or use through the shared ntfy.sh instance. Pocket Alert is a hosted account-based service: you get an API key and webhook URLs, and there is no server, TLS certificate or storage to look after.

### What happens to old messages?

On ntfy, messages sit in the server cache and are dropped after about 12 hours. Pocket Alert keeps message history on the account, so the same list is in the app and in the dashboard, with delivery statistics beside it. Webhook calls are recorded separately for 7 to 365 days depending on plan.

### Can I point a service straight at it?

Both can. ntfy turns a JSON body into a title and message with Go templates, with built-in ones for GitHub, Grafana and Alertmanager; custom template files live on the server, so on ntfy.sh you write the template inline in the URL. A Pocket Alert webhook keeps the mapping in the dashboard: `%field.path%` placeholders fill the title, body and action buttons, and every call is logged with its payload, so a Sentry alert arrives with a working link to that issue.

### How does scheduled delivery compare?

Both schedule. ntfy delays a message up to three days; Pocket Alert accepts an absolute time or a delay up to 30 days, lists what is pending, and cancels anything that has not fired yet.

### Who can read my notifications?

On the public ntfy.sh instance the topic name is effectively the password, unless you pay for a reserved topic. Pocket Alert works the other way round: an account with API keys, optional two-factor authentication, and message content encrypted at rest with your own key.