Pagebox / machine publishing

Let the agent ship the page.

An agent can build a finished static page and publish it here in one step — no account, no dashboard, no waiting on the person who asked for it. It gets back a public URL to share and a private claim URL that turns the page into a permanent, owned one.

The whole protocol

Build the site as HTML, CSS, JS and assets. Zip it with index.html at the top level. POST the raw zip as application/zip to the endpoint advertised in the discovery document. Return both URLs to the person, clearly labelled — and never put the claim URL anywhere public.

01

The job, in plain language

  1. 01

    Read the contract first

    https://pagebox.page/.well-known/pagebox-publish.json is machine-readable and authoritative: endpoint, body, caps, error codes. It is the one thing to fetch before writing publish code.

  2. 02

    Build a finished static site

    HTML, CSS, JavaScript and assets that open from a plain file server. Relative paths, no build step, no server code. A deck, a tool, a report — whatever was asked for, complete.

  3. 03

    Zip it, index.html at the root

    One archive. The entry page must be index.html; everything it references travels with it.

  4. 04

    POST the raw zip

    The archive is the request body — not multipart, not base64. Set content-type: application/zip.

  5. 05

    Hand back both URLs, labelled

    pageUrl is public: share it. claimUrl is private: it goes to the one person who asked for the page, and nowhere else. Say plainly that an unclaimed page stops working in 24 hours.

02

The call, and its limits

POST https://pagebox.page/api/pagebox/temporary-sites
content-type: application/zip
x-pagebox-title: Series A deck        # optional

<the raw bytes of site.zip>

201 Created
{
  "pageUrl":   "https://…/s/<token>",           # public — share this
  "claimUrl":  "https://pagebox.page/claim/{claimId}#{secret}",  # private — hand to one person
  "expiresAt": "2026-08-26T12:00:00.000Z"
}

Page title, trimmed to 120 characters. Defaults to "Untitled site".

Request body
4.0 MB zip, sent raw
Files per page
100
Per file
10 MB
Unzipped total
20 MB
Publishes per hour
5 per client
Unclaimed lifetime
24 hours

These are the live values from the contract. Read them there at runtime rather than pinning them in code — 13 error codes are documented alongside them, each with a stable meaning.

Open the machine contract ↗
03

Prompts that do the whole job

Paste one of these, add what you want built, and the agent handles hosting too. Each prompt makes the agent read the contract, publish through it, label both links, and keep the claim link out of anything public.

app

Relay product demo

The audience should click through a product concept, workflow, or dashboard.

PreviewSource ZIP
deck

Northstar decision deck

A presenter needs to move an audience through evidence toward one decision.

PreviewSource ZIP
report

Atlas analysis report

A reader needs findings, evidence, recommendations, and methodology in one document.

PreviewSource ZIP
one-pager

Keystone decision brief

A busy stakeholder needs the decision, rationale, owner, and next step at a glance.

PreviewSource ZIP
report

Beacon project status

A cross-functional team needs progress, milestones, risks, decisions, and next steps in one update.

PreviewSource ZIP
one-pager

Summit business proposal

A buyer or executive sponsor needs the problem, approach, scope, investment, and next step in one place.

PreviewSource ZIP
Browse the template gallery →

Ready-to-use prompt

Claude

Give Claude a page to build and publish in one turn. Claude Code and browser-capable integrations publish directly; read-only chat tools use the fallback.

Build the page described at the end of this message and publish it to Pagebox.

PUBLISH PROCEDURE
1. Fetch https://pagebox.page/.well-known/pagebox-publish.json first. That document is the contract: the
   publish endpoint, the request shape, the size limits, and every error code. Follow it
   over anything you remember about Pagebox.
2. Review the optional templates in the contract. Use and adapt one only when its structure
   fits the requested page; otherwise build from scratch.
3. Build the page as static files: index.html plus the CSS, JS, images, and fonts it needs.
   Relative paths only. No build step, no server code, no runtime API calls.
4. Zip those files with index.html at the top level of the archive.
5. POST the raw zip bytes to the publish URL from the contract with content-type:
   application/zip. Raw body — not multipart, not base64, not JSON.
   Optionally set x-pagebox-title to the page title.
6. Read pageUrl and claimUrl from the 201 response.

THEN REPLY WITH EXACTLY THESE THREE LINES
   Public link (share this): <pageUrl>
   Private claim link (do not share): <claimUrl>
   Unclaimed, this page stops working in 24 hours. Open the claim link and sign in to keep it and its URL.

CLAIM SECRECY
Treat claimUrl as a password. Never paste it into the page you built, a summary, a commit
message, a log line, a ticket, a shared channel, or any file you write. Anyone who opens it
can take ownership of the page. It goes in your reply to me and nowhere else.

IF PUBLISHING FAILS
Report the HTTP status and the error code from the contract's error table, say what you
would change, and stop. Do not retry a size or rate-limit failure unchanged.
If your tools cannot make an outbound binary POST, say so plainly, give me the zip, and
print the exact curl command from the contract instead. Do not pretend it was published.

BUILD THIS
[describe the page: what it is, who reads it, what must be on it]

Ready-to-use prompt

ChatGPT

The same job for ChatGPT, with an explicit fallback for turns where it cannot make the network call itself.

I want a finished web page, published and live. Do the whole job, including hosting.

STEP 1 — READ THE CONTRACT
Open https://pagebox.page/.well-known/pagebox-publish.json and follow it. It states the publish
endpoint, the accepted body, the caps, and the error codes.

STEP 2 — CHECK THE OPTIONAL TEMPLATES
The contract lists source packs for common page formats. Use and adapt one when its
structure fits the request; otherwise build from scratch.

STEP 3 — BUILD IT
Static files only: index.html plus any CSS, JS, images, and fonts, all referenced with
relative paths. It must open correctly from a plain file server with no build step.

STEP 4 — PUBLISH IT
Zip the files with index.html at the top level and POST the raw archive to the contract's
publish URL with content-type: application/zip. The zip is the request body.
If you cannot make outbound requests in this turn, say so plainly, give me the zip, and
print the exact curl command to run instead. Do not pretend the page was published.

STEP 5 — HAND IT BACK
From the 201 response, report exactly:
   Public link (share this): <pageUrl>
   Private claim link (do not share): <claimUrl>
   Unclaimed, this page stops working in 24 hours. Open the claim link and sign in to keep it and its URL.

STEP 6 — KEEP THE CLAIM LINK PRIVATE
Treat claimUrl as a password. Never paste it into the page you built, a summary, a commit
message, a log line, a ticket, a shared channel, or any file you write. Anyone who opens it
can take ownership of the page. It goes in your reply to me and nowhere else.

Ready-to-use prompt

Any coding agent (Cursor, Codex, Copilot, CLI)

Shell-shaped instructions for an agent working in a repo or terminal, including the exact curl call.

Publish the static site in this working directory to Pagebox and give me the links.

1. READ THE CONTRACT
   curl -s https://pagebox.page/.well-known/pagebox-publish.json
   It is authoritative for the endpoint, the caps, and the error codes. Read it before
   writing any publish code.

2. CHECK THE OPTIONAL TEMPLATES
   Inspect templates in the contract. If one fits, download and adapt its source pack;
   otherwise keep the existing implementation.

3. CHECK THE BUNDLE
   index.html must sit at the root of what you zip, every asset path must be relative,
   and the archive must stay under the request cap in the contract
   (currently 4.0 MB, 100 files).
   Exclude .git, node_modules, and source maps.

4. ZIP AND POST
   cd dist && zip -qr ../site.zip . -x '*.DS_Store' && cd ..
   curl -sS -X POST 'https://pagebox.page/api/pagebox/temporary-sites' \
     -H 'content-type: application/zip' \
     -H 'x-pagebox-title: <page title>' \
     --data-binary @site.zip

5. REPORT BACK
   Parse pageUrl and claimUrl from the 201 JSON and print exactly:
   Public link (share this): <pageUrl>
   Private claim link (do not share): <claimUrl>
   Unclaimed, this page stops working in 24 hours. Open the claim link and sign in to keep it and its URL.

6. HANDLE THE CLAIM URL AS A SECRET
Treat claimUrl as a password. Never paste it into the page you built, a summary, a commit
message, a log line, a ticket, a shared channel, or any file you write. Anyone who opens it
can take ownership of the page. It goes in your reply to me and nowhere else.
   Do not echo it into build output, do not write it to a file in the repo, and delete
   site.zip and any response body you saved when you are done.

7. ON FAILURE
   Print the status code and the contract's error code, then stop. Do not loop.
04

Worth building this way

  • 01Slide deckKeyboard-navigable HTML slides from a brief, ready to present.
  • 02Product demoA clickable prototype of the feature you just specced.
  • 03CalculatorPricing, ROI, or dosage math with the inputs exposed.
  • 04ReportAnalysis with charts drawn from the numbers in the thread.
  • 05InviteA dated, mapped, RSVP-linked page for one event.
  • 06PortfolioWork samples laid out properly instead of zipped up.
  • 07One-page siteA launch, a policy, a changelog — one URL, no hosting account.
05

Rules of the handoff

  • The public page is live immediately and open to anyone with the link. It is served sandboxed and kept out of search engines.
  • Unclaimed, it stops serving after 24 hours; cleanup removes its files afterward. Claiming it keeps the exact same URL, moves it into that account, and removes the expiry.
  • The claim URL carries its secret in the fragment, so the secret never reaches a server until the person claims the page. Anyone who reads that URL can take the page: it belongs in a direct reply, never in the page, a log, or a channel.
  • Received something abusive? Every temporary page carries a report control, and https://pagebox.page/api/pagebox/abuse-reports takes reports without an account.

No agent involved?

Drop the files yourself instead.

Publish with Pagebox →