Ship 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).

The hosted endpoint exposes one tool: deployments_upload. For listing, custom domains, and account-tied operations, run it locally.

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.

That's it. Your agent can ship.

Run it locally

For listing, managing deployments, custom domains, and account-tied operations, install the local package with a free API Key:

claude mcp add shipstatic -e SHIP_API_KEY=ship-... -- npx -y @shipstatic/mcp

Or in any mcp.json:

{
  "mcpServers": {
    "shipstatic": {
      "command": "npx",
      "args": ["-y", "@shipstatic/mcp"],
      "env": {
        "SHIP_API_KEY": "ship-..."
      }
    }
  }
}

SHIP_API_KEY is optional. Without it, deploys behave like the hosted endpoint (public, claim URL, 3-day expiry). With it, you get permanent deployments, the full toolset, and bigger limits.

NPM · GitHub · MCP Registry · Smithery · Glama

Tools

The hosted endpoint exposes deployments_upload only. The local package exposes everything below.

Deployments

Tool	Description	Hosted
`deployments_upload`	Publish files as a new deployment (supports `password`)	✓
`deployments_list`	List all deployments
`deployments_get`	Show deployment details by hostname
`deployments_set`	Update deployment labels
`deployments_remove`	Delete a deployment permanently

Domains

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 hash — anyone with the hash 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_remove`	Delete a domain permanently

Account

Tool	Description
`whoami`	Show current account info

Typical Workflow

Anonymous publish (hosted endpoint, or local without an API key):

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

Custom domain (local package, with an API key):

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

What you can ask

Drop any of these into your agent. The hosted endpoint handles them all.

"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.

With the local install, your agent can also manage deployments, link custom domains, switch live versions, and look up DNS records:

"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."

Architecture

Zero business logic. Every tool is a one-liner that delegates to the SDK. The hosted endpoint receives file bytes inline (base64) since a Worker has no filesystem; the local package reads paths from disk. Same tool schemas where the surface overlaps.