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 410Gone, 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
- Handing over a credential or a recovery code.
- A one-time report you do not want sitting in a mailbox.
- A preview a client should look at once and then discuss with you.
- Anything where the record of the content mattering more than once is itself the risk.
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:
- The burn is written after the content is read, not before. If fetching the stored document fails, the page has not been served and the single open is still there. A crash cannot silently consume it.
- The screenshot service will not open it. One rule decides both whether a preview may be generated and what the preview endpoint serves, so there is no path where our own machinery is the first visitor.
Failure modes worth planning for
Most one-time links that go wrong were spent by something that was never the intended reader:
| What happens | Result | What to do about it |
|---|---|---|
| A mail gateway follows links to scan them | The open is spent before the person sees it | Add a password or an email gate — a refused request never consumes the open |
| The recipient forwards the message first | Whoever opens it first takes it | One share token per recipient, each with its own view limit |
| The link sits unopened for a month | It stays live indefinitely | Pair it with an expiry as a backstop |
| The reader opens it on the wrong device | Spent, and they still cannot read it properly | Say 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}'Claiming an anonymous burn link
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.