# MCP

> One URL for any MCP client: tools to publish sites and manage domains, with nothing to install and no account needed to deploy.

Source: https://docs.shipstatic.com/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**

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

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

```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](https://marketplace.visualstudio.com/items?itemName=shipstatic.shipstatic); 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:

```text
✓ 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`](https://www.npmjs.com/package/@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:

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

Or in any `mcp.json`:

```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](https://docs.shipstatic.com/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](https://www.npmjs.com/package/@shipstatic/mcp) · [GitHub](https://github.com/shipstatic/mcp) · [MCP Registry](https://registry.modelcontextprotocol.io/v0.1/servers?search=com.shipstatic/mcp) · [Smithery](https://smithery.ai/servers/shipstatic/ship) · [Glama](https://glama.ai/mcp/servers/shipstatic/mcp)

## Agents that run shell commands

If your agent can run a terminal command, it does not need MCP at all — the [CLI](https://docs.shipstatic.com/cli) publishes with nothing installed and nothing configured:

```bash
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](https://docs.shipstatic.com/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](https://docs.shipstatic.com/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.