# Emits · Publish HTML to a live URL, no repo or build step
> Emits is agent-native HTML hosting. Drop a page or a folder of pages, run one command, call the API, or hand your agent the MCP tools, and get a live URL back. Old links keep opening, views never billed, free to publish.
The same page, as HTML: https://emits.app/
## 01 · Share your HTML
**Send HTML, get a link.** Drag it in, run one command, or call the API.
One command:
```
emit publish ./site/index.html --bundle --domain handbook
published https://handbook.emits.page v1
```
Or over HTTP:
```
curl -X POST api.emits.app/v1/pages \
-H "Authorization: Bearer $KEY" \
-d '{ "html": "…", "slug": "handbook" }'
{ "id": "pg_…", "url": "https://handbook.emits.page", "version": 1 }
```
- **Setup: None** — No repo, no build, no config file
- **Input: Any HTML** — Written by you, or by an agent at 3am
- **Traffic: Unlimited** — Page views are never billed, however popular it gets
- **Price: $0** — Free to publish and to serve, forever
**What people publish with it when there is no repo in sight.** Anything that is finished as HTML and needs to exist at an address. Static HTML hosting, without a project, a pipeline, or a deploy.
- **Pages an agent just wrote** — A coding agent finishes a report, a summary or a dashboard and needs to hand back a URL, not a file path.
- **Client previews** — Send a draft to a client without touching your real site. Keep it unlisted while the work is in progress.
- **One-page docs and handbooks** — A folder of linked pages goes up together, and every link between them keeps working.
- **Changelogs and status pages** — Update the same link as often as you like. Earlier versions are kept, never overwritten.
- **Invoices, quotes and receipts** — Generate the HTML, publish it unlisted, send the link. No file storage to set up, no links that expire.
- **Prototypes and mockups** — Show the thing on a real URL, on a phone, in a meeting, without a build step between you and the demo.
## 02 · Stay in control
**It is your page after it is live.** Change it, hide it, find it, name it.
### Versions
**Send a new version to the same link.** Nothing you published is ever overwritten.
- The link you gave out never changes
- Every earlier version is kept, never overwritten
- A retry never creates a duplicate
`emit update pg_abc123 ./index.html`
### Visibility
**You decide who gets in.** Change your mind without republishing.
- **Public** — Anyone can open it, and it can be found.
- **Unlisted** — Only people you send the link to.
- **Private** — Nobody but you, while a draft is still moving.
`emit visibility pg_abc123 unlisted`
### Tags and search
**Tag them now,** find them in a second.
`emit find --tag launch --q handbook`
### Custom domains
**Add your domain once.** Everything you host answers there.
- One domain for the whole account, not one per page
- Every page also serves at your-domain/name
- HTTPS is set up for you
`emit bind-domain pages.mzed.studio`
## 03 · Hand it to your agent
**Your agent learns it in one command.** Then it ships pages on its own.
### MCP
**Publish straight from the model.** No file, no shell, no setup.
An MCP agent gets four tools: publish, update, list and unpublish. Publish takes the HTML itself, so a page the model just wrote goes live without touching a disk.
```
https://api.emits.app/mcp
# nothing to install: paste it into any MCP client, approve once in the browser
# local: emit mcp
# Claude Code: claude plugin install emits@mzed
```
### CLI
**Got a shell? Use the CLI.** Point it at a file and go.
No HTML to paste anywhere: the login already lives on the machine, and a whole folder publishes with one flag.
```
emit publish ./index.html --tag draft --visibility unlisted
published https://launch-notes.emits.page v1
```
or teach it: `emit skill --out SKILL.md`
### HTTP
**No shell? Five verbs.** That is the whole API.
Anything that can make a web request can publish. Hosted agents, tool calls and browser agents all use the same five.
- `POST /v1/pages` — publish: Send HTML, get the link back
- `PATCH /v1/pages/{id}` — update: New version, same link
- `GET /v1/pages` — find: Search and filter by tag
- `PATCH /v1/pages/{id}/visibility` — visibility: Public, unlisted or private
- `DELETE /v1/pages/{id}` — delete: The link goes dark, nothing erased
A failed call is safe to send again. A retry never publishes twice.
You stay in control:
- Reading pages and writing them are separate permissions
- Pointing a domain at pages always asks a human first
- Any connected agent can be revoked in one click
- The activity feed records what changed, and who changed it
## Pricing
**Free to use.** $2.50 for your own domain.
Page views are never billed. A page can go around the world and cost you nothing.
### Free · $0
Enough for most of what you will do.
- As many pages as you like
- Custom slug on every page
- The last 5 versions, ready to restore
- Public, unlisted or private
- Views never billed
- A small “Published with Emits” badge
### Pro · $2.50 / month
When the link should carry your name.
- Everything in Free
- Your own domain, account-wide, HTTPS handled
- Page views and referrers
- Password-protected pages
- Every version, forever
- No Emits badge
## Common questions
### Do I need a repository or a build step?
No. Emits takes the HTML you already have and puts it at a URL. There is no project to create, nothing to build, and nothing to configure.
### Can I publish a multi-page site, not just one file?
Yes. Publish the folder and it goes up as one unit. Every page keeps the path you gave it, links between pages work as written, and the whole site shares one link, one version and one visibility setting.
### Will my HTML be modified?
No. A full document is served exactly as you wrote it: scripts, styles and third-party tags all keep working, with nothing stripped out and nothing blocking them. Paste a snippet instead of a full page and it is wrapped just enough to render on its own.
### What happens when I change a page?
Publishing again creates a new version at the same link. Nothing is overwritten: earlier versions are kept, and a restore puts one back at the link without creating a new page.
### Can I keep a page private?
Every page is public, unlisted or private, and you can change that at any time without republishing. Unlisted pages open for anyone with the link, but nobody can find them without it.
### Can an AI agent publish on its own?
That is what it was built for. Point any MCP client at api.emits.app/mcp and it gets four tools, nothing installed. An agent with a shell can run `emit skill` once to learn the whole surface, and everything also works over plain HTTP.
### What can an agent actually do to my account?
Only what you approved. Reading pages and writing them are separate permissions, pointing a domain always asks you first, and the consent screen says in plain language what is being asked. Any connected agent can be disconnected in one click, and the activity feed shows what changed and who changed it.
### Can I use my own domain?
Yes, on the Pro plan: $2.50 a month, or $15 a year. Your domain covers the whole account rather than a single page, so once it is active every page you host also answers at your-domain/name, with HTTPS set up for you.
### What does it cost if a page goes viral?
Nothing. Page views are never billed. Publishing and serving are free at any level of traffic, and the Pro plan exists for custom domains, page analytics, page passwords and taking the Emits badge off your pages.
### Do I have to use Shortwind to publish here?
No. Plain HTML is served exactly as written. If a page does use `@recipe` shorthand, it is expanded to Tailwind when you publish, so there is still nothing to build first.
## Links
- [Home](https://emits.app/)
- [Pricing](https://emits.app/pricing)
- [Terms](https://emits.app/legal/terms)
- [Privacy](https://emits.app/legal/privacy)
- [Acceptable use](https://emits.app/legal/acceptable-use)
- [Copyright and DMCA](https://emits.app/legal/copyright)
- [Docs](https://emits.app/docs)
- [The landing page as markdown](https://emits.app/index.md)