◈OpenTree DashboardSign in

$ burn_after_read: true

A link that works exactly once

Burn-after-read closes the page permanently after the first successful open. The second request gets 410 — from the same URL, for everyone, including you.

Turn it on

publish_html({
  content: "<h1>Handover</h1>…",
  burn_after_read: true,
  expires_in_hours: 24
})

Or on a page that already exists:

curl -X PATCH https://read.botook.ai/sites/SITE_ID \
  -H "Authorization: Bearer otr_live_YOUR_KEY" \
  -H "content-type: application/json" -d '{"burn_after_read": true}'

What counts as the first open

A successful content response. A request that is refused — wrong password, wrong email domain, an expired link — does not consume the single open, because otherwise anyone who could reach the URL could burn it before the intended recipient arrived.

What the second visitor sees

$ curl -si https://read.botook.ai/p/UNLISTED_TOKEN/ | head -1
HTTP/2 410

Gone, not "not found" — the distinction is deliberate. The recipient who is late knows the link existed and was consumed, and can ask for another rather than wondering if they mistyped it.

Where it earns its keep

It is not a self-destructing message

The content is stored normally until it is opened. Burn-after-read controls how many times the page may be served; it does not encrypt anything and it cannot stop a reader screenshotting what they legitimately opened.

Combining it with a password

Two independent gates. The passcode decides who may open it; the burn decides how often anyone may:

publish_html({
  content: "…",
  password: "hunter2",
  burn_after_read: true
})

And with an email gate

With a work-email gate, the recipient requests an open link, confirms the address, and only that confirmed open consumes the single view. Which is what makes the pair usable for a genuine one-shot handover to a named person.

And with expiry

Expiry is the backstop for the link nobody ever opens. Without it, an unopened burn link waits forever:

set_expiry({ site_id: "…", expires_in_hours: 24 })

Preview images and burns

Link unfurling in a chat client fetches a URL before any human clicks it, which is exactly the accident this setting cannot survive. So a one-time page is never photographed at all: the screenshot pass refuses pages that are gated, encrypted or burn-after-read, and the unfurl gets a plain placeholder card instead. The preview lives at its own path regardless, so nothing an unfurling client does reaches the page itself.

Nothing we run can spend it for you

Two implementation details are the whole reason this is trustworthy, and both are worth stating plainly rather than leaving as a promise:

Failure modes worth planning for

Most one-time links that go wrong were spent by something that was never the intended reader:

What happensResultWhat to do about it
A mail gateway follows links to scan themThe open is spent before the person sees itAdd a password or an email gate — a refused request never consumes the open
The recipient forwards the message firstWhoever opens it first takes itOne share token per recipient, each with its own view limit
The link sits unopened for a monthIt stays live indefinitelyPair it with an expiry as a backstop
The reader opens it on the wrong deviceSpent, and they still cannot read it properlySay in the message that it opens once, before they click

Say it opens once, before they click

The single most effective thing around a one-time link is a sentence next to it. A reader who knows the page will not open twice reads it properly the first time, on a device where they can act on it; a reader who does not know treats it like any other link and clicks it on a phone in a lift. The mechanism cannot fix that — the message can.

Watching it happen

The site object carries view_count, unique_viewers and last_viewed_at. For a burn link those tell you the one thing you want: whether the recipient actually got it.

curl https://read.botook.ai/sites/SITE_ID -H "Authorization: Bearer otr_live_YOUR_KEY"

Sending a replacement

A burnt link cannot be revived — that is the property you asked for. Publish again and send the new link; the old one stays 410 forever.

Multiple recipients, one page

Do not use one burn link for three people; the first arrival takes it. Mint a share token per recipient instead, each with its own view limit and its own revocation:

curl -X POST https://read.botook.ai/share-tokens \
  -H "Authorization: Bearer otr_live_YOUR_KEY" \
  -H "content-type: application/json" \
  -d '{"site_id":"SITE_ID","label":"alice","max_views":1}'

Anonymous publishes can carry the same flag. The claim ticket in the receipt lets you attach the page to your account afterwards — worth doing if you want the record of whether it was opened.

Questions

Can I see the content again myself?

Not through the link. Keep your own copy; the point of the setting is that the served copy cannot be read twice.

Does a bot preview burn it?

No — unfurls hit the preview image, not the page.

What if the recipient's mail scanner opens links?

Pair it with a password or an email gate so an automated fetch cannot complete a successful open.

Is the content deleted after the burn?

The page stops being served immediately; the stored object is removed by the same purge that handles expiry.

Keep reading