binthere is a zero-knowledge, end-to-end encrypted pastebin. Write a note, get a link, share it — and the note self-destructs the moment it's read. Your browser encrypts everything with AES-256-GCM before it leaves your device, so the server only ever holds ciphertext it can't read. Think of it as a self-destructing envelope for text: secrets, credentials, a private message, a snippet of code.

binthere is a clean-room rebuild inspired by PrivateBin's zero-knowledge model — modern Web Crypto, a strict CSP, atomic burn-after-read, and a real test suite, with the ~700 KB of jQuery/Bootstrap/zlib-WASM stripped out. It runs as a single Cloudflare Worker (Static Assets + KV + a Durable Object), so hosting is cheap and there is no server to maintain.

• No accounts, no tracking. Paste, share, done. There is nothing to sign up for and no analytics watching you do it.
• Nobody can recover a lost link. Not even the operator — there is no key to look up and no index of pastes. The link is the only copy of the key, by design.
• Honest limits. The server still sees IPs, timings, and ciphertext sizes (it's private, not anonymous), and like all in-browser crypto it trusts the code the site serves — the full threat model is in SECURITY.md and summarized under Limitations.

Pick binthere if you want a paste service you can deploy in one command with nothing to patch, back up, or keep online yourself.

The whole design rests on one trick: where the decryption key lives. It travels in the URL fragment — the part after # — which browsers never send to any server.

you type ──▶ browser encrypts (AES-256-GCM) ──▶ Worker stores ciphertext only
                     │                                      │
              key stays in the URL #fragment          KV or Durable Object
                     │                                      │
recipient opens link ─▶ browser fetches ciphertext ─▶ browser decrypts ─▶ plaintext

1. You write a note. Your browser generates a random 256-bit key and encrypts the note locally with AES-256-GCM — before any network request is made.
2. Only ciphertext is uploaded. The key is never sent; it's appended to your link after #. The server stores an opaque blob it has no way to read.
3. You share the link. It carries both the note's id and the key (…/p/<id>#<key>) — the link is the capability to read the note. Optionally, add a password: it's mixed into the key derivation, so neither the link nor the password alone can decrypt.
4. The recipient opens it. Their browser fetches the ciphertext, reads the key from the fragment, and decrypts locally. The server never sees plaintext at any point.

Every note is one-time view: the first reader atomically consumes it (exactly one winner, even under simultaneous clicks — a Durable Object guarantees it), and everyone after gets 410 Gone. Unread notes self-delete after 24 hours regardless.

All of these are solid zero-knowledge paste/secret tools — the difference is mostly in how they are hosted and what they optimize for:

Requires Node.js ≥ 20 (.nvmrc pins 22).

npm install
npm run dev      # wrangler dev → http://127.0.0.1:8787

KV, the Durable Object, and rate limiting are all emulated locally — no Cloudflare account needed for development.

CI runs lint, a byte-for-byte test-vector diff, and the full suite.

An official command-line client lives in cli/ and is published to npm as binthere. It implements the same frozen protocol as the web client — encryption happens locally, only ciphertext is uploaded, and notes have the same one read / 24 hours lifecycle as the website. Zero runtime dependencies (Node ≥ 20 built-ins only).

npm install -g binthere    # or try it without installing anything: npx binthere

A bare binthere opens an interactive full-screen menu; it also composes in pipelines (git diff | npx binthere prints a share URL on stdout). See cli/README.md for the full command reference, interactive-mode tour, and security notes.

You can run your own binthere — nothing about the design ties it to the public instance, and there is no managed service in the loop. Because it's a single Cloudflare Worker (Static Assets + KV + a Durable Object), it's optimized for Cloudflare Workers and one of its biggest advantages is cost: a complete instance fits inside Cloudflare's free tier, so you can host binthere completely free.

The button above clones the repo and provisions everything declared in wrangler.toml — the static assets, the PASTES KV binding, the BurnPaste Durable Object + migration, and the CREATE_RL rate limiter — on your own Cloudflare account. The importer creates fresh resources and rewrites the resource ids in your copy of the config; the checked-in ids belong to the origin deployment and are identifiers, not secrets.

If the one-click path ever misbehaves, the manual route below is the guaranteed fallback:

npm run kv:create        # create your own PASTES KV namespace (+ preview)
# paste the printed id / preview_id into wrangler.toml
npm run deploy           # creates the Worker, Durable Object, and rate limiter

See ARCHITECTURE.md for the request path and SPEC.md for the exact cryptographic protocol and paste format v1, including frozen test vectors.

public/            static frontend (CSP-clean; served by Workers Static Assets)
  index.html  css/styles.css  js/*.js  fonts/*.woff2  img/ (favicon.svg + png fallbacks + wordmark[-dark].svg)
  _headers  robots.txt  favicon.ico  opengraph.png  .well-known/security.txt
src/
  index.js         Worker: /api/paste routing + asset fallback
  burn-do.js       BurnPaste Durable Object (atomic burn-after-read)
  lib/             ids, storage routing, rate-limit wrapper
test/              vitest suites (run in workerd) + genvectors.mjs (vector regenerator)
                   + vectors.expected.txt (pinned vector output, diffed in CI)
tools/             verify-vectors.py — independent Python cross-check of the frozen vectors
cli/               the npm-published CLI client (own package.json + Node-environment tests;
                   vendor/ mirrors public/js/{bytes,format,crypto,qrcode}.js, drift-tested)
SPEC.md SECURITY.md ARCHITECTURE.md
CHANGELOG.md CONTRIBUTING.md CODE_OF_CONDUCT.md LICENSE

Most of these are deliberate scope choices, not bugs. Know them before relying on binthere:

• Not anonymous or metadata-free. The server sees IP, timing, ciphertext size, and the non-secret adata (IVs, KDF params, format flags). It only cannot read your plaintext (SECURITY.md §3).
• No protection from a compromised deployment. Decryption runs in JavaScript the server delivers, so a malicious or hacked host could serve code that leaks your key. In-browser E2E encryption trusts the origin (SECURITY.md §4).
• Lose the link, lose the note. No accounts, no server-side index — the id + key exist only in the URL you share. Nobody, including you, can recover or list pastes.

Roughly in priority order:

• Official CLI client — shipped; on npm as binthere (see CLI)
• Argon2id as a versioned password-KDF option alongside PBKDF2 (spec-first: vectors before code)
• File attachments — encrypted binary blobs with size limits (likely R2 for large files)
• Headless-browser CSP + render test (Playwright) in CI, asserting zero CSP violations across the create/view/burn flows

binthere is a security-sensitive cryptographic application. The threat model, explicit non-goals, and vulnerability-reporting process are in SECURITY.md; the frozen protocol and paste format live in SPEC.md.

Issues and PRs are welcome — see CONTRIBUTING.md. Two hard rules:

1. Crypto is spec-first. Any change to the protocol, paste format, or canonical AAD must update SPEC.md first — never silently — then regenerate the frozen vectors with node test/genvectors.mjs (and refresh test/vectors.expected.txt, which CI diffs byte-for-byte). Never hand-edit the pinned hexes in test/crypto.test.js.
2. Keep the CSP strict and rendering XSS-safe. No inline styles/scripts, no CDNs, no innerHTML on user content. New rendering paths need a case in test/markdown.test.js.

Run npm run lint and npm test before opening a PR; all suites run in the real workerd runtime.

• Cloudflare Workers — Static Assets, KV, Durable Objects, native rate limiting
• Vanilla JavaScript (native ES modules) — no framework, no bundler for the frontend
• Web Crypto API — AES-256-GCM, PBKDF2-SHA256
• Vitest — Worker suites in the real workerd runtime, CLI suites in Node
• ESLint 9 — flat config

• PrivateBin — the zero-knowledge pastebin whose model this is a clean-room rebuild of
• qrcode-generator by Kazuhiko Arase (MIT) — vendored in public/js/qrcode.js for offline, CSP-safe QR rendering
• Newsreader by Production Type, Geist by Vercel, and JetBrains Mono by JetBrains (all SIL OFL 1.1) — self-hosted in public/fonts/; license texts in public/fonts/THIRD-PARTY-NOTICES.md

MIT © 2026 nxfu

Built to be shared once and forgotten.
If binthere is useful to you, consider giving it a ⭐ — it helps others find it.