◈OpenTree DashboardSign in

alternative

A Tiiny Host alternative for HTML an agent wrote

Tiiny Host is a drag-and-drop static host built for a person with a file. This is the same private link with the drag-and-drop step deleted — the agent that produced the HTML publishes it itself, over a tool call, and keeps the URL when it revises.

What Tiiny Host is, and what this is

Tiiny Host takes a file or a folder you drop into a browser and puts it on a hosted subdomain in a few seconds. It is a good tool and the interaction is exactly right — for a human who already has the file on their desktop.

Here the publishing party is usually not a human. A coding agent finishes a build, calls publish_html, and the link exists before anyone has looked at a file manager. The unguessable URL is the default, not a paid add-on.

Short answer: pick this one when the publisher is an agent and the output should be private from the first byte. Pick Tiiny Host when its own strength — described honestly further down — is what the job actually needs.

Where the two overlap

Where the defaults diverge

Side by side

DimensionTiiny HostOpenTree
Primary publisherA person, in a browserAn agent, over MCP or HTTP
Default visibilityA public hosted subdomainUnguessable token, never indexed
Second revisionUpload the file againupdate_site, replace-in-place
PasswordSupportedSupported, and settable in the same publish call
Custom domainsSupportedSupported, CNAME + TXT, certificate issued on verify
Reader accountsNone neededNone needed
PricingTieredNone — this deployment is yours

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.html

With 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.html

Three gates, stacked or separate

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 asTreated asWhat the reader gets
.htmlhtmlThe bytes you published, unchanged
.mdmarkdownRendered to a self-contained document at publish time
.svgsvgHosted as-is and served as an image
.zipmulti-file siteUnpacked, 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.

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:

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

Moving a page across from Tiiny Host

Tiiny Host sites are ordinary static files, so there is nothing to convert: download what you have and publish the same bytes.

  1. Get the HTML — export it, view-source it, or ask the agent that wrote it for the file.
  2. Publish it: paste it on the home page, drop it in the dashboard, or POST /sites with your key.
  3. Set the access rule the page deserves: password, email-domain gate, or nothing but the token.
  4. Send the new link, and let the old one expire rather than deleting it out from under anyone.
  5. 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.txt

Nothing 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 isWhoever deployed it — for a self-hosted copy, that is you and your account, not a vendor.
What deletion doesRemoves the row and the object together. There is no archive to restore from.
What survives a redeployPages 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.

  1. Publish it here anonymously — no account, no project to create, one curl.
  2. Publish the same file to Tiiny Host the way you normally would.
  3. Send both links to the same reader and watch which one they open without asking a question.
  4. Change the document, and update each one. Note whether the link you already sent still works.
  5. 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 Tiiny Host is the better answer

If the person publishing is a person, every time, and nothing in the loop is automated, drag-and-drop is fewer moving parts than an API key. Nothing here beats dragging a file onto a page when that is genuinely the whole job.

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 still publish by hand?

Yes. The dashboard takes a pasted document or a zip, and the home page will publish an anonymous link with no account at all.

Does the link change when the content changes?

No. That is the point of replace-in-place. The client you sent it to on Monday sees Friday's version at the same address.

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.