NoPeek — Chat APIs your servers can’t read

01 live demo

One conversation, two views.

Left: your user’s device. Right: our relay — and everything it will ever know.

Same events, same order. The relay routes on metadata; the body never decrypts server-side.

02 threat model

What we can see. What we can’t.

Routing needs metadata. Content needs nothing from us. We’d rather show you the line than market around it.

Visible to NoPeek

Sender & recipient IDsusr_ana → ch_9f2Kq
Channel membership3 members · joined tue
Timing & message size14:02:33.914 · 184 B
Key rotationsepoch 41 → 42
Delivery & read acksreceipt.read ref=msg_8x1F
Push tokensapns:2f81…c0

Never visible

Message text
Edits — including prior versions
Reactions
File attachments
Link previews & GIF picks
History backups

This split is the protocol, not a policy. Policies change; math doesn’t.

03 feature set

The whole feature set. Still ciphertext.

Encryption is not the tradeoff. Everything you’d ship with a plaintext chat API, shipped encrypted.

instant delivery: WebSocket fan-out in tens of milliseconds. Speed is not the price of privacy.
edit: Fix it after you send it. Superseded ciphertext is dropped, not archived.
recall: Un-send for everyone. We purge the blob; clients redact the bubble.
reactions: Encrypted like everything else. We can’t tell applause from condolences.
threads: Branch the conversation. Same channel, same encryption envelope.
typing indicators: Presence without content. We see that someone types, never what.
receipts: Delivered and read, per member, per message.
GIFs & link previews: Unfurled on the device, so our servers never fetch your users’ URLs.
attachments: Files encrypted client-side. We store blobs we cannot open.
history sync: New device? History arrives as ciphertext and decrypts locally.
push: Notifications with encrypted payloads. The lock screen decrypts; APNs doesn’t.
webhooks: Every event your backend needs — metadata in, ciphertext opaque.

04 security

Boring, audited math.

No homegrown crypto. NoPeek runs the IETF’s Messaging Layer Security protocol — the standard built for encrypted groups at scale.

Protocol specification summary
protocol	MLS RFC 9420
ciphersuite	X25519 · AES-128-GCM · SHA-256 · Ed25519
forward secrecy	yes — per-epoch key rotation
post-compromise security	yes — self-healing group state
group size	2 to 50,000 members per channel
keys visible to NoPeek	none

HIPAA-ready by construction

Our servers only ever store ciphertext, so PHI never exists in plaintext on our side — at rest, in transit, or in a backup. BAA available on the Pro plan.

Opting out is loud

Some products need server-side moderation, so plaintext channel types exist — as an explicit, per-channel-type opt-out. It’s badged in the dashboard, in every API response, and in the client UI. There is no quiet downgrade.

E2EE OFF — EXPLICIT OPT-OUT "e2ee": false never hides.

05 pricing

Encryption is not a tier.

Two prices and a conversation. Every plan is end-to-end encrypted by default — privacy is not a gate. launch pricing — rates will change; existing apps keep theirs for 12 months.

Free

$0/mo

For development and test.

1 app · 500 MAU
Full E2EE, all features
JS SDK + Platform API
Community support

Coming soon

NoPeek Pro

$499/month

HIPAA compliance + E2EE included.

Production apps · 50,000 MAU
BAA available
99.95% uptime SLA
Encrypted attachments, 1 TB
Priority support

Coming soon

Enterprise

Talk to us

When your auditors have auditors.

Data residency
SSO / SCIM
Dedicated relays
Security-review support

hello@nopeekapi.com

MAU = monthly active users who connect at least once. Overages billed, never blocked.

06 ai-first integration

Let your AI agents build on NoPeek.

Ship the NoPeek MCP server and any Model-Context-Protocol client — Claude, Cursor, your own agents — can provision and operate encrypted chat infrastructure with a single API key. No glue code: the agent creates apps, workspaces, users, channels, issues keys, sends messages, and reads usage through typed tools.

16 typed tools, one key

Point an agent at the server with your NOPEEK_API_KEY and it can stand up a full messaging backend from a natural-language prompt — everything still end-to-end encrypted, your servers still storing only ciphertext.

create_app · issue_api_key · get_app_config
create_workspace · add_workspace_member · create_user
create_channel · send_message · list_messages
get_audit_log · get_usage · …and more

“Spin up an app called acme-support, add two users and a group channel, and send a welcome message” — done in one turn.

// claude_desktop_config.json — add the NoPeek MCP server
{
  "mcpServers": {
    "nopeek": {
      "command": "npx",
      "args": ["-y", "@nopeek/mcp"],
      "env": {
        "NOPEEK_API_KEY": "npk_live_…"
      }
    }
  }
}

MCP guide → npx @nopeek/mcp

07 ai-agent ready

Bring your own AI agent. It runs on your hardware.

NoPeek Messenger is agent-ready out of the box. Install one npm package on a Mac, Linux box, or Raspberry Pi, pair it to your account once, and then create bots from your phone — picking Claude or Hermes per bot. Your agent decrypts and replies on your computer; our servers still only ever hold ciphertext. Your agent, your hardware, your keys.

1 Install the bridge

On the computer that will run your bots (macOS, Linux, or a Pi). It installs a small background service that starts at login and waits, unpaired.
```
npm install -g @nopeek/agent-bridge
nopeek-agent-bridge install
```
The bridge uses whatever agent you already have — it doesn’t install Claude Code or Hermes for you. Install and log into those once, and it detects them.
2 Pair it to your account

In the app, open Contacts → My Bots → Connect your computer to get a one-time code, then run it on that computer:
```
nopeek-agent-bridge install \
  --pair npr_XXXXXXXX \
  --app-id app_XXXXXXXX
```
On the same computer as the app? Skip the code — Connect this computer pairs it in one tap; the secret never leaves the machine.
3 Create a bot from your phone, pick its brain

Tap Create a bot. NoPeek shows only the brains your computer actually has ready — pick one, and your machine provisions and runs it within seconds. No restart, no redeploy. Every bot is properly isolated: a Hermes bot gets its own Hermes profile (its own soul and memories, visible in hermes profile list), a Claude bot its own personality and workspace — they share your login, never a brain.

Installed isn’t the same as ready: a brain greyed out as “not logged in” means its CLI needs a login on that computer — run claude or hermes login there once. The picker rechecks every few minutes and flips it to available on its own. Install a new agent next month and it shows up the same way.

New bot

Choose a brain

ClaudeRecommended · ready on your Mac

Hermesnot logged in on your computer

EchoTest mode · no login needed

Create bot

Runs on your paired computer · ciphertext to us

What you see on the phone — the picker offers only what your machine can run.

Your phone ciphertext NoPeek serversstore ciphertext only ciphertext Your computerdecrypts · your agent replies

Bridge on npm → npm i -g @nopeek/agent-bridge

08 nopeek messenger

The same math, as an app.

NoPeek Messenger is the reference client we ship on our own infrastructure — a full E2EE messenger for teams and orgs, on iOS, Android, and the web. Everything below rides the exact protocol demoed above: ciphertext to us, plaintext to you.

calls that ring like calls: Incoming calls light up the native call screen — CallKit on iOS, full-screen call alerts on Android. The call itself is peer-to-peer WebRTC, encrypted end-to-end. We never record calls; we couldn’t play them back if we did.
AI bots on your computer: Bots run on the owner’s machine via @nopeek/agent-bridge — never on ours. A bot decrypts only in the groups its owner explicitly grants it. Private by default; your agent, your hardware, your keys.
share into NoPeek: NoPeek sits in your phone’s share sheet. Photos and files you share in are encrypted on-device before they go anywhere.
org admin controls: HIPAA-friendly controls for compliance-minded orgs: admins can switch off saving media to device galleries org-wide, manage membership, and control who reaches a bot. Controls, not certifications — bring your own compliance program.
save to gallery — on your say-so: Media is saved to your photo library only when you tap Save, using write-only access. The app can add that photo; it can’t browse the rest.
never logged out: Sessions persist across restarts and updates. Lose every device and your history still comes back — recovery is an encrypted key backup that only your email + password can unwrap. We store the blob; we can’t open it.
opens instantly: Recent messages are cached decrypted on your device — and only there — so chats open before the network does.
locked to your face: Biometric app lock, privacy screen, and QR device linking. New devices join with a scan, not a password reset.

iOS via TestFlight today, App Store next; Android and the web too. App privacy: Privacy Policy · Messenger EULA.

09 quickstart

First message in minutes.

Sign up, create an app, get keys. No sales call — a subpoena wouldn’t get anything out of us either.

1 Create an app

Account sign-up is coming soon. Once open you’ll add an app and copy your keys — or: Or do it from the Platform API:

# REST Platform API · OpenAPI 3.1 spec at /openapi.json
curl https://api.nopeekapi.com/v1/apps \
  -H "Authorization: Bearer np_sk_live_…" \
  -d '{ "name": "acme-support" }'

2 Install the SDK
```
npm i @nopeek/chat
```

3 Connect and send

import { NoPeek } from "@nopeek/chat";

const np = await NoPeek.connect({ appId, sessionToken });
const channel = await np.channels.create({ members: ["usr_ana", "usr_ben"] });
await channel.send({ text: "encrypted before it leaves this device" });

MLS key exchange, epoch management and device sync happen inside the SDK. You never touch a key. Webhooks tell your backend everything it’s allowed to know.

Coming soon API reference

Chat APIs your servers can’t read.