# Paperplane

> Push notifications for everything you run. Paperplane turns any system you run — a deploy pipeline, a cron
> job, a monitoring rule, an AI agent — into a channel you read like a chat
> thread. Each channel gets its own HTTPS endpoint, so anything that can POST
> JSON can reach your phone, and an agent can wait for your answer.

Paperplane is a hosted notification inbox for developers, built as a React
Native app for iOS and Android. It is closed source and currently pre-launch:
not yet on the App Store or Google Play. There is no self-hosting option.
The MCP connector, paperplane-mcp, is being open-sourced and published to
npm — also pre-launch.

Pricing: 1 channel free (up to 1,000
events/day), $5/month for unlimited channels.

## What it does

- **Asks** — an agent sends a question with up to 8 buttons and blocks
  (`paperplane_ask`) until a human taps one or it times out. Only a signed-in
  human can answer; the asking agent's own token cannot resolve its own
  question, even with every scope.
- **Inbox** — one channel per system, each with its own event endpoint. Live
  in-app delivery plus push notifications. Optional per-channel endpoint key,
  display label and emoji. In-thread replies. Shareable via invite link, QR
  code or username, with admin-approved join requests.
- **Callbacks** — labelled webhooks attached to an event, rendered as buttons on
  the message. Tap to fire; the response is shown inline. Optional GET/POST and
  JSON body, a per-endpoint cooldown, and a full trigger history.
- **Alerts** — events whose `nature` is error/failure/failed/critical/pending, or
  whose `priority` is high/crit/critical/urgent, become alerts. States: open,
  acked, snoozed, resolved. Ack and resolve sync across devices and to the
  channel; snooze stays local to the device that set it.
- **Tickets** — a personal board (open, in progress, blocked, done) with
  priorities, colour-coded tags, due dates, reminders and checklists. Alerts can
  be deferred onto a ticket that links back to the message.
- **AI tools (MCP)** — `paperplane-mcp`, nine tools: send a blocking ask, check
  an ask asynchronously, send a plain event, list channels, list messages,
  set alert state, reply, list tickets, create a ticket. Auth is a scoped,
  revocable personal access token — not the user's sign-in.
- **Throughout** — search across inbox and tickets, light/dark/system themes,
  offline reading, and local data encrypted on-device (device-local encryption;
  server-side data is encrypted at rest with a key the server holds, not
  end-to-end).

## Sending an event

Create a channel, then POST JSON to its endpoint:

    POST https://<host>/events/<username>/<Channel Name>
    Content-Type: application/json
    X-Paperplane-Endpoint-Key: <optional endpoint key>

    {
      "title":    "Deploy failed",                 // required
      "message":  "api-service · main @ abc123",   // required
      "priority": "Crit",                          // optional
      "nature":   "error",                         // optional
      "dataJson": "{\"run\":\"4821\"}",              // optional extra context
      "callback": [                                // optional action buttons
        { "label": "Re-run pipeline",
          "webhook": "https://ci.example.com/hooks/rerun" }
      ]
    }

Only `title` and `message` are required. There is no SDK — the endpoint URL is
the entire integration.

## MCP tools

- `paperplane_ask` — send a question with buttons, block until answered or timed out
- `paperplane_check_ask` — recover an answer after the client's own tool-call timeout
- `paperplane_send_event` — push a notification, with priority and buttons
- `paperplane_list_channels` — see which channels exist
- `paperplane_list_messages` — read recent events and replies, with alert status
- `paperplane_set_alert_state` — acknowledge or resolve an alert
- `paperplane_reply` — leave context in the thread
- `paperplane_list_tickets` — check what is already tracked
- `paperplane_create_ticket` — file a follow-up, linked back to the alert

## FAQ

### 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.

## Links

- Home: https://paprpla.in/
- Documentation: /docs/
- API contract: /docs/#api
- MCP server: https://www.npmjs.com/package/paperplane-mcp
- Source: https://github.com/ParikshithV/paperplane-mcp

## Status

Pre-launch. iOS and Android store releases, channel filters and unread state,
and a hosted MCP connector are on the roadmap.