Introduction

Burner Protocol gives every Solana payment its own address. The receiver sweeps it, the address burns, and nothing on-chain connects one payment to the next.

What it is

A burner tag is one public string you can share anywhere. It never receives money itself. When someone pays it, their browser derives a one-time burner: a normal Solana address that has never existed before and that only you can sign for.

You find your burners by scanning public announcements with a private view key, sweep the funds into a wallet of your choice and close the burner. What is left on-chain is a closed account with no future transactions. We call it ash.

What it is not

• Not a pool. Nobody's funds are mixed or held together. Each payment is an ordinary system transfer.
• Not a contract. There is no on-chain program to audit, upgrade, pause or drain.
• Not custody. From the first block, the only key that can move a burner's funds is yours.

Where to go next

Quick start

The whole loop in the sandbox on the main page. No wallet, nothing leaves your browser.

Five steps

1. Derive your keys. Open the sandbox, stay on Receive and press Sign to derive keys. You get a spend key, a view key and a burner tag that starts with br:sol:.
2. Pay yourself. Press Pay yourself. The Send tab opens with your tag filled in. Set an amount, add a note if you like, press Pay.
3. Look at the chain. The Explorer tab now shows your payment: an amount, a one-time burner, a br1: memo and “hidden” where the receiver would be.
4. Scan. On the Inbox tab press Scan announcements. Your view key is tried on every memo, and your payment shows up with its note decrypted.
5. Sweep. Press Sweep. The funds go to a fresh wallet and the burner is closed. In Explorer its state turns to ash.

How it works

Three roles, three steps, one shared secret that only the sender and the receiver can compute.

1. The receiver publishes a tag

You sign one fixed message with your wallet. The signature is turned into two private keys, spend and view, and their public halves are packed into a burner tag. The tag is safe to post anywhere and never changes.

2. The sender lights a burner

The sender's browser picks a random number, combines it with your tag and gets two things: a one-time burner address and a public point R. It sends the funds to the burner and puts R in a short memo on the same transaction.

3. The receiver sweeps and burns

Your browser reads every memo, combines R with your view key and checks whether the result produces the burner in that transaction. If it does, the payment is yours, and your spend key plus the same secret can sign for it. You sweep the balance out and close the account, which also returns its rent.

Glossary

Every word the rest of the docs uses, in one table.

Receive

One signature creates your keys. The tag built from them is the only thing you ever hand out.

What you sign

Burner Protocol v1
Derive my burner keys.
This signature never leaves this browser.
Only sign this on burnerprotocol.

Wallets sign deterministically, so the same wallet always gives the same keys. That is why you never have to back them up separately: your wallet is the backup.

Sharing your tag

Paste it in a bio, print it on an invoice, put it in a QR code. Posting it publicly does not reveal any of your payments, because none of them are sent to the tag itself.

Locking

Lock wipes the keys from the tab. Signing again restores exactly the same tag and the same inbox.

Send

Pay a burner tag or an @handle in SOL, USDC, USDT or any standard SPL token.

Fields

What the chain shows

• A transfer from your wallet to an address that never existed before
• A memo with a random point R and a one-byte view tag
• Nothing that names the receiver and nothing that links it to their other payments

The sender is visible as usual. If you want to hide that too, pay from a burner you received earlier.

Inbox and sweeping

Scanning happens on your device. The server only ever hands out public announcements.

Scanning

For each announcement the inbox computes the shared secret from R and your view key, compares the view tag and, on a match, checks the full burner address. A scan cursor is remembered so the next scan starts where the last one stopped. Keys and matches are never stored.

Sweeping

Sweeping signs a transfer of the full balance from the burner to the wallet you choose, then closes the burner and returns its rent to the same wallet.

Sweep all

Sweeps every unswept burner one by one. They go out as separate transactions on purpose: one transaction touching all your burners would announce that they share an owner.

@Handles

A short name instead of a long tag. Payments to it still land in fresh burners.

Name rules

• 3 to 15 characters: a–z, 0–9 and _
• No _ at the start or the end, never __
• First valid claim wins. No expiry, no renewal

Price

Claims burn whole $BURNER from the claimer's wallet. Burned tokens are destroyed, nobody receives them.

What is public

The wallet that burns is publicly linked to the handle. Payments to the handle are not: each one still goes to a new burner. The owner can point the handle at a new tag later with a free signature, and the newest signed update wins.

Private notes

120 bytes that only the receiver, or whoever holds their view key, can read.

The note is encrypted with a key derived from the payment's shared secret and travels in the same memo as R. Nobody else can open it, and every note uses a different key because every payment has a different secret.

How long is 120 bytes

About 120 Latin characters, fewer with emoji or Cyrillic. Enough for “rent, March” or an invoice number. Not enough for a letter, which is the point.

Exchange withdrawals

Exchanges cannot attach memos, so your inbox derives withdrawal burners itself.

1. On Receive, copy the address under “Exchange withdrawal burner”.
2. Paste it into the exchange as the withdrawal address.
3. Next time press Use a new one. Never reuse a withdrawal burner.

These burners are derived from your keys and a counter, so the inbox finds them without any announcement. The exchange sees a fresh address every time and never meets your main wallet.

Links and invoices

A link anyone can pay, prefilled with your tag, amount and note. Every payer still gets their own burner.

Link format

https://burnerprotocol.vercel.app/#pay?to=br:sol:…&amount=0.25&note=invoice%200042

Pay button for your site

A plain link with inline styles. No script, no tracking, nothing loads from us until someone clicks.

<a href="https://burnerprotocol.vercel.app/#pay?to=@yourname&amount=10&token=USDC"
   style="display:inline-block;padding:12px 18px;border-radius:10px;
          background:#ff7a3d;color:#1a0a02;font:600 15px system-ui;
          text-decoration:none">Pay privately</a>

Key derivation

Dual-key stealth addresses on Ed25519, the curve every Solana wallet already uses. G is the base point, H is SHA-512 reduced mod ℓ.

Receiver, once

sig   = wallet.sign("Burner Protocol v1 …")
s     = H("br/spend" ‖ sig)      // spend key
v     = H("br/view"  ‖ sig)      // view key
S, V  = s·G, v·G
tag   = "br:sol:" + b58(S ‖ V)

Sender, every payment

r       = random scalar
R       = r·G
k       = H("br/shared" ‖ r·V)
burner  = S + k·G
viewtag = first byte of H("br/tag" ‖ r·V)
transfer(amount → burner) + memo("br1:" + b58(R) + hex(viewtag))

Receiver, scanning

for each announcement (R, viewtag, burner):
  if first byte of H("br/tag" ‖ v·R) ≠ viewtag: skip   // 255 of 256
  k = H("br/shared" ‖ v·R)
  if S + k·G = burner: mine, signing key = s + k

It works because r·V = r·v·G = v·R: the sender and the receiver reach the same secret from opposite sides, and nobody else holds either r or v.

Formats

Every string Burner Protocol puts on-chain or hands to a user.

Versioning

The br1: prefix carries the version. A new memo format gets a new prefix, and scanners keep reading the old one, so no burner is ever orphaned.

Threat model

What the protocol hides, what it cannot hide, and the one mistake that undoes it.

Public

• Every burner, its amount, its memo and its time
• The sender's wallet, unless they pay from a burner
• The wallet that claimed a handle

Private

• Who a burner belongs to
• That two burners share an owner
• Notes, to anyone without the view key

On you

• Where you sweep. Ten burners swept into one wallet are ten burners with one owner.
• Timing. Sweeping seconds after every payment makes the pair easy to guess. Let them sit.
• Odd amounts. 13.37 SOL is memorable. Use split.
• Your view key. Whoever holds it sees every payment you receive.

$BURNER

The token behind @handles. Every claim burns some of it, and burned tokens are gone for good.

Contract address

soon

The same address is on the main page. Check that they match before trading anything called $BURNER.

What it does

• Claiming an @handle burns $BURNER at the prices in @Handles
• Payments and sweeps never need it: they cost ordinary SOL fees only
• The protocol itself has no contract, so the token has nothing to govern and nothing to upgrade

FAQ

Short answers to the questions people ask right before they sweep into their main wallet.

Is this a mixer?

No. Nothing is pooled. Each payment is a normal transfer to a new address that belongs only to the receiver.

Can someone freeze my burners?

There is no contract and no admin key. There is nothing to freeze.

What if I lose my keys?

Sign the same message with the same wallet and you get the same keys back. Lose the wallet and you lose the burners, same as any other Solana address.

Why does the burner have to burn?

Closing it returns the rent and makes sure it is never reused. A reused burner is just an address with a history, which is the thing we are trying not to have.

Does the sandbox move real money?

No. It generates keys and addresses inside the tab and keeps every number in memory. Close the tab and it is gone, like a good burner.