◈OpenTree DashboardSign in

$ curl -I

What is stored, what is served, and what is refused

A published page is code somebody's agent wrote and nobody read line by line. The viewer treats it that way: strict content policy, no third-party scripts, no referrers, no indexing, and a sensitive-data scan before anything reaches storage.

Headers on every viewer response

content-security-policy: default-src 'self'; script-src 'self'; object-src 'none';
                          base-uri 'none'; frame-ancestors 'none'
x-robots-tag: noai, noimageai, noindex
referrer-policy: no-referrer
x-content-type-options: nosniff
strict-transport-security: max-age=31536000; includeSubDomains

Verify it yourself against any page you publish — it is one curl -I away.

Why the policy is strict by default

Agent-written HTML routinely contains a pasted analytics snippet or a CDN font nobody asked for. A strict policy means that a page which quietly reaches for a third-party script simply does not get to; the content still renders, the beacon does not fire.

A 22-character random token, never listed and never indexed. There is no id to enumerate and no directory to walk — what private means here.

Unguessable is a quantity, not an adjective: the token is drawn from 62 characters at 22 places, so the space is about 1039 wide. Guessing is not a threat model anyone has to plan against; losing control of the link is, which is why the gates above exist and why every page carries no-referrer so the token never leaks in an outbound request.

Gates you can add

GateCheckedReader needs
PasswordBefore any content is servedA passcode you gave them
Email domainBefore any content is servedAn address at one work domain, confirmed once
Burn after readOn each successful openTo be first
ExpiryOn every requestTo arrive before the deadline

Expiry means deletion

A scheduled purge removes the database row and the stored object together. Expired content is not archived, not hidden, not recoverable — the link answers 410 and there is nothing behind it.

The sensitive-data scan

Before a document is stored it is checked for identity numbers, card numbers, phone numbers and dense lists of email addresses. The default mode blocks the publish; warn publishes anyway and tells you; off skips the check. Blocking is the default because the failure it prevents — a page nobody meant to send — is not recoverable once the link is out.

End-to-end encryption

When you need this deployment not to be able to read the content, publish encrypted. The key lives in the URL fragment, and browsers never send a fragment to a server, so only ciphertext is stored. The trade is real: lose the link and the content is unrecoverable, and no server-side feature — preview images, plain-text extraction, search — can work on bytes nobody can read.

Credentials

Sessions in the dashboard

Browser sign-in is GitHub OAuth or a one-time emailed link. Session cookies are HttpOnly, Secure and SameSite, and the browser session is never accepted as API authentication.

Rate limiting

Anonymous publishing is limited per address in a fixed window, which is what keeps an open endpoint from becoming someone else's file host.

The infrastructure

Cloudflare Workers for the runtime, D1 for records, R2 for the stored documents, Queues and scheduled triggers for the purge and the digest. Nothing is on a third-party analytics or logging service — the parts of the system that could see your content are the parts that have to.

Where the content actually sits

The document goes to object storage; the metadata goes to the database. Both are in the Cloudflare account running this deployment. If that account is yours, then so is every byte of this — self-hosting is not a fallback here, it is the normal case.

Source-available, and self-hosted by construction

You can read the code that serves your pages, and you already are — this deployment is running from it. There is no privileged build with different behaviour.

What we cannot do for you

Check it rather than believe it

Every claim on this page is something you can measure from outside in about a minute, and a security page that cannot be checked is marketing. Publish a throwaway document and look at what comes back:

# the headers on a viewer response
curl -sD- -o /dev/null https://read.botook.ai/p/UNLISTED_TOKEN/ \
  | grep -iE 'content-security-policy|x-robots-tag|referrer-policy|strict-transport|x-content-type'

# a gated page must not leak the body with the 401
curl -si https://read.botook.ai/p/GATED_TOKEN/ | head -1

# an expired page
curl -so /dev/null -w '%{http_code}\n' https://read.botook.ai/p/EXPIRED_TOKEN/

What you should see: the strict policy plus the robots and referrer headers on every viewer response; a 401 that carries the gate page and none of the document behind it; and for an expired link a 410, becoming 404 once the scheduled purge has removed the record and the stored object. The two codes are deliberately different — 410 tells a late recipient the link really existed so they can ask for a new one, and a revoked share token answers 404 instead precisely so it cannot be used to prove a page was ever there. If any of that differs from what is written above, it is a bug and worth reporting.

Reporting something

Machine-readable contact at /.well-known/security.txt, or mail hello@botook.ai. Include how to reproduce; that is the part that saves everyone a week.

Privacy of the reader

Aggregate counters only: opens, unique viewers, scroll depth, whether anyone reached the end. No recording, no replay, no cross-site identifier — the full list.

Questions

Can you see my pages?

Whoever runs this deployment can read stored bytes, unless you published with end-to-end encryption. On a self-hosted install that is you.

Is content scanned for anything else?

Only the sensitive-data check described above, and only at publish time.

What happens on account deletion?

Records and objects go together; expiry and deletion use the same purge path.

Keep reading