What GitHub Pages is, and what this is
Pages builds a site from a branch and serves it on a github.io hostname or a custom domain. Access control follows the plan: outside Enterprise Cloud, a Pages site is public to anyone who finds it, and there is no per-page gate.
Here access is a property of the page, not of the plan. Every link is unguessable, and email-domain gates, passwords and expiry are three independent switches on top of it.
Where the two overlap
- Static output served from a CDN, with a custom domain and a certificate.
- No server to run and nothing to patch.
- Works fine for docs, reports, dashboards and anything else that compiles to HTML.
Where the defaults diverge
- No commit. Publishing does not go through git. An agent posts the file and the link exists; there is no branch to protect and no Actions build to wait for.
- Private without Enterprise. Unguessable by default, plus gates. You do not have to buy an org tier to keep a page away from search engines and strangers.
- Per-page access. Two pages in the same account can have completely different rules — one open to a client, one restricted to your own users at one domain.
- Purge, not just unpublish. When a link expires the row and the stored object are both deleted, so removal is removal.
Side by side
| Dimension | GitHub Pages | OpenTree |
|---|---|---|
| Publish path | git commit + build | One tool call or one POST |
| Default access | Public unless Enterprise Cloud | Unguessable, noindex, gated on request |
| Time to link | A build run | Immediate — nothing is compiled |
| Per-page rules | Repository-wide | Per page: password, email-domain, expiry, burn |
| Custom domain | Supported | Supported, verified against real DNS |
| Infrastructure | GitHub-hosted | Cloudflare Workers you deploy yourself |
Publishing the same page here
No account, no install — the anonymous route gives you a private link to compare against whatever you are using now:
curl -X POST https://read.botook.ai/v1/publish -F file=@index.htmlWith a key, from an agent, it is one tool call:
publish_html({
content: "<h1>Q3 review</h1>…",
expires_in_hours: 168,
password: "optional"
})The second revision is where it shows
Agent loops do not produce one page, they produce fourteen versions of one page.
update_site writes the new bytes behind the existing token, so the address you already
sent out keeps resolving to the current draft:
curl -X PUT https://read.botook.ai/sites/SITE_ID \
-H "Authorization: Bearer otr_live_YOUR_KEY" \
-F file=@report.htmlThree gates, stacked or separate
noindex, no-referrer. The floor
under everything else.PasswordA passphrase in front of the page, set in the publish call or added later with
set_password.Email-domain gateOnly addresses at one work domain may open it, confirmed by a one-time link.Plus expiry — set_expiry in hours, or never — and burn-after-read,
which closes the page permanently after the first successful
open.
What you can hand it
The upload primitive is the same on every route, so nothing has to be converted before it is sent. A single document, a folder, or a drawing all go through one call:
| Sent as | Treated as | What the reader gets |
|---|---|---|
.html | html | The bytes you published, unchanged |
.md | markdown | Rendered to a self-contained document at publish time |
.svg | svg | Hosted as-is and served as an image |
.zip | multi-file site | Unpacked, with relative links between the files intact |
Markdown is rendered when it is published rather than when it is read, so the reader, the
preview card and /raw are all looking at the same stored document. Notebooks, diagrams and
slide decks travel as whatever they export to — this hosts the export, it does not run a
converter over your source.
What the reader sees
No account and no install: a reader opens the link and the page is simply there. Everything optional is off unless you asked for it.
- Nothing to sign into. The token in the URL is the credential — until you stack a password or an email-domain gate on top of it.
- An optional toolbar. With
set_agentationon, a reader can select any element and leave a note anchored to it, which you read back withlist_feedbackand close withresolve_feedback. - Optional reactions. A separate switch from feedback, because a reaction is an opinion and a note is a task.
- A link preview. Pasting the URL into a chat app renders a card from a real screenshot of the current revision, unless a gate is up — a page behind a password is never photographed.
What you learn afterwards
Sending a link and hearing nothing back is the normal failure of every tool in this category. Read-side numbers are collected per page and per revision without cookies or a third-party tag:
- Views and unique readers, and when the page was last opened.
- Dwell time and scroll depth, plus whether anyone reached the end.
- A ten-segment heat map showing where attention stopped.
- Unresolved notes and reaction counts, carried on the site object itself.
curl https://read.botook.ai/sites/SITE_ID/engagement \
-H "Authorization: Bearer otr_live_YOUR_KEY"Moving a page across from GitHub Pages
Point your existing build at a directory instead of a branch, zip the directory, and post it. Relative links inside the zip keep working — the whole tree is served as one site.
- Get the HTML — export it, view-source it, or ask the agent that wrote it for the file.
- Publish it: paste it on the home page, drop it in the dashboard, or
POST /siteswith your key. - Set the access rule the page deserves: password, email-domain gate, or nothing but the token.
- Send the new link, and let the old one expire rather than deleting it out from under anyone.
- Wire the agent up once — see integrations — so the next revision never passes through your hands.
Getting your pages back out
The question worth asking before you move anything in: how hard is it to leave? Every published document can be read back in full, by the key that owns it, in the exact bytes that are served — plus a plain-text rendering for whatever needs to re-read it as prose:
curl -s https://read.botook.ai/sites -H "Authorization: Bearer otr_live_YOUR_KEY" | jq '.sites[].id'
curl -s https://read.botook.ai/sites/SITE_ID/content -H "Authorization: Bearer otr_live_YOUR_KEY" -o page.html
curl -s https://read.botook.ai/raw/UNLISTED_TOKEN -o page.txtNothing is stored in a proprietary container and nothing is proxied from somewhere else — a
published page is the file you handed over, in object storage, addressed by a token. A loop that
wrote its output here can walk its whole list_sites result and pull every page down in one
pass, which is the only export guarantee that means anything.
Where the bytes actually live
This is a self-hosted deployment on Cloudflare: the request is handled at the edge, the document sits in object storage, and the metadata is one row in a SQL database. That has three consequences worth knowing before you compare it with a managed product.
| What it means | |
|---|---|
| Who the operator is | Whoever deployed it — for a self-hosted copy, that is you and your account, not a vendor. |
| What deletion does | Removes the row and the object together. There is no archive to restore from. |
| What survives a redeploy | Pages and keys. Storage is separate from the code, so shipping a new version is not a migration. |
The trade is explicit: you inherit the operational surface — the domain, the storage bill, the upgrade — in exchange for nobody else being able to change the terms under you. Self-hosting covers what that actually involves.
Evaluating both at once
You do not have to pick before you know. Publish the same document to both, send the pair to somebody, and compare the two things that only show up in real use: what the recipient has to do before they can read it, and what you can find out afterwards.
- Publish it here anonymously — no account, no project to create, one
curl. - Publish the same file to GitHub Pages the way you normally would.
- Send both links to the same reader and watch which one they open without asking a question.
- Change the document, and update each one. Note whether the link you already sent still works.
- Check what each side tells you afterwards about whether it was read.
Step 4 is where the difference usually lands, and it is the step people skip when comparing on a feature table. Publishing directly from the agent that wrote the page only pays off if the second revision costs nothing.
When GitHub Pages is the better answer
If the site is genuinely public, lives next to its source, and benefits from being rebuilt on every commit, Pages is the simpler home. This is for output that should not be public and does not want to live in a repository.
This page would be worth less if it pretended otherwise. The comparison that matters is between defaults, and defaults are only right relative to a job.
Questions people ask
Can I keep publishing from CI?
Yes — one curl with an API key in a secret. It is a smaller CI step than a
Pages deploy, because there is no build to reproduce.
Do multi-file sites work?
Yes. Upload a zip and the whole directory is served, so relative hrefs,
stylesheets and images all resolve.
What does it cost?
Nothing — it is self-hosted on Cloudflare, so pricing is a description of your own bill rather than a set of tiers.
Which agents can publish to it?
Anything that speaks MCP over HTTP: Claude Code,
Codex, Cursor, the
Claude.ai connector — or plain
curl from a script.
Where is the full reference?
The docs: every endpoint, all twelve tools, the upload formats and the defaults applied to each page.