Paperplane
Read the docs

Pre-launch · iOS, Android & CLI

Push notifications for everything you run.

Paperplane sends notifications from your servers, scripts, pipelines and AI agents straight to your phone. Anything that can make an HTTP request can reach you — and when one needs a decision, you can make it from the message.

Get notified at launch
See how it works
  • One request to set up
  • Buttons that actually do something
  • Free for your first channel
Sending

Create a channel. POST to its URL. That’s it.

A channel is one source of notifications — your CI, your home server, a cron job, an agent. Each gets its own web address. No SDK, no library, no keys to rotate.

  1. 1 Sign in and pick a username
  2. 2 Create a channel
  3. 3 POST to its URL, forever
The whole integration 
curl -X POST "https://<host>/events/<username>/Deploys" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Deploy complete",
    "message": "api-service is live"
  }'

Only title and message are required. Priority, buttons and extra context are optional.

Buttons

Deal with it from the notification.

Knowing a deploy failed is only half of it. Add buttons to a notification and they show up on the message — tap one and Paperplane calls the web address behind it, then shows you what came back.

Re-run the pipeline. Roll back. Silence an alert for an hour. Whatever your systems already know how to do.

Hard to set on fire

Only http(s) endpoints, requests time out, and a cooldown per button so a stray tap can’t spam anything. Every press is recorded with what came back.

Two buttons on one message 
{
  "title": "Disk usage above 90%",
  "message": "db-primary · /var/lib/postgres",
  "priority": "High",
  "nature": "critical",
  "callback": [
    { "label": "Silence 1h",   "webhook": "https://ops.example.com/hooks/silence" },
    { "label": "Scale volume", "webhook": "https://ops.example.com/hooks/scale" }
  ]
}
Alerts

The ones that matter don’t get lost.

Mark a notification high priority or error and it becomes an alert: badged, counted, waiting on you instead of scrolling away. Acknowledge it, snooze it, or resolve it — and if it’s a tomorrow problem, turn it into a ticket that links back to the message.

  1. Open Nobody has touched it yet
  2. Acked Someone is on it
  3. Snoozed Hidden until later
  4. Resolved Done
AI agents

Your agent can ask before it acts.

Coding agents run for a long time without you. Paperplane lets them stop and ask: the agent sends a question with buttons and waits — really waits — until you tap one or it times out.

Only a signed-in human can answer; the agent can’t approve its own question. Works with Claude Code, Cursor, and anything else that speaks MCP. See how asks work.

A question your agent waits on 
// Your agent asks, then waits.
{
  "title": "Deploy staging to production?",
  "message": "12 files changed, all checks green.",
  "options": [
    { "id": "approve", "label": "Approve", "tone": "positive" },
    { "id": "deny",    "label": "Deny",    "tone": "destructive" }
  ],
  "timeoutSec": 300
}

// You tap a button. Only then does the agent carry on.
{ "status": "answered", "optionId": "approve", "elapsedSec": 41 }
Integrations

Point anything at it.

If it can curl, it can reach you — here’s that same request inside a GitHub Actions workflow.

.github/workflows/ci.yml 
- name: Tell me if CI breaks
  if: failure()
  run: |
    curl -sS -X POST "${{ secrets.PAPERPLANE_ENDPOINT }}" \
      -H "Content-Type: application/json" \
      -d '{
        "title": "CI failed on main",
        "message": "build · abc123",
        "priority": "High",
        "nature": "error"
      }'
Everything else

Also in the app.

Tickets

Turn anything into a to-do, with a due date and a reminder.

Terminal

paperplane-cli puts the same inbox in your terminal, and posts events from CI.

Shared channels

Invite people in. Everyone sees who acknowledged what.

Search

One search box across every message and every ticket.

Offline

Anything you’ve already seen stays readable with no signal.

Private

Data on your device is encrypted, and channels can be locked to your systems.

FAQ

Questions, answered.

What is Paperplane?

Paperplane is a hosted inbox for machine-generated events, built for a human to stay in the loop on what their systems and AI agents are doing. Create a channel per source — CI, cron, monitoring, an agent — and it gets its own HTTPS endpoint. Anything that can POST JSON to that URL shows up on your phone as a message you can read, reply to, act on, or defer onto a ticket.

What makes it different for AI agents specifically?

An agent can send a question with up to eight buttons and block on paperplane_ask until you tap one, on a real timeout. Only a signed-in human can answer — the agent’s own token cannot resolve the question it just asked, even if it holds every scope. That is the property that makes it safe to let an agent page you before a deploy, not just after one.

How is it different from email or Slack alerts?

Email buries alerts and team chat drowns them. Paperplane is built for the actual shape of the problem: a stream of short, timestamped, often actionable events, with one channel per source and buttons on the messages that need a decision.

What does it take to integrate?

One HTTP request. Create a channel, copy its endpoint URL, and POST JSON with a title and a message. Priority, nature, arbitrary context data and action buttons are all optional fields on the same payload. There is no SDK to install.

What are actionable callbacks?

A callback is a labelled webhook attached to an event. It renders as a button on the message, so you can approve a deploy or re-run a pipeline straight from the notification. Only http(s) endpoints are called, requests time out, each endpoint has a cooldown, and every trigger is recorded with the response it got back.

How do alerts work?

An event becomes an alert when its nature is error, failure, failed, critical or pending, or its priority is high, crit, critical or urgent. Alerts sit in one of four states — open, acked, snoozed, or resolved. Acknowledge and resolve sync to every device and to everyone in the channel; snooze stays private to your device.

Can I share a channel with other people?

Yes. A channel is personal by default but you can invite others by username or by sharing a link or QR code, with join requests the admin approves. Ack and resolve are visible to everyone in the channel and attributed to whoever handled it; snooze stays private to the device that set it.

What does it cost?

One channel is free, with up to 1,000 events a day. $5 a month removes the channel limit. There is no separate charge for the MCP connector or for asks.

Is my data private?

Local data is stored encrypted on-device, and ticket text — titles, notes, checklist items, tag labels — is encrypted at rest on the server. That protects a stolen device or a raw database read; it is not end-to-end encryption; Paperplane’s backend can decrypt what it stores. Endpoints can be locked with a per-channel endpoint key so only your systems can post to them.

Is Paperplane available yet?

Paperplane is pre-launch — iOS and Android store releases are on the roadmap. It is a hosted service; there is no self-hosting option. The MCP connector, paperplane-mcp, is open source and published on npm, so it can be used with the hosted API today.

Point your first system at it.

One channel is free, $5 a month for unlimited. Paperplane is pre-launch — leave your email and we’ll tell you when the apps ship.

Get notified at launch
Read the docs