// one-time encrypted notes

Read once.
Then ash.

Mainnet live · checking… Status: Ticker (placeholder, no token exists):
// a note was struck for you

A note is waiting.

It is encrypted. The key is in this link's #fragment, which never reached the server.

This will burn on open. Pressing the button below fetches the ciphertext and the server deletes it in the same step. Nobody — including you — can open this link again. Link previews and bots can't burn it: they don't press buttons.
Checking whether the note is still sealed…
Not now
// the working app

Strike a note. Send the link. Watch it burn.

Encryption happens in this page with Web Crypto before anything is uploaded. The x-ray on the right shows, byte for byte, what the server receives.

New note

Plain text, up to 60 KB. Whoever opens the link first reads it; after that it's gone.

burns unread after
Add a passphrase · second lock, optional Derived with PBKDF2-SHA256 (600,000 rounds) into a second AES-256-GCM key. A stolen link alone is then not enough.
Attach a Solana address · optional, reader can check it live
your one-time link

Server x-ray

Exactly what this upload contains, and what never leaves the page.

Server receives

POST /api/notes
(nothing sent yet)

Stays in your browser

    Like any website, the server also sees your IP address and the time of each request.

    Prove it burns

    Runs a real round trip against this server: seal a throwaway note, read it once, then try to read it again.

      // how it works

      Five strikes, one flame

      1. Seal in the page. Your browser makes a random 256-bit key with crypto.getRandomValues and encrypts the note (plus any attached address) with AES-256-GCM under a fresh 96-bit IV. With a passphrase, the note is first wrapped in a second AES-256-GCM layer whose key comes from PBKDF2-SHA256 with a random salt.
      2. Upload ciphertext only. The page posts { ttl, ct } to /api/notes. The server gives back a random 128-bit note id and a delete token. It keeps the ciphertext in memory with an expiry time — nothing else about the note.
      3. Key in the fragment. The link is /#n=<id>.<key>. Everything after # stays in the browser: it is not part of the HTTP request, so it never appears in server logs.
      4. Burn on an explicit click. Opening the link does nothing by itself. Only pressing Burn & open sends POST /api/notes/<id>/burn; the server looks the note up and deletes it in the same synchronous step, so exactly one request can ever get the ciphertext. Every later attempt gets 404.
      5. Decrypt locally, scrub the link. The reader's browser decrypts with the key from the fragment (and the passphrase, if any), then removes the key from the address bar. If the timer runs out first, the server drops the note unread.
      // privacy model

      What the server can and can't see

      The server can't see

      • The note text — only AES-256-GCM ciphertext arrives
      • The key — it lives only in the link #fragment
      • Your passphrase, or whether you used one (the flag is in the fragment too)
      • Any attached Solana address — it is sealed inside the ciphertext
      • Who the note is for

      The server can see

      • Ciphertext size (roughly the note length) and the expiry you picked
      • The IP address and time of whoever creates, checks or burns a note
      • That a given note id was read, and when
      • If the reader checks an attached address: that address, via the read-only RPC call to mainnet (and the upstream RPC provider sees it too)

      Burnnote reduces how long a secret sits around and who can read it. It does not make anyone anonymous.

      Known limitations — please read

      • The link is the secret. Anyone who gets the full link before your recipient can read the note — and then your recipient sees "gone". Use a passphrase sent another way for anything sensitive.
      • Burn-after-reading is server-side only. Once decrypted, the reader can copy, screenshot or keep the text. Nothing can un-show a note.
      • Memory only. Notes live in this server's memory, expire after 1 h / 24 h / 7 d, and are all lost on restart or redeploy. Max 5,000 notes, 64 KB each; when full, new notes are refused.
      • You trust the page you load. The encryption code is served by this site. A compromised or malicious server could ship code that leaks keys. There is no browser extension or reproducible build yet.
      • Metadata is visible. The server sees IPs, timing and sizes. A note's length can hint at its content.
      • The address check is a lookup, not a guarantee. It reads public mainnet data through a public RPC endpoint; it doesn't prove who owns the address or that it's safe to pay.
      • Experimental and unaudited. Not reviewed by anyone. Don't use it for anything where a leak would seriously harm you or others.