Deploy from Claude Code

Three steps, two minutes

1 · Get a scoped token

Sign in, open API Keys, create a token with the deploy scope. It expires when you say and revokes in one click.

2 · One command

The API Keys page generates it with your token filled in — paste it into any terminal and restart your Claude Code session.

3 · Just ask

"Deploy this repo to SnapDeploy." Claude creates the container, links the repo, builds it and replies with the live URL.

claude mcp add --scope user snapdeploy \
  -e SNAPDEPLOY_API_KEY=sd_pat_your_token \
  -- npx -y @snapdeploy/mcp

Your repo needs to be on GitHub and connected to SnapDeploy once (the connector hands you the connect link if it isn't).

What you can say

"Deploy this repo to SnapDeploy"

"Why did my build fail?" — gets the error and the build-log tail

"What env vars does this repo need?" — scans the code first

"Set STRIPE_KEY on my-app"

"Add a Postgres database" · "Connect mydomain.com"

"Show me the logs" · "How many deploys do I have left?"

Free tier, honest limits — inside the chat

Free accounts get up to 4 containers, 100 container-hours a month, auto-sleep after ~15 minutes idle and 10 deploys a day (5 per rolling 12 hours; failed attempts count). When a limit bites, the reply carries SnapDeploy's own message and the exact link: a $1 Sprint Pack lifts the deploy limit for 24 hours; Always-On from $12/month per container removes it and keeps the app awake. The assistant relays it and stops — it never retries past a limit.

See pricing for the full catalog, including managed databases and Dedicated GPU.

What actually happens when you say "deploy"

Claude Code calls the connector's deploy tool. The connector is a small Node process on your machine (npx -y @snapdeploy/mcp) that speaks the Model Context Protocol over stdio. Nothing runs in the cloud on Claude's side; your token never leaves your machine except in requests to SnapDeploy.
It scans the repo first. detect_env_vars reads the code and config for variables the app needs and tells Claude which are required, which look secret, and where to find each value. Claude asks you for anything it cannot know — it never invents a value.
One request creates and links. POST /api/mobile/deploy creates the container and links the GitHub repository; the first build starts immediately. If linking fails — repository not accessible, already linked to another container, GitHub not connected — the container is removed again and Claude gets the reason. Nothing half-finished is left behind.
SnapDeploy builds and runs it. The build runs on AWS CodeBuild with framework detection (Node, Python, Go, Java, PHP, Ruby, static sites — a Dockerfile is honoured when present), pushes the image and starts an isolated AWS Fargate task with free SSL on a *.containers.snapdeploy.app URL. Builds usually take two to six minutes; the hard limit is sixty.
Claude gets the result. The connector polls the deployment and returns the live URL — or the error code, a plain-language message and the last lines of the build log, so Claude can fix the code and deploy again.
The deployment is attributed. Every call carries X-SnapDeploy-Client: mcp/claude-code; the row in your dashboard's deployment history reads "via Claude Code".

The 15 tools, and the scope each one needs

Scopes nest: read ⊂ deploy ⊂ manage. A token can only reach the rows at or below its scope; the server checks this before any controller runs, and answers 403 INSUFFICIENT_SCOPE with the scope it wanted.

Scope	Tools	What they do
read	`list_apps` `get_status` `get_logs` `get_deployments` `check_quota` `list_repos` `detect_env_vars`	Inventory, status, runtime logs, deployment history with error and build-log tail, remaining deploys and hours, connected GitHub repos, the env vars a repo needs (names, sources and where to find each value)
deploy	`deploy` `set_env` `start_container` `stop_container` `wake_container`	Create + link + build in one call (or rebuild an existing app at a chosen size), replace environment variables, start, stop and wake
manage	`create_database` `add_domain` `assign_always_on`	Managed Postgres, MySQL, MariaDB, MongoDB, Redis or RabbitMQ add-ons; custom domains; attach a spare Always-On subscription
— none —	delete, cancel, change password, apply SmartFix commits	Not tools, and refused by the server for every token (`403 INTERACTIVE_SESSION_REQUIRED`). These need a signed-in person.

Tokens: scoped, expiring, revocable

Made on the API Keys page, prefixed sd_pat_, shown exactly once — copy it into the assistant's config and it is gone from the UI. Only a hash is stored.
Pick a scope and an expiry (30, 90 or 365 days, or never). Up to 20 active tokens per account, so give each assistant and each machine its own.
Revoke in one click. A revoked or expired token gets 401 on every path from that moment — no grace period.
Its own rate limit. Each token has a separate request bucket (150 requests a minute), so a looping agent throttles itself rather than your dashboard or other tokens.

What a token can never do, whatever its scope: delete a container, database, domain or account; change the password; cancel a subscription; apply a SmartFix commit. Deleting needs a person signed in to the dashboard or the mobile app.
What a token never sees: environment-variable values come back as (set), database credentials as (redacted). The masking happens on the server, not in the connector, so a raw API call gets the same answer.
Legacy sk_ API keys still work but are unscoped — prefer a token for anything an assistant holds.
Treat the config file like an SSH key. If a laptop goes missing, revoke the token; nothing else needs to change.

The three ways this goes wrong, and what stops each

A README tells the agent to "clean up"

Prompt injection is real: a file in a cloned repo can carry instructions the model may follow. The connector has no delete tool, and if the agent escalates to a raw API call with the same token the server refuses it. We tested exactly that with a live agent — it got a 403.

The token leaks from a dotfile

A leaked token can deploy and read logs, nothing more: no deletes, no secrets (values are masked server-side), no account changes. It expires on the date you chose, it is throttled per token, and you revoke it in one click on the API Keys page.

The agent loops on a failing build

Every attempt costs one deploy unit and the reply says how many remain, so the model is told to diagnose before retrying. Identical requests inside ten minutes return the original build instead of a new one. Plan limits come back as 402/429 with your upgrade link and an instruction not to retry.

Troubleshooting

You see	It means	Do this
`401 Unauthorized`	The token was revoked, has expired, or the env var name in your config is wrong	Mint a new token on API Keys; the variable is `SNAPDEPLOY_API_KEY`
`403 INSUFFICIENT_SCOPE`	The token's scope is below what the tool needs; the response names `requiredScope`	Create a token with that scope (databases and domains need `manage`)
`GitHub not connected`	SnapDeploy has no GitHub authorization for your account yet	Open the link the connector returns (or Dashboard → Deploy → Connect GitHub) once; then ask again
`MISSING_ENTRY_POINT`	A Node repo has no `index.js`/`server.js`/`app.js` at the root and no `main`/`start` script	Add one, set a root directory, or add a Dockerfile — then deploy again
`Missing required environment variables`	The repo declares variables that are not set on the container	Ask for `detect_env_vars`, set them with `set_env`, deploy again
`402 SIZE_REQUIRES_ALWAYS_ON`	Medium (2 GB) and Large (4 GB) containers need an Always-On subscription	Deploy small, or buy Always-On from the link in the reply ($25 / $45 per month)
`402 websocket`	Apps that hold WebSocket connections need Always-On (sleeping containers would drop them)	Add Always-On from the link, or deploy a non-WebSocket app on the free tier
`429 DEPLOY_CAP_REACHED`	The free tier's 10 deploys a day (5 per rolling 12 hours) are used up — failed attempts count	Wait for the window, or a $1 Sprint Pack lifts the cap for 24 hours
`Tools do not appear in Claude Code`	The session started before the server was added, or the add command ran in a different scope	Restart the session; run `claude mcp list` — the server should show as connected

What it costs

Free

Up to 4 containers · 10 deploys/day (5 per rolling 12 h) · 100 hours/month · sleeps after ~15 min idle, wakes on the next request in about a minute · no credit card

Always-On

Per container, never sleeps, no hour cap, no deploy limit: Small 512 MB $12/month · Medium 2 GB $25 · Large 4 GB $45

$1 Sprint Pack

24 hours of Always-On for one container plus unlimited deploys — for a demo, a launch, a long debugging session

The connector itself is free and open. Managed databases and custom domains are available on every tier. India pays in INR (UPI, cards, net banking); everywhere else via PayPal. Full pricing.

Frequently asked questions

How do I deploy from Claude Code to SnapDeploy?

Create a scoped token on the SnapDeploy API Keys page, run one command — claude mcp add --scope user snapdeploy -e SNAPDEPLOY_API_KEY=your-token -- npx -y @snapdeploy/mcp — restart the session, then tell Claude Code to deploy your GitHub repository. It creates the container, links the repo, builds it and replies with the live URL.

Can Claude Code delete my SnapDeploy containers?

No. The connector has no delete tools, and the SnapDeploy server refuses deletes, subscription cancellations and password changes for every API key and token, whatever its scope. Deleting requires a person signed in to the dashboard or the mobile app.

Does the assistant see my environment variables or database passwords?

No. Tokens receive environment-variable names with every value replaced by "(set)", and add-on credentials are masked. The masking is done by the server, so a raw API call with the same token gets the same answer.

Is deploying from Claude Code free?

Yes. The free tier gives you up to 4 containers, 10 deploys a day (5 per rolling 12 hours) and 100 hours a month with no credit card. When you hit a limit the reply includes SnapDeploy's own upgrade link — a $1 Sprint Pack for 24 hours or Always-On from $12 per container per month.

Which repositories can Claude deploy?

Any GitHub repository your connected GitHub account can read, public or private, once you have connected GitHub to SnapDeploy (a one-time step; the connector returns the link if it is missing). The app needs a detectable entry point or a Dockerfile.

What happens if the build fails?

Claude receives the error code, a readable message and the last lines of the build log, fixes the code and deploys again. Each attempt counts toward the free deploy limit and the reply says how many remain; identical requests inside ten minutes return the original build instead of starting another.

Does it work in Claude Desktop too?

Yes. Claude Desktop reads the same server definition (command npx, args -y @snapdeploy/mcp, env SNAPDEPLOY_API_KEY) from its MCP configuration file, as does any other MCP client.

Where is the token stored, and how do I revoke it?

claude mcp add --scope user stores it in your Claude Code user configuration on your machine. Revoke it any time on the SnapDeploy API Keys page; from that moment every request with it returns 401. Tokens also expire on the date you chose when creating them.

Can I use the same thing from a script or CI instead of chat?

Yes. The connector only calls SnapDeploy's public API. The MCP reference documents the one-call deploy endpoint, the Idempotency-Key header for retry-safe pipelines and the X-SnapDeploy-Client header for attribution.

Using something else?

The same connector works in any MCP client: Cursor and Windsurf, Codex CLI and Gemini CLI, Claude Desktop, Cline, Zed, VS Code agent mode. Building with Lovable? Your export deploys first-try, no connector needed.