Send your first push in a minute.
One bearer token, one URL. POST a JSON payload and your phone lights up. Use pushr cloud, or run the open-source backend yourself. Working with an AI agent? Give it pushr's skills or llms.txt.
Install pushr's skills and ask in plain words, like "notify me when this build fails".
Quickstart
Three steps on pushr cloud. Self-hosting? Jump to the self-hosting guide.
- 1Get the app
Install pushr on your iPhone, sign up and allow notifications.
- 2Create a source app
In the Apps tab, tap +, name it after what will send pushes, and copy the token. It is shown once.
- 3Send a request
In the app's API & token sheet, tap Copy curl example: your notify URL is filled in. Run it anywhere.
curl -X POST "$PUSHR_URL/notify" \
-H "Authorization: Bearer $PUSHR_TOKEN" \
-H "Content-Type: application/json" \
-d '{"title":"Hello","body":"from my terminal"}'URL and token persist in this browser only. Nothing is logged server-side by the docs page.
Fill in URL and token, then hit send. The actual HTTP response prints here: status, latency, body.
curl -X POST https://site-convex.pushr.sh/notify \
-H "Authorization: Bearer $PUSHR_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"title": "Hello from the docs",
"body": "It works.",
"priority": "normal"
}'Every endpoint lives at your server's site URL, referenced below as
$PUSHR_URL. On pushr cloud, the app's API & token sheet shows it and
can copy a ready-to-run curl example; self-hosted, it's your Convex
deployment's https://<your-deployment>.convex.site. Every authenticated endpoint takes a source-app bearer token
(pshr_…) created from the mobile app's Apps tab and referenced as
$PUSHR_TOKEN.
Endpoints at a glance
Self-hosted servers also answer POST /pair, which the app uses to redeem a connection code; see Self-hosting.
POST /notify
Sends one notification to every device the source app's owner has registered (and to every accepted member's devices, if the app is shared).
Minimal example
curl -X POST "$PUSHR_URL/notify" \
-H "Authorization: Bearer $PUSHR_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"title": "Build succeeded",
"body": "ci.example.com / main → staging"
}'Request
POST /notify
Authorization: Bearer pshr_…
Content-Type: application/jsontitleRequiredstringbodyRequiredstringmessageAliasstringbody.urlstringdataobjectimagestringactionLegacyobject{ label, url }. Replaced by actions when both are set.replaceKeystring ≤ 128priority1–10 | string1–6, low, normal or default deliver normally; 7–10 and high wake the device. Defaults to normal; anything else is a 400. See Priority and interruption.deliverAtnumber (ms-epoch)ackobjectcriticalbooleanactionsarray ≤ 4liveActivityobjectResponse
{
"id": "j97…",
"scheduledFor": null
}- id
- The notification, for logs and support.
- scheduledFor
- The
deliverAtyou sent, in ms, ornullwhen it went at once.
Idempotency-Key already used. Same body, plus Idempotent-Replay: true. Nothing is sent again.Anything else is an error; see Errors and retries.
Guides
Each one is a field (or two) on POST /notify.
Priority and interruption
# Wake the device — banner + sound:
-d '{"title":"DB disk > 90%","body":"prod","priority":"high"}'
# Numeric (Gotify-style 1-10):
-d '{"title":"FYI","body":"nightly backups complete","priority":4}'{
"title": "DB disk > 90%",
"body": "prod-db-1 · 92% used",
"priority": 8
}- ✓Shows a banner
- ✓Plays a sound
- ✓Lights the screen
- ✓Breaks through Focus
Priority also sets how hard the push may interrupt on iOS:
| Priority | iOS interruption level | Effect |
|---|---|---|
1–3, "low" | passive | Lands quietly in Notification Center, no screen wake |
4–6, "normal" (default) | active | A normal banner and sound |
7–10, "high" | time-sensitive | Breaks through Focus and the notification summary |
any push with ack | time-sensitive | Same, for every re-push until acknowledged |
| critical, where the app allows it | critical | Plays its sound even with the ringer off or in Do Not Disturb |
During a source app's quiet hours, pushes are delivered as passive unless they need acknowledgment.
Links and images
-d '{
"title": "PR #42 merged",
"body": "from peptide",
"url": "https://github.com/owner/repo/pull/42"
}'-d '{
"title": "New deploy",
"body": "Build #382 passed",
"image": "https://ci.example.com/badges/build-382.png"
}'{
"title": "PR #42 merged",
"body": "Build #382 passed",
"url": "https://github.com/owner/repo/pull/42",
"image": "https://ci.example.com/badges/build-382.png"
}A tap opens the link. The image shows as a thumbnail on the banner.
Action buttons
Up to 4 actions. Three kinds:
kind | Behavior |
|---|---|
open_url | Opens url when tapped. Recorded as an event server-side. |
callback | POSTs to callbackUrl. HTTP status stored on the action event. Optional authRequired to lock-gate. |
reply | iOS inline text reply. POSTs { reply, ... } to callbackUrl. Optional placeholder. |
Decisions: one answer per notification
The callback actions on a notification are treated as one choice, like
Approve or Reject. Once one of them has gone through, the others are
refused ("Already answered"), whether the second tap comes from the feed,
the Lock Screen or another device, so your endpoint hears exactly one
answer. A callback that fails (a network error or a 4xx/5xx from your
endpoint) leaves the choice open to retry or change. reply and open_url
actions aren't part of the decision and keep working afterwards.
In the app's feed, the callbacks sit together as a full-width pair: the
first one that isn't destructive is the suggested action, and a
destructive one is shown in red. Once answered, the pair becomes a single
line with the answer and when it was given. Links and replies sit under
the pair as smaller buttons. So for a yes/no question, send one callback
for each answer and mark the risky one destructive:
"actions": [
{ "kind": "callback", "id": "approve", "label": "Approve", "callbackUrl": "https://ci.example.com/deploy/42/approve" },
{ "kind": "callback", "id": "reject", "label": "Reject", "callbackUrl": "https://ci.example.com/deploy/42/reject", "destructive": true },
{ "kind": "open_url", "id": "logs", "label": "View logs", "url": "https://ci.example.com/deploy/42" }
]If you need several independent buttons rather than one answer, send them as separate notifications.
Tap Approve or Reject to see the request pushr sends.
Callback request shape
When the user taps a callback or reply action, pushr POSTs to your
callbackUrl:
POST /your/endpoint
Content-Type: application/json
User-Agent: pushr/1.0
X-Pushr-Source: pushr
X-Pushr-Notification: <notificationId>
X-Pushr-Action: <action.id>
{
"notificationId": "...",
"actionId": "approve",
"respondedAt": 1712160000000,
"reply": "LGTM" ← only for kind=reply
}callbackUrl must be a public https:// URL: localhost, private-network
and link-local addresses are rejected, and redirects are not followed. pushr
records only the response status, never the body. Members of a shared app
can run callbacks and replies too. The owner can turn that off for a viewer
(in the app's Sharing, tap the member): they can still open links, and their
pushes arrive without the other buttons.
Outbound action callbacks are unsigned. To authenticate the request,
embed a bearer token in the callbackUrl itself (e.g.
https://api.example.com/hook?key=…) or terminate the URL on a server
that already trusts the server's egress IP (pushr cloud's, or your own
Convex deployment's if you self-host).
Inbound webhook signing (provider → pushr) is unrelated and configured per provider — see Webhook adapters → Signing secrets below.
Caveat: lockscreen labels
iOS requires notification categories to be pre-registered, so the
lockscreen banner shows generic labels (Action 1, Action 2,
Reply). The mobile feed renders the real labels you sent and is
where users normally respond.
Ack-or-escalate
Turn a notification into an on-call-style alarm that re-pushes at high priority — ignoring quiet hours — until the user taps it. A muted source app stays silent.
{
"title": "DB disk > 90%",
"body": "homelab/prod",
"priority": "high",
"ack": {
"timeoutSec": 60, // 10–86400, seconds between re-pushes
"maxAttempts": 5 // 1–20, total re-pushes after the initial send
}
}{
"title": "api-prod is down",
"body": "5xx rate 38% across 3 regions",
"ack": {
"timeoutSec": 60,
"maxAttempts": 3
}
}Press Send to start.
Tapping the notification (or opening its url) acknowledges it and stops
the loop. Un-acked notifications are listed at the top of the feed with an
"ack needed" badge.
On-call escalation
When a source app is shared with teammates, its owner can set an on-call rotation in the app (source app → On-call). An urgent push then reaches the first person on call only, and one more person each time it goes unacknowledged, instead of waking everyone at once.
{
"title": "api-prod is down",
"body": "5xx on 38% of requests",
"priority": "high"
}Send an urgent push to page You.
- Urgent means a push with
ack, or priority7or higher. Everything else still goes to everyone on the app. - Each round waits the push's
ack.timeoutSec, or the app's Escalate after time (1 to 60 minutes) when the push has noack. pushr adds an ack loop long enough to reach everyone on the rotation. - Acknowledging on any phone stops it for everyone.
- Weekly rotation moves who's first along by one person each week.
- Heartbeat and uptime alerts escalate the same way; their recoveries go to everyone.
- On-call is a Pro feature on pushr cloud, and needs at least two people and at most 10.
Nothing changes in the request: the same /notify call pages one person or
everyone, depending on the app's settings.
Critical alerts
A critical alert plays its sound even when the phone is muted or in Do Not Disturb, like a severe weather alert. Because it overrides the user's own settings, the sender can't turn it on alone: the source app's owner chooses in the app (source app → Critical alerts) which pushes may ring through:
| Setting | What rings through |
|---|---|
| Off (default) | Nothing |
| Marked critical | Pushes sent with "critical": true |
| All urgent | Those, plus every push with ack or priority 7+, including heartbeat and uptime alerts |
{ "title": "Freezer above -10°C", "body": "Walk-in #2 · 4°C", "priority": "high", "critical": true }- Critical alerts ignore quiet hours. A muted source app stays silent.
- Each phone also asks its owner's permission the first time it's turned on.
- iOS rings through mute only once Apple has approved pushr's critical-alerts entitlement. Until then these pushes arrive as time-sensitive.
- Critical alerts are a Pro feature on pushr cloud.
Replace keys
Some notifications describe a state that keeps changing: disk usage, a
deploy, a queue's depth. Give them the same replaceKey and each one
replaces the last instead of stacking up.
{ "title": "Disk 91%", "body": "db-1 /var", "replaceKey": "disk-db-1" }
// …later
{ "title": "Disk 97%", "body": "db-1 /var", "priority": "high", "replaceKey": "disk-db-1" }
// …and once it's fixed
{ "title": "Disk OK", "body": "db-1 /var · 62%", "replaceKey": "disk-db-1" }{
"title": "Disk 91%",
"body": "db-1 /var",
"replaceKey": "disk-db-1"
}Nothing sent yet.
- On the phone, the earlier notification is removed from Notification Center when the new one arrives, so the Lock Screen shows only the latest.
- In the feed, only the latest shows, marked Updated 2×. Tap it to see the timeline of earlier versions with their times.
- The badge counts the latest only: replaced versions are marked read.
- Each push is still a full notification, with its own sound, priority and
quota. Use a lower priority for routine updates and
highwhen it gets worse. - Keys are per source app, so two apps can use the same key safely.
- Send a key at most every few seconds. Many sends a second under one key
contend with each other and some can fail with a
500; for that pace, use a Live Activity. - A scheduled push (
deliverAt) replaces its predecessor when it's delivered, not when you send it. - An
ackstops escalating once its notification is replaced. - Deleting the latest version from the feed deletes its timeline too.
For progress you want to watch live, such as a build, use a Live Activity instead. A replace key suits things that change every few minutes or hours, where a notification for each change is worth it.
Scheduled delivery
{
"title": "Standup",
"body": "Time to gather",
"deliverAt": 1714435200000 // ms-epoch
}Returns 202 { id, scheduledFor } immediately; delivery happens at the
target time via the Convex scheduler.
{
"title": "Standup",
"body": "Time to gather",
"deliverAt": 1714435205000
}Live Activities
Drive iOS lockscreen / Dynamic Island progress indicators. Three actions:
start / update / end, all keyed by your own activityId. state is
required on every action, and progress must be between 0 and 1.
Update:
{
"title": "Deploy #42",
"body": "Deploying to staging",
"liveActivity": {
"action": "update",
"activityId": "deploy-42",
"state": { "title": "Deploy #42", "status": "Deploying", "progress": 0.85 }
}
}End:
{
"title": "Deploy #42",
"body": "Shipped 🎉",
"liveActivity": {
"action": "end",
"activityId": "deploy-42",
"state": { "title": "Deploy #42", "status": "Complete", "progress": 1.0 }
}
}start requires the device to have registered a push-to-start token (the
mobile client does this on first launch). update/end can fire even if
the app is terminated. Set the APNS_* environment variables on your
Convex deployment to enable this end-to-end (see .env.example).
A push with liveActivity shows as the Live Activity instead of a
notification banner, so each step doesn't arrive twice; every step still
appears in the feed. The banner is sent instead only when the activity can't
be shown: APNS_AUTH_KEY isn't configured, no device has a push-to-start
token, or Apple rejects the start for every device. Updates and ends never
send a banner.
Ending, and failing
End with "outcome": "failure" in state and the activity turns red so
it can't be mistaken for a running one: a solid red Failed label, a red
glow, an ✕ beside the status, and the bar and ring stopped in red where the
job failed.
{
"title": "Build #43",
"body": "3 tests failed",
"liveActivity": {
"action": "end",
"activityId": "build-43",
"state": { "status": "3 tests failed", "progress": 0.55, "icon": "xmark.octagon.fill", "outcome": "failure" }
}
}state.outcome | Shows as | Stays on the Lock Screen |
|---|---|---|
"success", or a full bar with no outcome | Done, green | 15 minutes |
"failure" | Failed, red | Until dismissed, up to iOS's 4 hours |
dismissAfter on an end sets how long a finished activity stays instead,
in seconds from 0 (gone at once) to 14400. A failure ignores it and stays
until it's dismissed, so a failed job is never cleared before someone sees it. Always end an activity, failure included: one
that's never ended stays until iOS removes it, still saying it's running.
- start
- update
- update
- end
{
"title": "Deploy #42",
"body": "Building image",
"liveActivity": {
"action": "start",
"activityId": "deploy-42",
"attributes": {
"name": "ci.acme"
},
"state": {
"title": "Deploy #42",
"status": "Building image",
"progress": 0.15
}
}
}Every request reuses the same activityId. attributes only go with start; each step after that just sends the new state.
Choosing an icon
state.icon is the name of any SF Symbol,
Apple's icon set. It shows in the Dynamic Island and beside the status on the
Lock Screen, so pick one that says what the job is. Filled symbols (….fill)
read best at that size. Leave it out, or send a name iOS doesn't know, and the
Dynamic Island shows the initial of attributes.name instead.
hammer.fillFilled symbols read best at this size. Leave icon out, or send a name iOS doesn't know, and the Dynamic Island shows your app's initial instead.
{
"title": "Deploy #42",
"liveActivity": {
"action": "start",
"activityId": "deploy-42",
"attributes": {
"name": "ci.example.com"
},
"state": {
"title": "Deploy #42",
"status": "Running tests",
"progress": 0.35,
"icon": "hammer.fill"
}
}
}Heartbeats
A heartbeat catches the failure no notification can report: a job that silently stopped running. Your job pings pushr each time it finishes, and pushr pushes to your phone when a ping is late, or when the job reports a failure. When it pings again, a recovery replaces the alert.
# crontab: back up at 03:00 and check in afterwards
0 3 * * * /usr/local/bin/backup.sh && curl -fsS -H "Authorization: Bearer $PUSHR_TOKEN" "$PUSHR_URL/heartbeat/nightly-backup?every=1d"- Status
- Not created yet
- Last ping
- –
- Alerts if no ping by
- –
No alerts yet.
The first ping creates the heartbeat, so there's nothing to set up in the app. It's watched from then on.
Endpoints
| Request | Meaning |
|---|---|
GET or POST /heartbeat/<name> | The job ran. Starts a new window. |
POST /heartbeat/<name>/start | The job started. The next ping reports how long it took. Optional. |
POST /heartbeat/<name>/fail | The job failed. Alerts at once; a text body (up to 500 characters) becomes the alert's text. |
DELETE /heartbeat/<name> | Stop watching it. |
<name> is up to 64 letters, digits, dots, dashes or underscores, and is
unique within the source app.
| Query | Notes |
|---|---|
every | How often the job runs: seconds, or a number with s, m, h or d, from 1m to 30d. Required on the first ping; send it again to change it. |
grace | How long past every to wait before alerting, up to 7d. Defaults to 20% of every, between 1 minute and 1 hour. |
The response is 200:
{ "ok": true, "name": "nightly-backup", "status": "up", "everySec": 86400, "graceSec": 3600, "dueAt": 1714525200000 }dueAt is when pushr alerts if no ping arrives. It's null while the
heartbeat is down or paused.
What you get
| Event | Notification | Priority |
|---|---|---|
No ping by dueAt | nightly-backup missed its check-in · Expected every 1d. Last ping 1d 1h ago. | high |
/fail | nightly-backup failed · your body, or "The job reported a failure." | high |
| A ping after either | nightly-backup is back up · Down for 2h 14m. Took 3m 12s. | normal |
- One alert per outage: further misses and failures stay quiet until it recovers. A heartbeat that flaps sends at most 3 down alerts an hour; past that its status still changes, without a push. Each down alert that was sent gets its recovery.
- Alerts come from the token's source app and use the replace key
heartbeat:<name>, so the recovery replaces the alert and the feed keeps the history. They follow the app's mutes and quiet hours like any push, and don't count toward your monthly quota. - Lateness is checked every minute.
- Ping as often as you like: pings don't count toward your quota, and repeats within 10 seconds are ignored.
- On pushr cloud, Free includes 3 heartbeats and Pro 100, across all your apps; a single source app holds at most 50. Heartbeats made before a downgrade keep running.
Report failures and durations
Wrap the job to report all three:
url="$PUSHR_URL/heartbeat/nightly-backup"
auth="Authorization: Bearer $PUSHR_TOKEN"
curl -fsS -X POST -H "$auth" "$url/start?every=1d"
if out=$(/usr/local/bin/backup.sh 2>&1); then
curl -fsS -X POST -H "$auth" "$url"
else
printf '%s' "$out" | tail -c 500 | curl -fsS -X POST -H "$auth" --data-binary @- "$url/fail"
fiWith the SDK, withHeartbeat reports the start, success
or failure of a job for you, and never fails the job if pushr can't be
reached:
import { heartbeat, withHeartbeat } from '@pushrsh/sdk';
await withHeartbeat('nightly-backup', { every: '1d' }, runBackup);
await heartbeat('queue-worker', { every: '5m' }); // a plain check-inIn the app
The Monitors tab lists every heartbeat with its status and last ping, and + → Heartbeat creates one with copy-ready setup for cron, the CLI, curl or the SDK. Pause one during maintenance so it can't alert. Pings while it's paused are recorded but don't lift the pause, so a job that keeps running during maintenance stays quiet; Resume starts a fresh window.
Uptime checks
Heartbeats catch jobs that stop running. Uptime checks catch sites and APIs that stop answering: pushr requests a URL on a schedule and pushes to your phone when it fails, then again when it's back.
curl -X PUT "$PUSHR_URL/uptime/api" \
-H "Authorization: Bearer $PUSHR_TOKEN" \
-d '{"url":"https://api.example.com/health","every":"1m","keyword":"ok"}'{
"url": "https://api.example.com/health",
"every": "1m",
"keyword": "ok",
"confirmAfter": 2
}- Press a button to run a check.
Failures in a row: 0 of 2
You can also add and edit checks in the app: Monitors → + → Uptime check tests the URL as you type.
The check
| Field | Notes |
|---|---|
url | http or https, on a public host. The name is looked up before every check, and an address that's private, loopback or link-local, or a name that points to one, is refused. Redirects aren't followed. |
every | How often to check: 1m to 1h (seconds, or a number with s, m or h). On pushr cloud's Free plan, every 5 minutes at most. |
method | GET (default) or HEAD. |
keyword | Text the response body must contain, up to 200 characters. Not with HEAD. |
timeout | Seconds to wait for a response, 1 to 30. Default 10. |
confirmAfter | Failed checks in a row before it alerts, 1 to 5. Default 2, so one blip doesn't page you. |
A check passes when the response status is below 400 (redirects aren't
followed, so a 301 passes) and, with keyword, the body contains it. It
fails on a status of 400 or more, a missing keyword, an error, or no response
within timeout.
PUT creates the check or changes it, and answers 200 with its state;
GET answers the same; DELETE removes it:
{
"ok": true, "name": "api", "url": "https://api.example.com/health", "method": "GET",
"intervalSec": 60, "timeoutSec": 10, "keyword": "ok", "confirmAfter": 2,
"status": "up", "lastCheckedAt": 1714525200000, "lastStatusCode": 200,
"lastLatencyMs": 182, "lastError": null, "downSince": null
}status is pending until the first check, then up, down or paused.
The name follows the same rules as a heartbeat's.
What you get
| Event | Notification | Priority |
|---|---|---|
confirmAfter failures in a row | api is down · HTTP 503 · api.example.com/health | high |
| The next passing check | api is back up · Down for 12m. Responded in 182ms. | normal |
Alerts work like a heartbeat's: one per outage, at most 3 down alerts an hour,
the recovery replaces the alert (replace key uptime:<name>), and they follow
the app's mutes, quiet hours, on-call and
critical alerts. They don't count toward your quota.
Checks come from pushr's servers (your own Convex deployment, if you self-host)
with the user agent pushr-uptime/1.
| Free | Pro | |
|---|---|---|
| Uptime checks | 1 | 50 |
| Most often | Every 5 minutes | Every minute |
After a move from Pro to Free nothing is deleted. Your oldest check keeps running, no faster than every 5 minutes; the others are on hold and start again by themselves when you upgrade.
Status pages
A status page shows some of an app's heartbeats and uptime checks to anyone,
at status.pushr.sh/<slug>: whether each is up now, 90 days of uptime, and recent
incidents. Create one in the app (Monitors → + → Status page), choose its
address, title and monitors, and give each monitor a public name if you like.
Addresses are 3 to 40 lowercase letters, digits or dashes; a few, such as
docs and status, are reserved. pushr's own status is at the root,
status.pushr.sh.
Services
API
Website
Jobs
Nightly backup
Branding
Out of the box a page uses the source app's logo and color. In the page's editor you can also set:
| Option | Notes |
|---|---|
| Logo | Upload one for the page, or keep the app's. |
| Accent color | Tints the page's banner and highlights. Status colors stay green, amber and red. |
| Theme | Auto (follows the visitor), light or dark. |
| Website | A link back to your site at the top. |
| Description | A line under the title, up to 160 characters. |
| Announcement | Pinned at the top until you clear it, up to 280 characters: info, maintenance or warning. |
| Groups | Name a group on monitors to show them under headings, like API and Jobs. |
Visitors never see URLs, error messages or a job's output: an incident reads as Failed, Missed its check-in, HTTP 503, Timed out or Not responding.
Incidents
Every outage of a monitor on the page is an incident. Outages that overlap across the page's monitors (or start within two minutes of each other) are one incident, like API and Website. Each opens to a timeline of what the checks saw: when the first check failed (or a heartbeat's check-in was due), when it was confirmed down, and when it came back, with the status code and response time. The page lists 90 days of them, newest first, grouped by day.
Updates. Tell visitors what's happening. In the dashboard or the app, open
a monitor, then its incident: give it a title (up to 80 characters, like
Checkout errors) and post updates as it goes, each marked Investigating,
Identified, Monitoring or Resolved, up to 1,000 characters. Anyone
who can edit the app can post, so whoever's on call can; an AI agent can too,
with the incident_update tool. An incident holds up to 30
updates. The latest update's status is the incident's on the page; without
one it shows Ongoing or Resolved. Updates are part of Pro, with status
pages, and go with the incident: after 90 days, or when its monitor or app is
deleted.
The page's data is public JSON, for your own page or a widget:
GET $PUSHR_URL/status-page/<slug>overallisoperational,degraded(some monitors down) oroutage(all of them).days[].downMsis-1for days before the monitor existed.uptimeis over the last 90 days, or since the monitor was created.incidentsare newest first, up to 50 from the last 90 days.endedAtisnullwhile one is going on.titleandstatusarenulluntil someone writes an update;statusis the latest update's.monitor(the monitors' names joined) andreason(the first outage's) are kept for readers of the older shape.firstFailedAt,statusCodeand therecovered…fields arenullwhen the check didn't see one (heartbeats have no status code).- Answers
404for an unknown or disabled page, and may be cached for 30 seconds. - Status pages are a Pro feature on pushr cloud, up to 5 per account. After a
move to Free a page is kept but offline (
404), and comes back when you upgrade. - Self-hosted servers serve the JSON only; the app doesn't offer status pages
there, since
status.pushr.shshows pushr cloud's pages.
Other ways to send
Webhook adapters
Forward provider webhooks straight to pushr without writing glue code. Adapters normalize the provider payload into the same internal shape and flow through the same delivery / quota / ack plumbing.
POST /hooks/github?token=$PUSHR_TOKEN
POST /hooks/sentry?token=$PUSHR_TOKEN
POST /hooks/grafana?token=$PUSHR_TOKENAuth: either Authorization: Bearer $PUSHR_TOKEN (when the provider lets
you customize headers) or ?token=$PUSHR_TOKEN in the query string.
Payloads must be JSON; a form-encoded delivery gets 400 Invalid JSON body.
https://<deployment>/hooks/github?token=pshr_…- 1Repo or org → Settings → Webhooks → Add webhook
- 2Payload URL: the URL above
- 3Content type: application/json
- 4Secret: the one you save in the app
202 { "id": "k57…", "scheduledFor": null }Signing: X-Hub-Signature-256: sha256=<hex>
GitHub
Paste $PUSHR_URL/hooks/github?token=$PUSHR_TOKEN into your repo or org
webhook settings. Set the content type to application/json (GitHub
defaults to form-encoded). Subscribe to events you care about:
| Event | Sent when | Title | Priority |
|---|---|---|---|
push | Always | "{repo}: N commits → {branch}" | 5 |
pull_request | Opened, reopened, ready for review, closed | "{repo} PR #N {opened|merged|closed}" | 6 when opened, else 5 |
issues | Opened or reopened | "{repo} issue #N {action}" | 5 |
release | Published | "{repo} release {tag}" | 7 |
workflow_run | Failed or timed out | "{repo}: {name} failed" | 8 |
check_run | Failed or timed out | "{repo}: {name} failed" | 8 |
deployment_status | Finished (not queued or in progress) | "{repo}: deploy to {env} → {state}" | 8 on failure or error, else 6 |
| Any other event | Always | "{repo}: {event}" | 5 |
Everything else (other pull_request and issues actions, releases that
aren't published, successful runs, deployments still queued or in progress,
and ping) is acknowledged with 200 { ignored: true } and sends nothing.
To sign deliveries, open the source app in the iOS app → API & token →
Webhooks → GitHub and paste the same secret you set in GitHub. Once
it's saved, pushr checks X-Hub-Signature-256 on every delivery and a
mismatch returns 401.
Sentry
Add an Internal Integration (or legacy plugin webhook) at
/hooks/sentry?token=…. An issue becomes {project}: {action} — {title}
with its culprit as the body; an alert uses the event's own title; a legacy
plugin webhook is sentry: {project}. A payload of any other shape is
acknowledged with 200 { ignored: true }. Severity maps to pushr priority:
| Sentry level | pushr priority |
|---|---|
| debug | 2 |
| info | 4 |
| warning | 6 |
| error | 8 |
| fatal | 9 |
| anything else | 5 |
To verify Sentry signatures, set the integration's client secret in API &
token → Webhooks → Sentry. Once it's saved, pushr checks
Sentry-Hook-Signature (bare hex HMAC-SHA256 of the raw body) on every
delivery.
Grafana
Contact point → Webhook → URL $PUSHR_URL/hooks/grafana?token=…. The
adapter collapses the alert batch into one push titled
<ruleName> (<n> firing), or <ruleName> resolved at priority 4 once it
clears. commonLabels.severity (else the first alert's severity label)
sets the priority: info 5, warning 6, high/error 8,
critical/emergency 9; anything else is 6. Grafana doesn't HMAC-sign webhook payloads, so
the bearer token is the only authenticator — keep the URL private.
Signing secrets
A single source app can be wired to multiple providers — each with its own signing secret. Configure them independently in API & token → Webhooks.
| Provider | Header | Format | Notes |
|---|---|---|---|
| GitHub | X-Hub-Signature-256 | sha256=<hex> | Required when set |
| Sentry | Sentry-Hook-Signature | bare <hex> | Required when set |
| Grafana | — | — | Bearer-only (no signing) |
When a secret is set for a provider that supports signing, every inbound
delivery to /hooks/{provider} must carry a valid signature or pushr
returns 401 { error: "Invalid signature" }. Clearing the secret falls
back to bearer-only auth.
Adapter response
| Code | Body | When |
|---|---|---|
| 202 | { id, scheduledFor: null } | Adapter normalized the event and the push was queued. |
| 200 | { ignored: true, provider } | The adapter chose to ignore this event (e.g. GitHub ping). |
Errors are listed under Errors and retries.
CLI and SDK
Both read PUSHR_URL and PUSHR_TOKEN from the environment and call
POST /notify for you.
CLI (brew install cpreston321/tap/pushrsh):
pushrsh "Deploy finished" "main → production" -p high
tail -n 5 deploy.log | pushrsh "Cron failed" # stdin becomes the body
pushrsh "PR ready" "+812 / -96" -a "View=https://github.com/owner/repo/pull/318"
pushrsh la start deploy-42 --title "Deploy #42" --status Building --progress 0
pushrsh "Disk 94%" "db-1 /var" -r disk-db-1 # replaces the last disk-db-1
pushrsh hb nightly-backup --every 1d -- ./backup.sh # heartbeat around a command
pushrsh uptime api https://api.example.com/health --every 1m --keyword okpushrsh hb NAME -- COMMAND runs the command between a start and a success
or fail ping, sends the last 500 characters of its output on failure, and
exits with the command's status.
TypeScript SDK (bun add @pushrsh/sdk, any fetch runtime):
import { notify, liveActivity, withHeartbeat } from "@pushrsh/sdk";
await notify({ title: "New sale", body: "$42 from Acme", priority: 9 });
const la = liveActivity("deploy-42");
await la.start({ status: "Building", progress: 0 });
await la.end({ status: "Live" });
await withHeartbeat("nightly-backup", { every: "1d" }, runBackup);Gotify compatibility
pushr accepts Gotify's message and extras click URL. See
From Gotify or iGotify for the full mapping.
Connect AI agents
pushr is an MCP server, so Claude, ChatGPT, Cursor and other AI agents can reach you on your iPhone: ask before they do something you'd want a say in, wait for your tap, tell you when they're done, and show long tasks on your Lock Screen. There's no token to copy: the agent signs in to your pushr account, and you choose which apps it may use. This is a pushr cloud feature.
Add pushr to your agent
https://mcp.pushr.shAlso answers at https://mcp.pushr.sh/mcp, and at https://pushr.sh/mcp for agents connected before. No token to paste: the agent signs in to your account.
- 1Open Settings›Connectors›Add custom connector
- 2Paste , name it pushr
- 3Sign in when Claude opens pushr, and choose the apps it may use
On claude.ai, Claude Desktop and the Claude mobile apps.
The agent opens pushr.sh/connect in your browser:
- 1Sign in
With your pushr email and password, or Email me a sign-in link if you made your account with Apple. Accounts are made in the app.
- 2Choose the apps
The agent sends as these apps and can read their monitors. With more than one, it picks the app for each message.
- 3Allow
You’re sent back to the agent, connected. Settings → AI agents in the app lists it.
The app's Settings → AI agents lists what's connected, which apps each one uses and when it was last used. Tap one to disconnect it; it has to sign in again to come back. Deleting an app removes it from every agent.
The tools
askwaits for youPushes a question with a button for each choice (Approve and Reject unless it gives others, up to 4) and an optional Reply, then waits for your tap. urgent: true pushes it again every minute, up to 5 times, until you answer.
{"status": "waiting","id": "q_8f2c41"}get_answerKeeps waiting for, or checks, the answer to an ask.
notifySends a notification, like POST /notify.
progressShows a task as a Live Activity. Call it again with the same id to move it on; outcome success or failure ends it.
monitorsThe state of the chosen apps’ uptime checks and heartbeats, worst first.
incident_updateProPosts an update to a monitor’s current or latest status page incident, within the last day. Needs edit access to the app.
ask, notify and progress take an app argument when the agent has more than one app. It only ever sees the apps you chose.
ask waits- ask0sThe question lands on your phone and in the feed.
- One call waitsup to 90swait_seconds, at most 240. The first tap is the answer.
- get_answerafterNo tap yet: the agent gets the id and keeps waiting. It never assumes an answer.
A late tap still counts. The buttons work like action buttons, with no callback URL: the answer goes straight back to the agent.
Each ask, notify and progress step is a notification, and counts toward your monthly pushes.
An app paused on the Free plan can’t send, and the agent is told why.
Use with AI agents
pushr ships agent skills: task-focused guides that teach coding agents (Claude Code, Cursor, Codex and others) how to integrate pushr the right way, from picking a priority to building a callback endpoint. Install them into your project once, then just ask.
Set up the skills
- 1Add your credentialsPut
PUSHR_URLandPUSHR_TOKENin the project’s.envand your CI secrets. The skills read them from the environment, like the SDK and CLI, and never paste a token into code. - 2Install the skillsThen choose which agents get them. For Claude Code by hand, copy the folders from skills/ into
$ npx skills add cpreston321/pushr-backend.claude/skills/, or~/.claude/skills/for every project. - 3No skills support?Give your tool the docs instead: add
https://pushr.sh/llms-full.txtas a docs source (in Cursor, @Docs → Add new doc), or this line to yourAGENTS.mdorCLAUDE.md:For push notifications, follow https://pushr.sh/llms.txt - 4Check it worksAsk your agent “Send me a test push with pushr.” A notification should arrive on your phone.
The skills
pushr-notifySetup and secrets, request fields, choosing a priority, replace keys, the SDK, CLI, Python, Go and GitHub Actions, errors and safe retries
pushr-actionsButtons and replies, the callback request, building and securing the endpoint (Hono, Express, Next.js, FastAPI), approval gates
pushr-live-activitiesStart, update and end, choosing an icon, always ending on failure, update pacing
pushr-alertsUrgency levels, ack-or-escalate, on-call rotations, critical alerts, quiet hours and mutes, GitHub, Sentry and Grafana webhooks with signing
pushr-heartbeatsHeartbeats for cron jobs and workers, uptime checks for sites and APIs, status pages, the CLI wrapper, SDK and CI
pushr-typesDrop-in TypeScript types and a dependency-free client with idempotent retries, Python types, a Zod schema
The agent loads the right skill from what you ask, so you don’t need to name it. Each reads PUSHR_URL and PUSHR_TOKEN from the environment.
Docs for LLM tools
All of them are generated from this page, so they stay in step with it.
Errors and retries
Status codes
Every error body has an error string; some also carry a code to branch on.
error: "<reason>"Validation error: missing fields or a bad shape.Fix, don’t retryInvalid token / Missing bearer tokenBad or absent token.Fix, don’t retryInvalid signatureThe provider’s signature didn’t match the signing secret you set.Fix, don’t retrySource app disabledThe token is valid, but the app was turned off.Fix, don’t retryAPP_PAUSEDpushr cloudThe app is on hold: the account is on Free with more apps than Free allows. Choose the active app in the iPhone app, or upgrade.Fix, don’t retryIDEMPOTENCY_KEY_REUSEDThe Idempotency-Key was used with a different payload.Fix, don’t retryEVERY_REQUIREDThe first ping to a new name didn’t say every.Fix, don’t retryerrorNot /heartbeat/<name>, /start or /fail, or a DELETE of a name that doesn’t exist.Fix, don’t retryPRO_REQUIREDpushr cloudA new heartbeat past Free’s 3.Fix, don’t retryHEARTBEAT_LIMITPro’s 100, or 50 on one source app, are in use.Fix, don’t retryPRO_REQUIREDpushr cloudA second check, or checking more often than every 5 minutes, on Free.Fix, don’t retryUPTIME_LIMITThe account already has 50 uptime checks.Fix, don’t retryQUOTA_EXCEEDEDpushr cloudThe month’s pushes are used up; it resets on the 1st (UTC). See Rate limits and quotas.Next montherror: "<message>"Unexpected server error.Retry with a keyRetries and Idempotency-Key
Send an Idempotency-Key header (any string up to 255 characters, such as a
job id or UUID) to make retries safe:
curl -X POST "$PUSHR_URL/notify" \
-H "Authorization: Bearer $PUSHR_TOKEN" \
-H "Idempotency-Key: deploy-482-finished" \
-d '{"title":"Deploy #482 finished"}'id comes back with Idempotent-Replay: true. Not pushed again, and not counted.GET /healthz
GET /healthz{ "ok": true, "version": "0.1.0", "selfHosted": false, "appleSignIn": true }version is the backend release, and appleSignIn says whether Sign in
with Apple is enabled on this server. A self-hosted server answers
"selfHosted": true, with appleSignIn false unless you've enabled it. Use this from a monitor to check that your deployment is reachable.
Tokens and limits
Source-app token format
Tokens always start with pshr_ followed by a base64url payload. They're
shown once at creation time in the mobile app's Apps tab — the
server only stores the sha256(token) hash. Revoking an app invalidates its
token for good; rotating the token issues a new one and invalidates the old.
tokenPrefix (e.g. pshr_abcd1234) is safe to display in logs and CI
config; the full token is not.
Rate limits and quotas
Self-hosted: there are no plans and no push quota. Every account on your deployment gets every feature. A few fixed limits remain: 50 uptime checks per account, 50 heartbeats per source app, and notification history is kept 90 days (a daily sweep deletes older pushes).
Push limits, on both: each source app can send 120 pushes a minute; past
that, /notify answers 429 with code: "RATE_LIMITED" and a
Retry-After header. title is at most 256 characters, body 4096, url,
image, appUrl and action URLs 2048, an action's label and id 64, and
data 4 KB as JSON. url and image must be http or https; appUrl
and open_url actions may use any app scheme (myapp://…) but never
javascript:, data:, file: or vbscript:. Provider webhooks
(/hooks/*) have over-long titles and bodies shortened instead of refused.
Logos, for an app or a status page, are PNG, JPEG, WebP or HEIC images up to 5 MB. An upload that isn't attached to an app or page within a day is deleted.
Signing in, on both: after 10 wrong passwords for one email address within
15 minutes, password sign-in for that address answers 429 with
code: "TOO_MANY_SIGN_IN_ATTEMPTS" until the 15 minutes pass. Password reset
and Sign in with Apple still work, and signing in before the limit starts the count over.
- Pushes per month1,000
- Source apps1
- History7 days
- People per shared app1
- Quiet hours, Slack and Discord forwarding—
- Uptime checks1, every 5 minutes
- Heartbeats3
- Status pages—
- On-call escalation and critical alerts—
- Pushes per month10,000
- Source appsUnlimited
- History90 days
- People per shared appUnlimited
- Quiet hours, Slack and Discord forwarding✓
- Uptime checks50, every minute
- Heartbeats100
- Status pages5
- On-call escalation and critical alerts✓
Past the monthly limit, /notify answers 429:
{
"error": "Monthly quota exceeded",
"code": "QUOTA_EXCEEDED",
"tier": "free",
"count": 1000,
"limit": 1000
}The count resets at the start of each month (UTC). Replays with an
Idempotency-Key don't count.
Migrating from other apps
Every guide below ends the same way: create a source app in the iPhone app
(Apps → +), copy its token, and send JSON to POST /notify with
Authorization: Bearer $PUSHR_TOKEN. A source app plays the part of a
Pushover application, an ntfy topic, a Gotify app or a Hark service: give each
sender its own, with its own name, logo and colour.
From Pushover
Same idea, one less key: there's no user key, and emergency priority becomes an alert that repeats until you acknowledge it.
- 1Make a source app for each Pushover application
- 2Send JSON to
/notifywith its token as a bearer header - 3Map
messagetobodyand the priorities below
curl -s https://api.pushover.net/1/messages.json \
--form-string "token=$APP_TOKEN" \
--form-string "user=$USER_KEY" \
--form-string "title=Backup failed" \
--form-string "message=exit 2" \
--form-string "priority=1"curl -X POST "$PUSHR_URL/notify" \
-H "Authorization: Bearer $PUSHR_TOKEN" \
-d '{
"title": "Backup failed",
"body": "exit 2",
"priority": "high"
}'titletitlemessagebodyurlurl- Priority
-2-1011358
token(application)The source app's token, as a bearer headeruseror group keyNot needed: a push reaches everyone the source app is shared withpriority=2withretry,expire"high"plusack:timeoutSec= retry,maxAttempts= expire ÷ retry (up to 20). See Ack-or-escalateurl_titleAnopen_urlaction with your labelsoundChosen per priority level in Settings → Soundsattachmentuploadimage, a public URLdeviceChosen on the phone instead: each person switches delivery off for any of their devices in Settings → Devices
html,ttl,timestampNot available
From ntfy
Instead of a topic and headers, send one JSON object. Priorities, links, images, buttons and delays all have a direct match.
- 1Make a source app for each topic
- 2Move the headers into a JSON body on
/notify - 3Swap the topic or
tk_token for the source app's token
curl -H "Title: Backup failed" \
-H "Priority: high" \
-H "Click: https://homelab.lan" \
-d "exit 2" ntfy.sh/homelab-backupscurl -X POST "$PUSHR_URL/notify" \
-H "Authorization: Bearer $PUSHR_TOKEN" \
-d '{
"title": "Backup failed",
"body": "exit 2",
"priority": "high",
"url": "https://homelab.lan"
}'- Message (request body)
body Titletitle, requiredClickurlAttach(a URL)image- Priority
1…5135810
- Topic in the URLA source app, with its own token
ActionsviewAnopen_urlactionActionshttpAcallbackaction: a POST with pushr's JSON, no custom method or headersDelay/AtdeliverAt, in milliseconds- GitHub, Grafana templatesWebhook adapters for GitHub, Grafana and Sentry
Tags(emoji)Put the emoji in the titleMarkdown,Email,CallNot available
Piping into curl -d? The CLI reads stdin the same way: tail -n 5 backup.log | pushrsh "Backup failed"
From Gotify or iGotify
pushr already reads Gotify's field names, so most senders only need a new address and header. No Gotify server to run, and no iGotify bridge.
- 1Make a source app for each Gotify app
- 2Point the sender at
/notifyinstead of/message - 3Send the token as
Authorization: Bearer
curl -X POST "https://gotify.lan/message?token=$APP_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"title": "Backup failed",
"message": "exit 2",
"priority": 8
}'curl -X POST "$PUSHR_URL/notify" \
-H "Authorization: Bearer $PUSHR_TOKEN" \
-d '{
"title": "Backup failed",
"message": "exit 2",
"priority": 8
}'title,messagetitle(required),messageorbody- Priority
1…10The same scale extras client::notification click.urlurl
?token=orX-Gotify-KeyAuthorization: Bearer- Priority
0Rejected: send1, or leave priority out bigImageUrlNot read: sendimage
client::displayMarkdownBodies are plain text
From Hark
Both are webhook-to-iPhone services, so most fields carry straight over. Prompts become buttons, and Live Activities become a field on /notify.
- 1Make a source app for each Hark service
- 2Send to
/notifywith its token instead of the webhook URL - 3Turn prompts into buttons, as below
curl -X POST https://hark.ryan.ceo/hooks/whk_your_token \
-H "Content-Type: application/json" \
-d '{
"title": "GitHub",
"body": "Production deployed"
}'curl -X POST "$PUSHR_URL/notify" \
-H "Authorization: Bearer $PUSHR_TOKEN" \
-d '{
"title": "GitHub",
"body": "Production deployed"
}'body,title,urlThe same, buttitleis requiredIdempotency-KeyThe same header
responseapproval,yes_noTwocallbackactions, the risky onedestructiveresponsetextAreplyactioncallback.tokenPut it in thecallbackUrl: callbacks are unsignedimageUrlavatarThe source app's logo, set once in the appprojectOne source app per project- Withdraw a notificationSend a newer one with the same
replaceKey deviceIdsChosen on the phone instead of per push: each person switches delivery off for any of their devices in Settings → Devices, and a source app can be muted or given quiet hours
One endpoint instead of three: send liveActivity.action start, update or end on /notify, with an activityId you choose. See Live Activities.
title,status,progressstate.title,state.status,state.progresssymbolstate.icon, any SF Symbol- Failure on end
state.outcome: "failure" accentColor,style,ifSequenceNot available
- Reading a response over HTTPAgents wait with
ask bodyFormatMarkdown,summaryNot available
harkctl notify becomes pushrsh "Title" "Body" and harkctl activity becomes pushrsh la. For coding agents, add https://mcp.pushr.sh to Claude, ChatGPT or Cursor and they ask with ask.
Self-hosting
pushr's backend is open source. You can run it on your own Convex deployment and point the iPhone app at it, so your notifications never touch pushr's servers. Self-hosted backends have no plans or push quota: every feature is unlocked, for free, within a few fixed limits.
What you need
Both run the same pushr backend. Pick one and every step below shows only what applies to it; you can switch at any time.
- ✓Bun and a free Convex account
- ✓The pushr iPhone app
- ✓The pushr-backend source
1Create your deployment
git clone https://github.com/cpreston321/pushr-backend
cd pushr-backend
bun install
bun run devThe first bun run dev signs you in to Convex, creates a deployment and
pushes the schema and functions. It writes CONVEX_URL (ends in
.convex.cloud) and CONVEX_SITE_URL (ends in .convex.site) to
.env.local. You'll need both.
2Set the server secrets
These live in the Convex deployment, not in .env.local:
bunx convex env set BETTER_AUTH_SECRET "$(openssl rand -hex 32)"
bunx convex env set SITE_URL "https://<your-deployment>.convex.site"3Create your account
bunx convex run seed:createAdmin '{"email":"you@example.com","password":"<a strong password>"}'4Connect the app
- In pushr, open Settings → Server.
- Under Custom Convex Deployment, paste your
.convex.cloudURL. The.convex.siteURL is filled in from it.
-
Tap Test connection. It checks that
/healthzanswers from your deployment. -
Make a connection code on the computer you deploy from, and type it into the app:
bashbunx convex run pairing:createCode # { "code": "P4QM-2B2V", "expiresInMinutes": 15 } -
Tap Save & sign out. The app switches to your server right away; sign in with the account from step 3.
Connection codes
A self-hosted server only accepts new accounts that its owner lets in, so it
can't quietly turn into a public pushr. Only someone with access to the
Convex deployment can run pairing:createCode. Each code:
- lasts 15 minutes and works once;
- lets one new account sign up, in the app or with Sign in with Apple, within the next hour;
- isn't needed for accounts that already exist, or for ones you make with
seed:createAdmin.
After 20 wrong codes in 15 minutes, /pair answers further wrong codes with
429 (PAIRING_LOCKED) until the window passes. A real code always works.
The server's owner is any account seed:createAdmin made; run it again
with an existing account's email to make that account an owner too. On a
server set up before owners were recorded, the first account is the owner.
Anyone on the server can share an app with someone who already has an
account, but only the owner's invites let someone new sign up without a
code.
To go back, return to the same screen and tap Use pushr cloud.
If you change BETTER_AUTH_SECRET
The key that signs the app's Convex tokens is stored encrypted with the
secret. After changing it, sign-in still works but the app can't load
anything, and the logs show Failed to decrypt private key. Generate a new
key with:
bunx convex run maintenance:resetAuthKeys5Send a push
Create a source app in the Apps tab and copy its token, then:
curl -X POST "https://<your-deployment>.convex.site/notify" \
-H "Authorization: Bearer $PUSHR_TOKEN" \
-H "Content-Type: application/json" \
-d '{"title":"Hello","body":"from my own server"}'Updating
Pull the latest source and run bun run push: it updates the deployment
from step 1, the one your app and variables are on. Schema changes deploy
with the functions; there's no separate migration step. If you run a
separate production deployment (bun run deploy), it starts empty: set its
variables with bunx convex env set --prod …, create your account with
bunx convex run --prod seed:createAdmin …, point the app at its URLs, and
update it with bun run deploy.
Differences from pushr cloud
- Live Activities are not available with the App Store app. Starting and
updating them needs an APNs key from the team that publishes the app. A
push with
liveActivityis still accepted and arrives as a normal push. Everything else (pushes, actions, ack-or-escalate, widgets, webhooks) works. - Delivery goes through Expo's push service, the same as pushr cloud. Your server only needs outbound HTTPS.
- Plans don't apply. Pro features are on for every account on your deployment.
- AI agents connect to pushr cloud only.
mcp.pushr.shsigns in to a pushr cloud account. On your own server, agents send with the skills, SDK or CLI and a token instead. - Status pages are served as JSON at
/status-page/<slug>on your deployment; thestatus.pushr.sh/<slug>page shows pushr cloud's pages only. - The web dashboard works with your server. At
app.pushr.sh, choose Change server and enter
your
.convex.cloudaddress, then sign in with your email and password (no emailed links or Apple there). Status pages and plans are hidden. The server must allow the dashboard's origin:https://app.pushr.shby default, or setDASHBOARD_URLif you host the dashboard yourself. - Sign in with Apple is off unless you set
APPLE_SIGN_IN=enabled. Apple gives every server for the pushr app the same identifier for a person, so signing in to your server would link their Apple ID to their pushr cloud account. Deletion also can't revoke the Apple sign-in (that needs the publisher's key), and Hide My Email addresses only get email if your sending domain is registered with Apple.
That's the whole API. Go send one.
Paste a token into the console at the top and watch it land on your phone.