Host Cursor's HTML output — and let Cursor publish it for you
Cursor is an AI code editor whose agent can write a full, self-contained HTML page — a dashboard, a report, a quick prototype — and, unlike a chat assistant, it runs inside your project with real tools at its disposal. That second part is the interesting bit here: Cursor does not just hand you HTML, it can publish the HTML itself. Point its agent at the host-html publish API or the publish skill and it will ship the page and return a live host-html.com/p/ link, with no manual deploy on your end. Prefer to stay in control? Copy the HTML Cursor generated and paste or drop it on host-html yourself. This page walks both paths — the one-step programmatic publish, and the copy-and-drop manual route.
Two ways to get Cursor's HTML online
The manual path is the one you already know. Cursor writes a page, you copy the HTML out of the editor or save it as a .html file, and you bring it to host-html. Paste the code into the editor or drag the file onto the drop zone, watch the live preview render exactly what will ship, sign in to your free account, and click publish. You get a clean host-html.com/p/ link you can send anywhere. No git, no build step, no config.
The programmatic path is what makes Cursor different from a chat window. Because Cursor's agent can run commands and call HTTP endpoints, it can publish the page for you. Give it your personal host-html publish key (every account gets one) or install the publish skill, ask it to publish the file, and the agent POSTs the HTML and reports back the URL. Generation and distribution collapse into a single step you never leave the editor for.
Which one you reach for depends on how much you want to touch. For a one-off you are eyeballing anyway, copy-and-drop is honest and fast. For an agent loop where Cursor is iterating on a page and you want each version live without babysitting a deploy, let it publish itself and read the link back to you.
Letting Cursor publish through the API or skill
The host-html publish API is a plain REST endpoint. You authenticate with a personal key that starts with hh_, send the HTML in the request body, and get back JSON containing the live URL. There is nothing Cursor-specific about it, which is exactly the point: any agent that can make an authenticated HTTP request can use it, and Cursor can. The publish skill wraps that same endpoint in an instruction file so the agent knows the shape of the call without you spelling it out each time.
A couple of honest limits are worth knowing up front. Publishing requires a free account, so the agent needs your key — treat it like any credential and keep it out of shared logs. Free pages live for 10 days and cap at 1MB, which is plenty for a self-contained page but not a media-heavy site. And custom slugs are honored only on a paid plan; on the free tier you get a random slug. None of that blocks the agent loop — it just sets expectations for what the returned link looks like.
Re-publishing is something the agent handles well too. Ask Cursor to regenerate and publish again and you get a fresh link each time. On Pro you can instead edit a page in place so the URL you already shared keeps pointing at the newest version — handy when the agent is refining a page you have already sent to someone.
Free to start, paid when the page earns its keep
A free account takes about five seconds and needs no card. It is the right choice for a throwaway Cursor prototype: publish it, share it, and let it expire in 10 days if it was only ever a draft. Basic page-view analytics come with it, along with a small "Made with host-html" badge and a random slug.
When a page turns out to matter, Pro (from $5/mo) keeps it alive forever and adds the things you notice you want the second time around: password protection, badge removal, custom slugs, in-place editing on the same URL, version history, detailed analytics with referrers and countries, tags, QR codes, form and response collection, collections that gather many pages behind one link, and a 10MB file cap. Team adds custom domains, 50MB files, and shared seats.
host-html is model-neutral, so nothing here is Cursor-only. The same publish API and drop zone take HTML from Claude, ChatGPT, Gemini, DeepSeek, v0, Bolt, or Lovable. Cursor just happens to be able to drive the API itself, which is why setting up the one-step publish is worth the few minutes it takes.
Frequently asked questions
Can Cursor publish the HTML it generates on its own?
Yes. Because Cursor's agent can run commands and make HTTP requests, it can call the host-html publish API or use the publish skill to ship the page and return a live host-html.com link, with no manual deploy step from you.
Do I still have to copy and paste anything?
Only if you want to. The manual path — copy Cursor's HTML, drop it on host-html, click publish — always works and keeps you in control. The programmatic path skips it entirely: the agent sends the HTML for you and hands back the finished URL.
What do I need to let Cursor publish programmatically?
A free host-html account and your personal publish key, which starts with hh_. Give the key to Cursor, or install the publish skill that wraps the same endpoint, and the agent can POST the HTML and read back the live link.
How is this different from the Cursor-to-URL blog post?
That blog post is the conceptual walk-through of publishing AI code from Cursor in one command. This page is the practical landing spot for both routes — manual copy-and-drop and agent-driven API publish — with the current free and paid limits spelled out.
How long does a published page stay live, and how big can it be?
On a free account a page stays live for 10 days and can be up to 1MB, which fits almost any self-contained HTML file. Pro keeps pages forever and lifts the cap to 10MB, and Team goes to 50MB with custom domains.
Does this only work with Cursor?
No. host-html is model-neutral, so the same drop zone and publish API accept HTML from Claude, ChatGPT, Gemini, DeepSeek, v0, Bolt, or Lovable. Cursor is notable mainly because its agent can drive the publish API itself.