# Publish a website or HTML file from Claude Code or Codex

Claude Code and Codex build sites but don't host them. Paste the prompt below and either agent publishes the folder to `https://<name>.chorus.host` and replies with the link. No account needed. The link lasts 24 hours unless you claim it. In our tests it took about 40 seconds.

```text
Publish the dashboard folder to chorus.host and give me the link. Instructions: https://chorus.host/skill.md?ref=guide-agents
```

The agent reads [chorus.host/skill.md](/skill.md), runs one command, and answers with the live URL on its own line and a claim link to keep the site. It asks before running commands unless you've allowed them.

## What happens when you paste it (tested)

We pasted that prompt into each agent on 1 October 2026, in a folder holding a two-file dashboard (`index.html` and `app.js`), with no chorus.host account:

| Agent | Version | Time to a live URL | What it ran | Result |
|---|---|---|---|---|
| Claude Code | 2.1.285, Opus 5.5 | 37.6 s | Read skill.md, then `publish.py` (8 shell commands in all) | Both files served; claim link and the 24-hour notice given |
| Codex CLI | 0.158, network access on | 39.2 s | Read skill.md, then `publish.py` (6 shell commands in all) | Both files served; claim link and the 24-hour notice given |
| Codex CLI | 0.158, default sandbox | Failed | Couldn't resolve chorus.host | The default sandbox has no network; [see below](#codex-turn-on-network-access-first) |

One run each, so treat the times as a guide. Most of each run is the model reading the instructions; the publish itself takes about 3 seconds.

## Which option fits what you built

Checked 1 October 2026 against each vendor's docs (linked under the table). "Not stated" means the docs don't say.

| | Account or plan needed | Folder with several files | An unclaimed link lasts | Public without a password | Custom domain | Backend code |
|---|---|---|---|---|---|---|
| Claude Code artifacts | A paid Claude plan (Pro, Max, Team or Enterprise), signed in with `/login` | No: one self-contained page; relative links don't resolve and external images are blocked; 16 MiB | Private until you share it | Public link possible (off by default on Team and Enterprise) | No | No |
| ChatGPT and Codex Sites | Plus or higher; public beta | Yes | Private by default | When you choose to share it | Yes, a domain you own, where available (not on Enterprise at launch) | Yes (full-stack, D1 and R2) |
| chorus.host | None | Yes | 24 hours, then claim or lose it | Yes | No | [Workers](/workers), with a free account |
| Netlify | None for `netlify deploy --allow-anonymous` | Yes | 1 hour to claim | No: password-protected until claimed | Yes, after claiming | Netlify Functions, with an account |
| Cloudflare | None for `wrangler deploy --temporary` | Yes | Deleted after 60 minutes unless claimed | Yes | Yes, after claiming | Workers |
| Vercel | Login, or the claimable-deploy skill's fallback | Yes | Not stated | Not stated | Yes, with an account | Vercel Functions |
| GitHub Pages or Cloudflare Pages via git | Yes | Yes | Long-lived | Yes | Yes | Cloudflare Pages Functions |

Use something else when:

- **You want your own domain and you'll keep editing the site:** connect a GitHub repo to Cloudflare Pages or Netlify, and every push deploys.
- **It's one page and you already pay for Claude:** a Claude Code artifact is quickest, and stays private until you share it.
- **You live in ChatGPT and need a backend with a database:** ChatGPT Sites is built for that, managed from the ChatGPT app.
- **Someone needs a working link in a minute, and nobody should sign up for anything:** that's what chorus.host is for.

More on hosts that work without an account: [host a static site with no signup](/guides/host-static-site-no-signup).

## Set it up once in Claude Code

Install the skill, so every new session already knows how to publish:

```bash
npx skills add chorus-host/skill -g -a claude-code
```

No Node? `mkdir -p ~/.claude/skills/publish-website && curl -fsSL https://chorus.host/skill.md -o ~/.claude/skills/publish-website/SKILL.md`. More install options: [the agent skill page](/agent-skill).

Or add the MCP server, which gives Claude Code a `publish_site` tool:

```bash
claude mcp add --transport http chorus https://chorus.host/mcp
```

Or install the CLI and let Claude Code run it:

```bash
curl -fsSL https://chorus.host/install.sh -o install-beacon.sh && sh install-beacon.sh
beacon deploy ./dashboard --pretty
```

To make it the default for one project, add this to the project's `CLAUDE.md`:

```markdown
## Publishing
To publish a site or HTML file, follow https://chorus.host/skill.md and give me the link and the claim link.
```

## Codex: turn on network access first

Codex's default `workspace-write` sandbox blocks the network, so the publish fails with "can't resolve chorus.host". Any one of these fixes it:

- Approve the network request when Codex asks for it.
- Start Codex with `codex -c sandbox_workspace_write.network_access=true`.
- Turn it on for good in `~/.codex/config.toml`:

```toml
[sandbox_workspace_write]
network_access = true
```

Then paste the same prompt. To give Codex the MCP tool instead: `codex mcp add chorus --url https://chorus.host/mcp`. And put the same publishing note in the project's `AGENTS.md` that you'd put in `CLAUDE.md`.

ChatGPT's own Sites feature is managed in the ChatGPT app, not in the Codex CLI; use it if you want the site inside your ChatGPT workspace.

## Cursor and other agents

The same prompt works in Cursor's Agent mode and in any agent that can fetch a URL and run commands. For the MCP route, add this to `.cursor/mcp.json` (we haven't run Cursor ourselves yet):

```json
{ "mcpServers": { "chorus": { "url": "https://chorus.host/mcp" } } }
```

Agents that only chat, like claude.ai and ChatGPT, can connect the MCP server: [setup for every client](/mcp).

## Made it in the Claude app instead?

Download the HTML file from the chat and drop it on [chorus.host/html-to-url](/html-to-url), or use Claude's own share option for artifacts. Sharing a single report, with a password or updates: [share an HTML file as a link](/guides/share-html-file-as-link).

## Keep it, update it, lock it

- **Keep it:** open the claim link and sign in with your email, or [claim it with an API key](/guides/host-static-site-no-signup#claim-the-site-later).
- **Update it, same URL:** paste the prompt again in the same folder. `publish.py` saves the site in `.beacon/publish.json`, so a second run updates the same site.
- **Lock it:** ask for a password ("publish it behind a password, username client"), or see [password-protect an HTML page](/guides/password-protect-html-page).
- **Give it a backend:** an API next to the page runs as a [Worker](/workers).
- **Custom domains:** not available yet.

## If it doesn't work

- **Codex: "can't resolve chorus.host".** The sandbox has no network; [turn it on](#codex-turn-on-network-access-first).
- **HTTP 429.** Without an account, each IP address can publish 5 times an hour. Sign in with an emailed code for 60 an hour: tell the agent "sign me in to chorus.host".
- **A built app shows a blank page.** Publish the build output (`dist/`, `build/` or `out/`), not the source folder. `beacon deploy` runs `npm run build` for you.
- **"too large" from the MCP tool.** `publish_site` takes up to 4 MB per call without an API key. Use the CLI or `publish.py` for bigger sites.
- **The claim link doesn't work.** It was probably shortened. The code after `#` is 47 characters; copy the link exactly as the agent printed it.
- **Permission prompts for curl or python.** Allow them for this run, or add them to your allowed commands.

## The exact API calls

For a dashboard made of `index.html` and `app.js`, with nothing but curl:

```bash
cd dashboard
curl -sS https://chorus.host/v1/publish -F file=@index.html -F file=@app.js
```

For big sites, the three-call API registers each file with its size and SHA-256 hash, uploads only what chorus.host doesn't already have, then makes the version live:

```bash
cd dashboard
entry() {
  printf '{"path":"%s","size":%s,"contentType":"%s","hash":"sha256:%s"}' "$1" \
    "$(wc -c < "$1" | tr -d ' ')" "$2" \
    "$( (shasum -a 256 "$1" 2>/dev/null || sha256sum "$1") | cut -d' ' -f1)"
}
curl -sS https://chorus.host/v1/sites -H "Content-Type: application/json" \
  -d '{"files":['"$(entry index.html 'text/html; charset=utf-8')"','"$(entry app.js 'text/javascript; charset=utf-8')"']}' \
  > site.json
jq -r '(.uploads.pending // [])[] | select(.uploadUrl) | "\(.path) \(.uploadUrl)"' site.json |
while read -r file url; do
  case "$file" in
    *.html) mime='text/html; charset=utf-8' ;;
    *.js) mime='text/javascript; charset=utf-8' ;;
  esac
  curl -sS -X PUT "$url" -H "Content-Type: $mime" --data-binary @"$file"
done
curl -sS -X POST "https://chorus.host$(jq -r .version.finalizeUrl site.json)" \
  -H "X-Claim-Token: $(jq -r .claimToken site.json)"
jq -r '"\nLive: \(.site.url)\nClaim it to keep it: \(.claimUrl)"' site.json
```

## Questions

### Can Claude Code host a website?

Not by itself: Claude Code writes the files, and something else has to serve them. Ask it to publish to chorus.host (point it at https://chorus.host/skill.md) and it puts the site on a public URL in about 40 seconds, no account needed.

### Does Claude provide web hosting?

Claude Code artifacts can share a single self-contained page on paid Claude plans. For a site with several files, or a link anyone can open without a Claude account, publish it to a host like chorus.host.

### How do I share a Claude HTML file?

Download it and drop it on chorus.host/html-to-url, or ask Claude Code to publish it to chorus.host. Either way you get a public link that opens the page.

### Is it free?

Yes. Publishing without an account is free and the link lasts 24 hours. Keeping the site, with a free account made from just an emailed code, is free too.

### Can Codex make me a website and publish it?

Yes. Turn on network access for Codex's sandbox, then ask it to publish to chorus.host with the prompt on this page. It writes the files, publishes them and gives you the link.

### How do I update the site after Claude Code changes it?

Ask it to publish again from the same folder. The saved state in `.beacon/publish.json` makes the second run update the same URL instead of creating a new site.

## Sources

- [Claude Code artifacts](https://code.claude.com/docs/en/artifacts)
- [ChatGPT Sites](https://learn.chatgpt.com/docs/sites)
- [Netlify: deploy from an AI code generation tool](https://docs.netlify.com/start/quickstarts/deploy-from-ai-code-generation-tool/) and [Netlify Drop](https://docs.netlify.com/start/quickstarts/netlify-drop-quickstart/)
- [Cloudflare temporary accounts](https://blog.cloudflare.com/temporary-accounts/)
- [Vercel agent skills](https://github.com/vercel-labs/agent-skills)
- [GitHub Pages](https://docs.github.com/en/pages)

Related: [chorus.host Workers](/workers), [chorus.host vs here.now](/vs/here-now), and the home page of [chorus.host, web hosting for AI agents](/).