ShipStatic Docs
llms.txt llms-full.txt

MCP

One URL. Your agent ships.

https://mcp.shipstatic.com

Drop that URL into any MCP client. Your agent can publish a static site in its next message — free, no install, no signup, no API key. The response includes a live URL and a claim URL the user can visit later to keep the site permanently (otherwise it expires in 3 days).

Connect an account and the same URL answers with the rest: listing, custom domains, and everything tied to an account. Connecting is optional — publishing without an account keeps working exactly as it does today.

Add it to your client

Claude Code

claude mcp add --transport http shipstatic https://mcp.shipstatic.com

Cursor, Antigravity, Windsurf, n8n, Zed — anywhere with mcp.json

{
  "mcpServers": {
    "shipstatic": {
      "url": "https://mcp.shipstatic.com"
    }
  }
}

Claude Desktop, Claude.ai web — add a custom connector pointing at https://mcp.shipstatic.com.

VS Code — install the ShipStatic extension; the server is built in, with no config at all.

That's it. Your agent can ship.

What you can ask

Drop any of these into your agent — no account needed:

"Ship the dist folder."

"Publish my Vite build to a live URL."

"Deploy and password-protect with preview2026."

"Re-publish with the new files."

"Ship it to a temporary URL I can send to my client."

"Tag this deployment v1.2 and publish it."

The agent calls deployments_upload and shows you:

✓ Live: https://happy-cat-abc1234.shipstatic.com
  Visit https://my.shipstatic.com/claim/... within 3 days to keep this deployment permanently.

Once the user claims it, the deployment is theirs and never expires.

Connect an account

Nothing to configure. Ask your agent for something that needs an account — "list my deployments" — and your client will offer to sign you in. Approve the permissions once and the whole toolset is available:

"List my deployments."

"Connect www.example.com to the latest one."

"Show me the DNS records I need to set up."

"Switch www.example.com to the previous deployment."

Connected deployments never expire, and you can pass a ttl when you want one that cleans itself up.

You can disconnect at any time from the same place in your client. Access is scoped and expires; it never includes creating API keys or deleting your account.

Tools

Fifteen tools, the same whichever way you connect. What changes is not which tools exist, but which ones answer.

Publishing — no account needed

Tool Description
deployments_upload Publish files as a new deployment (supports password)

Deployments — with an account

Tool Description
deployments_list List all deployments
deployments_get Show deployment details by hostname
deployments_set Update deployment labels
deployments_delete Delete a deployment permanently

Domains — with an account

Tool Description
domains_set Create a domain, link to deployment, or update labels
domains_list List all domains
domains_get Show domain details
domains_records Get required DNS records for a domain
domains_dns Look up the DNS provider for a domain (e.g. Cloudflare, Namecheap)
domains_share Get a shareable DNS setup link: anyone with it can view the records without an API key
domains_validate Check if a domain name is valid and available
domains_verify Trigger DNS verification after records are set
domains_delete Delete a domain permanently

Account — with an account

Tool Description
whoami Show current account info

Typical workflows

Publish with no account (nothing to set up):

  1. Agent calls deployments_upload with files
  2. Response has url (live now) and claim (visit to keep)
  3. Agent shows both URLs to the user

Custom domain (with an account):

  1. domains_validate to check availability
  2. domains_set to create or link
  3. domains_records to get DNS records, show them to the user
  4. domains_dns to identify the user's DNS provider (optional)
  5. domains_verify after the user configures DNS

Prefer to run it yourself?

The same fifteen tools also run as a local process, published as @shipstatic/mcp on npm. Reach for it when your agent needs to publish a folder on your own machine — the hosted endpoint receives files inline, so it has no path to read from — when you would rather configure a key once than sign in, or when your client does not speak OAuth yet:

claude mcp add shipstatic -e SHIP_TOKEN=ship-your-api-key -- npx -y @shipstatic/mcp

Or in any mcp.json:

{
  "mcpServers": {
    "shipstatic": {
      "command": "npx",
      "args": ["-y", "@shipstatic/mcp"],
      "env": {
        "SHIP_TOKEN": "ship-your-api-key"
      }
    }
  }
}

SHIP_TOKEN is optional and takes a free API Key. Without it, deploys are public with a claim URL and expire in 3 days. With it, they go to your account and never expire — the same two states connecting gives you on the hosted endpoint.

NPM · GitHub · MCP Registry · Smithery · Glama

Agents that run shell commands

If your agent can run a terminal command, it does not need MCP at all — the CLI publishes with nothing installed and nothing configured:

npx @shipstatic/ship ./dist

Same platform, same anonymous publish, same claim URL. Many agents reach for this first because there is no client configuration to add — see the Skill for a single file that teaches any agent to use it.

Architecture

Zero business logic. Every tool is a one-liner that delegates to the SDK. One tool surface, two ways to reach it: the hosted endpoint receives file bytes inline since a server has no access to your disk, and the local package reads paths from it. Everything else — the tools, their schemas, what they answer — is the same code.

Previous CLI Next SDK