Embarko is inBeta

Guide

How to Deploy from Cursor with One Prompt

Paste Embarko’s deployment prompt into Cursor’s agent and get a live HTTPS link. No Git or Dockerfile, plus the sandbox fix.

The Embarko team Updated · 11 min read

Cursor builds your app and runs it on your laptop. One prompt sends it out through Cursor’s sandbox to a live link. Scroll, and we’ll take it the whole way.

To deploy from Cursor, paste Embarko’s deployment prompt into Cursor’s agent.

Copy the prompt from embarko.ai, open your project in Cursor and paste it. The agent packs the folder, uploads it and hands you a live HTTPS link like your-app-name.embarko.app. No Git repo or Dockerfile is needed. If Cursor’s sandbox blocks the upload, allow Embarko’s hosts.

takeaways.log

Key takeaways

  • A Cursor app runs on localhost, which only your own computer can open. To share it, it needs a host.
  • The usual route asks for a GitHub repository, a hosting account, build settings and secret keys.
  • With Embarko, the “one prompt” is the deployment prompt copied from embarko.ai. Cursor’s agent packs the folder, uploads it and checks the status until the app is live.
  • Cursor’s sandbox blocks network access by default. If the upload is blocked, add three Embarko hosts to your sandbox.json allowlist, or approve the command.
  • Your first link needs no account. Press Keep within 24 hours and it stays at the same address.

01 — On your laptop

Why your Cursor app isn’t online yet

When Cursor builds your app, it runs it on your own machine so you can try it. You’ll often see an address like localhost:3000. “Localhost” simply means “this computer”, so a link that starts with it only works for you. Send it to a friend and it points at their computer, where your app doesn’t exist.

Tap the part of the link that’s the problem:

Your app runs in Cursor at localhost:3000. Send that link to a friend and it points at their computer, where your app doesn’t exist.

Putting an app online is called deploying. It takes three things: a server that stays on, your app’s files copied onto it, and a public address anyone can open. Together that’s called hosting. Cursor writes the app, but something else still has to host it.

02 — The usual route

Why deploying from Cursor gets complicated

Cursor hands you a project that works. The usual route to a host then asks for more than you may expect:

  1. A GitHub account and a repository, plus enough Git to push the project.

  2. A hosting service. Vercel, Netlify and others each have their own sign-up, dashboard and vocabulary.

  3. Build and start settings, and sometimes a Dockerfile Cursor didn’t write.

  4. Secret keys kept out of the code and added as environment variables on the host.

  5. A sandbox that can block the upload. Cursor runs agent commands in a sandbox, and network access inside it is blocked by default, so even a correct deploy command can fail until the host is allowed.

That’s fair work for a developer. For a small app Cursor wrote in one sitting, it’s a long way from “it runs” to “here’s the link”.

03 — Side by side

The usual route compared with Embarko

Embarko is hosting that your AI tool runs for you. Cursor’s agent packs the app, uploads it and checks that it’s live.

The usual route compared with deploying from Cursor through Embarko
The usual routeWith Embarko
Push the project to a GitHub repository No repository. Cursor’s agent uploads the folder directly.
Sign up for a host and connect it Your first link needs no account.
Configure the build, maybe add a Dockerfile No Dockerfile. Embarko detects the language and builds the app itself.
Read the build logs yourself The agent checks the status and hands you the link.

Not sure your Cursor project fits? What you can deploy is in the FAQ, with what to do if yours needs something else.

04 — The prompt

What “one prompt” means in Cursor

The one prompt is Embarko’s deployment prompt, a ready-made message that tells the agent how to deploy. It works because Cursor’s agent can run commands: Cursor’s own docs say it “runs shell commands directly in your terminal” (Cursor terminal docs). The agent reads the prompt, packs the folder, uploads it and reports the live link. It should also send cursor as its agent name, so once you keep the app, its deploy history shows which agent made each deploy.

Cursor’s agent runs the deploy in your terminal: it packs the folder, uploads it, checks the status and reports the link.

05 — The sandbox

Let Cursor’s agent reach Embarko

This is the step most Cursor deploys trip on, so it helps to know what’s happening. Cursor runs agent commands under a run mode, set in Settings → Agents → Approvals & Execution. Under the recommended default, Auto-review, allowlisted calls run at once, other shell commands run in Cursor’s sandbox when possible, and calls that can’t use the sandbox go to Cursor’s classifier for review. If a sandboxed command fails on a sandbox restriction, the agent can run it again outside the sandbox after the classifier reviews it, so the deploy may go through without any change from you.

Inside the sandbox, network access is blocked by default and opened only by your network mode and sandbox.json. The default network mode allows your sandbox.json list plus Cursor’s built-in defaults for common package managers and language tools. The deploy upload goes to Embarko’s hosts, so allow them:

.cursor/sandbox.json

Hosts in your allow list:

Cursor · Terminal
$ press “Run the deploy”
With all three hosts in sandbox.json, the deploy can reach Embarko from inside the sandbox.
Three ways to let Cursor’s agent reach Embarko
OptionWhat to doWhat to know
Allow Embarko’s hosts recommendedAdd embarko.ai, ship.embarko.ai and *.embarko.app to networkPolicy.allow in sandbox.json (example below): your-project/.cursor/sandbox.json for this project, or ~/.cursor/sandbox.json for all of them.Cursor combines the allow lists from both files. If your team admin has set a network allowlist, it replaces yours, so ask the admin to add these hosts.
Approve the commandWhen Cursor asks about the upload command, review it and approve it.Check that it only sends your project to ship.embarko.ai.
Run it yourselfAsk Cursor for the deploy commands and run them in Cursor’s terminal.Nothing is deployed until the upload succeeds, so don’t wait for a link before then. On Windows, ask for PowerShell versions that call curl.exe and tar.exe.

Create or open .cursor/sandbox.json in your project and add Embarko’s hosts to networkPolicy.allow. If the file already has an allow list, add the three hosts to it:

.cursor/sandbox.json
{
  "networkPolicy": {
    "allow": ["embarko.ai", "ship.embarko.ai", "*.embarko.app"]
  }
}

The full format is in Cursor’s sandbox.json reference.

Settings names and defaults are from Cursor run modes and sandboxing as of Cursor 3.23 (October 2026). Check that page if your Cursor version differs.

06 — Four steps

How to deploy from Cursor, step by step

Four steps. Tap a number when you’ve done it. 0 of 4 done.

preflight.check

Before you start

  • Your app runs locally.
  • Cursor’s agent can run commands and reach the internet. If it can’t, see the sandbox section.

  1. Open the project in Cursor

    Open the folder that holds your app. That folder is what gets uploaded.

    Cursor · Open Folder

    Pick the folder that holds your app.

  2. Copy the deployment prompt and paste it into Cursor’s agent

    Open embarko.ai, copy the deployment prompt, and paste it into a new agent chat in Cursor.

    deployment-prompt.txt What this does: tells Cursor’s agent how to pack, upload and check your app. 
    Deploy this app to Embarko — cloud hosting for small apps. No Dockerfile, no signup.

Read https://embarko.ai/docs/quickstart.md and follow it. Nothing to install.
Deploy anonymously first — no token, no account — then give me the live URL.
Only once it's live, ask me for my email: Embarko mails back a token that makes the app permanent.

Faster, if your tools let you install one: npx skills add embarko-ai/skill --skill embarko-deploy -g

    Here’s an example to add after it:

    I built a web app, help me get it live on Embarko

    The agent may first ask how you want to sign in. Skip the connector option, because Cursor doesn’t have one. Pick token by email (give your email, then paste the token from your inbox), or create a token at embarko.ai/app/tokens. With a token, the app goes into your account and is kept from the start. If you skip, the app still works for 24 hours. The three ways to sign in explains each option.

  3. Let the agent do the deploy

    It packs the project (leaving out node_modules, .git and .env files), uploads it, and checks the status about every 10 seconds until it reaches live. A static site is usually live in the first reply, and a server app builds first, so it takes longer. If Cursor asks you to approve a command, read it before you approve it.

    The app name becomes your address. It must be 3 to 63 characters (lowercase letters, numbers and dashes, with no dash at the start or end) and unique across Embarko. If it’s taken, the agent picks another. See app names.

    .embarko.app
    • 3 to 63 characters13
    • Lowercase letters, numbers and dashes
    • No dash at the start or end

    Unique across Embarko: if it’s taken, the agent picks another.

    • A first reply of “202 Accepted” only means the build has started. The app is live when the status says live. See 202 Accepted is not live.
    • If the upload fails with a network error, Cursor’s sandbox is blocking it and nothing was deployed. See the sandbox section.

  4. Open your link and keep it

    The agent gives you the address, your-app-name.embarko.app. Open it and click around. A link made without a token lasts 24 hours with no reminder email, though an HTML page shows a countdown banner. Ask Cursor to make it permanent: it asks for your email, Embarko emails you a token, you paste it into the chat, and the agent redeploys the same name. The link stays the same.

    Cursor · Agent24 h link
    1. Your app is live at your-app-name.embarko.app. It was made without a token, so it lasts 24 hours.

localhost:3000your-app-name.embarko.appOnly you can open it

Finish the four steps and your app gets a live link.

Stuck at any step? Failed deploys often come down to a blocked upload, a missing key or setting, or an app listening on the wrong port.

Open the fix list

07 — Later

Changing the app later

Ask Cursor to redeploy with the same name. Embarko keeps deployment history, and a kept app can roll back to a recent successful build. Rollback restores code, never data. Since Embarko isn’t where your code lives, keep your own copy too. A local Git repository is enough.

Redeploy my app to Embarko with the same name.

To use an API key, keep the app first, then ask the agent to set it as an environment variable with your Embarko deploy token and apply it. A write alone doesn’t reach the running app. Static sites can’t have environment variables, only server apps can.

A key you set is stored on Embarko. The running app only gets it once you apply it.

Troubleshooting

If something goes wrong

Pick what you’re seeing to get the likely cause and the fix.

What are you seeing?

Cursor · Terminal
$pick what you see

Failed deploys often come down to three things:

  1. 1

    A blocked upload.

    Cursor’s sandbox blocks Embarko’s hosts until you allow them.

  2. 2

    A missing key or setting.

    Something the app needs isn’t set on the host.

  3. 3

    The wrong port.

    The app listens on the wrong port or only on localhost.

If the link doesn’t open, or the status says failed or crashed, ask Cursor:

Make my app read its port from the PORT environment variable and listen on 0.0.0.0, then redeploy.
See every error at once
what you see, and the fix
Common deploy errors from Cursor, their likely cause and the fix
What you seeLikely causeFix
A network or connection error on the uploadCursor’s sandbox blocks Embarko’s hosts. Nothing was deployed.Allow embarko.ai, ship.embarko.ai and *.embarko.app in sandbox.json (how), approve the command, or run it in Cursor’s terminal.
403 host_not_allowedA network sandbox blocks the upload. Nothing was deployed.Same fix as above.
Exit code 137The app went over 256MB, often because it runs a dev serverUse the production start command, such as npm start after a build, not vite dev or next dev.
App gone after a dayIt was never keptDeploy it again and press Keep this time.
The link doesn’t open, or the status says failed or crashedThe app is listening on the wrong port or only on localhostAsk Cursor: “Make my app read its port from the PORT environment variable and listen on 0.0.0.0, then redeploy.”
Other deploy errors, such as 409 app_name_taken or a 422The reply’s code field names the causeLook the code up in the troubleshooting reference. Don’t retry a 409 or 422 unchanged.

Every code is explained in the troubleshooting reference.

Written by

The Embarko team
Published
Updated
Read time
11 min
Questions answered
9

08 — Questions

FAQ

What is Cursor’s sandbox?

It’s a restricted space where Cursor runs agent commands. Inside it, network access is blocked by default and opened only by your network mode and sandbox.json. That’s why an upload to a new host can fail until you allow the host’s address.

Can Cursor deploy my app?

Yes. Cursor’s agent runs shell commands in your terminal, so it can follow Embarko’s deployment prompt: it packs the project folder, uploads it and returns a live HTTPS link. Copy the prompt from embarko.ai, paste it into Cursor’s agent, and approve a command if Cursor asks. No Git repo or Dockerfile is needed.

What can I deploy from Cursor?

Embarko suits small web apps: plain websites, Node.js apps, Python apps, React or Vite apps and small SQLite databases. A frontend and a backend in one project are two apps. Postgres or MySQL, live WebSocket updates, scheduled jobs and heavy processing or a GPU need another route. Here’s how common Cursor projects line up, and what to do if yours needs something else.

Which Cursor projects Embarko can deploy, and what to know for each
What Cursor builtFits?What to know
A plain websiteYesKeep index.html at the top of the folder. Usually live straight away.
A Node.js appYespackage.json at the top. Read the port from PORT and listen on 0.0.0.0.
A Python appYesrequirements.txt or pyproject.toml at the top.
A React or Vite appYesBuilt first, then run as a server app.
A small databaseYes, SQLiteSave the file under DATA_DIR, the folder that survives redeploys. Keep your own copy of important data.
A frontend and a backend in one projectTwo appsOne deploy is one app. Deploy each folder as its own app.
Postgres or MySQLAnother routeEmbarko has no managed database. Use SQLite for small data, or host that app where its database lives.
Live updates (WebSockets)Another routeUse regular HTTP polling instead.
Scheduled jobsAnother routeRun them elsewhere and have them call your app.
Heavy processing or a GPUAnother routeRun that part elsewhere. Apps get 256MB of memory and no GPU.

Delete any Dockerfile Cursor added. Embarko builds the app itself and rejects an upload that includes one.

Does Cursor have an Embarko connector?

No. Claude is the only AI tool with an Embarko connector. Cursor uses the copied deployment prompt instead, which works for any AI tool. You can also get a deploy token by email, or create one at embarko.ai/app/tokens, so the agent can deploy straight to your account.

Why does Cursor block the deploy?

Cursor’s sandbox blocks network access unless a domain is allowed by your network mode or sandbox.json. If the upload fails with a network error, add embarko.ai, ship.embarko.ai and *.embarko.app to the sandbox.json allowlist, approve the command, or run it yourself in Cursor’s terminal.

Do I need GitHub to deploy from Cursor?

No. Embarko takes the project folder directly, so there’s no repo to create or connect. Embarko isn’t where your code lives, so keep your own copy: a local Git repository, a copy in cloud storage or a backup of the folder all work.

Will my app stay online?

Once you press Keep, yes. An app deployed without a token is deleted 24 hours after its first deploy. Ask Cursor to make it permanent: Embarko emails you a token, you paste it into the chat, and the agent redeploys the same name with it. The link stays the same.

Is it safe to put my Cursor app online?

Keep secret keys out of your project files. The agent leaves .env files out of the archive, and once you’ve pressed Keep you can add keys as environment variables, which Embarko stores encrypted and nobody can read back. Also remember that anyone with your link can open the app, so if it uses your AI key, set a spending limit with your AI provider if they offer one.

Is it free?

There’s a Free plan with 1 dynamic app and unlimited static websites. Creator is $9/month billed yearly for up to 5 dynamic apps, and Team is $23/month billed yearly for up to 20. Prices are from embarko.ai/pricing and can change.

Runs in Cursor, only for you

Your turn

Built something with AI? Ask it to deploy to Embarko.

Copy the prompt, paste it into Cursor, and get a live link without creating a repo.

  1. Copy
  2. Paste into Cursor
  3. Share your link

Keep reading: How to deploy an AI app · Deploy an app without GitHub · Agent quickstart · Troubleshooting reference · Cursor run modes and sandbox · Pricing

Continue reading…

View all guides
Your turn

Seen enough?
Ship something.

Copy the Embarko prompt, paste it into your AI agent, and your app goes live on its own link.

  1. Copy
  2. Paste into your agent
  3. Share your link