Skip to content

Automate

MCP server

Connect Claude Desktop, Claude Code or Cursor to QuickTane over MCP and manage services from your AI tools.

QuickTane runs an MCP server, so AI assistants can manage your services for you: "deploy the new tag of the API", "why does the worker keep restarting?", "add a Postgres database to this project". It offers the same operations as the REST API, with the same rules and limits.

Server URL and key #

  • URL: https://api.quicktane.com/mcp (Streamable HTTP transport)
  • Authentication: a team API key, sent as Authorization: Bearer qt_…

The assistant sees only the tools the key's scopes allow. Start with a key that has services:read only, and add services:deploy or services:manage when you want the assistant to make changes. Leave out services:delete unless you really want the assistant to be able to delete services.

Claude Code #

bash
claude mcp add --transport http quicktane https://api.quicktane.com/mcp \
  --header "Authorization: Bearer $QUICKTANE_API_KEY"

Run /mcp inside Claude Code to check that quicktane is connected.

Claude Desktop #

Claude Desktop connects to remote servers that use an API key through the mcp-remote bridge (it needs Node.js). Open Settings → Developer → Edit Config and add:

claude_desktop_config.json
{
  "mcpServers": {
    "quicktane": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://api.quicktane.com/mcp", "--header", "Authorization:${QUICKTANE_AUTH}"],
      "env": { "QUICKTANE_AUTH": "Bearer qt_your_key" }
    }
  }
}

Restart Claude Desktop; the QuickTane tools appear in the tools menu.

Cursor #

Add the server to ~/.cursor/mcp.json (all projects) or .cursor/mcp.json in one project — but don't commit a key to a repository:

mcp.json
{
  "mcpServers": {
    "quicktane": {
      "url": "https://api.quicktane.com/mcp",
      "headers": { "Authorization": "Bearer qt_your_key" }
    }
  }
}

Other clients #

Any MCP client that supports remote servers over Streamable HTTP with a custom header works with the URL and header above. Clients that only run local servers can use the mcp-remote bridge as shown for Claude Desktop.

Tools #

ToolWhat it doesScope
list_projects List the team's projects (each one is a private network for its services), newest first. Needs the services:read scope. services:read
list_services List the team's services (newest first, 50 per page), optionally only one project's. Each entry has the status, image, public URL and env variable names (never values). Needs the services:read scope. services:read
list_templates List service templates (databases, caches, search, queues, web apps): image, port, size, default env (names of generated secrets only), volume, how other services connect (`{host}` = the service slug, `${NAME}` = an env variable), notes and whether the team's plan can run it. Pass a key as `template` to create_service. Templates marked `experimental` are not yet verified on the platform. Needs the services:read scope. services:read
get_service A service's configuration and state: status (`deploying` while a saved change is not rolled out yet), public URL, image, size, mode, env variable names (never values) and `deployed_at` (when the last new configuration finished rolling out); `rollout` holds the same fields as get_deploy_status. Needs the services:read scope. services:read
get_deploy_status Rollout status of a service, to poll every few seconds after deploy_service or another change. The deploy is live once `applied_fingerprint` equals the deploy's `deploy_fingerprint` (pass it to get `fingerprint_applied`) and `is_ready` is true; `status` failed with a `status_reason` means the rollout failed. Needs the services:read scope. services:read
get_service_metrics A service's resource metrics: CPU (millicores) and memory (bytes) against the size's `limits`, network rx/tx (bytes per second), per-replica restarts, uptime (`started_at`) and last exit, plus `last_oom_killed_at` (`last_oom_likely`: inferred from a SIGKILL near the memory limit, not reported as OOMKilled). `range` is 1h (1-minute points, default), 24h (5-minute) or 7d (hourly); a null point means no data. In `total`, CPU and memory are the busiest replica's, network the sum; `pods` has per-replica series. Needs the services:read scope. services:read
deploy_service Roll out a new image for a service: pass `image` (a full public image reference, e.g. ghcr.io/acme/web:1.4.2) or `tag` (the current repository at a new tag). The image is checked and pinned to a digest now; the rollout runs in the background — then poll get_deploy_status with the returned `deploy_fingerprint`. Re-sending the current reference keeps the pinned digest, so deploy unique tags (e.g. a commit SHA), not a moving `latest`. Needs the services:deploy scope. services:deploy
create_service Create a service in a project from a public Docker/OCI image. A public service (`is_public` true) needs the container `port` and gets an HTTPS URL; others are reachable only inside the project by their slug. `mode` always_on keeps one replica running; scale_to_zero (public only) sleeps when idle. Env values are write-only: they are stored encrypted and never returned. The rollout runs in the background — poll get_deploy_status. With `template` (from list_templates) the template fills in the image, port, env (generating its passwords and keys), size and volume; any argument you pass overrides it (env merged by name). The generated values are returned once in `generated_env` — they are not shown again. Needs the services:manage scope. services:manage
update_service Change a service's configuration; only the fields you pass change. `env` adds or overwrites variables (write-only — values are never returned), `env_remove` deletes variables by name. The slug can't change; use deploy_service for a new image. The change rolls out in the background — poll get_deploy_status. Needs the services:manage scope. services:manage
start_service Start a stopped service again (one replica). Idempotent. Poll get_deploy_status until `is_ready`. Needs the services:manage scope. services:manage
stop_service Stop a service (scaled to zero replicas). Its configuration and env are kept; start_service brings it back. Idempotent. Needs the services:manage scope. services:manage
delete_service Permanently delete a service: its containers, public URL, env variables and persistent volume (its data) are removed and can't be restored. Ask the user first. `confirm` must equal the service's slug (see get_service). Needs the services:delete scope. services:delete
list_registry_credentials List a project's private registry credentials (host, username, last used) — passwords and tokens are never returned. Needs the services:read scope. services:read
set_registry_credential Save pull credentials for a private registry in a project, so its services can use private images from it: `host` is the registry (ghcr.io, registry.gitlab.com, docker.io, …), `username` and `password` (use a read-only token, ideally of a dedicated machine user: a GitHub classic PAT with read:packages can read every package its user can access; a GitLab deploy token with read_registry; a Docker Hub access token). Images are checked anonymously first; the credentials are used only when the registry demands auth. Replaces existing credentials for that host. The password is write-only. Needs the services:manage scope. services:manage
delete_registry_credential Delete a project's private registry credentials. Running services keep running, but services whose image needs them can't be deployed again until new credentials are added and they are redeployed. Ask the user first. Needs the services:manage scope. services:manage
list_domains List a service's custom domains: each with its `stage` (verifying, pending_dns, issuing_certificate, active, failed, removed), the verifier's `message`, and the two `dns_records` to create (a CNAME to the platform and a TXT ownership record whose value is per domain). Also says whether another domain may be added (`can_add`, `blocked_reason`) and the plan's limits. Needs the services:read scope. services:read
add_domain Add a custom domain (e.g. app.example.com) to a public service. The user must then create the two DNS records from `dns_records`: a CNAME to the platform (for an apex domain: ALIAS / CNAME flattening, or use www plus a redirect) and the TXT ownership record — its value appears within a minute, poll list_domains. On Cloudflare DNS the CNAME must be "DNS only" (grey cloud). The domain goes live once the TXT is seen and the certificate is issued. Paid plans only. Needs the services:manage scope. services:manage
verify_domain Check a pending or failed custom domain's TXT record right away and restart its verification window (domains are also re-checked automatically). Use it after the user created the DNS records; then poll list_domains for the stage. Needs the services:manage scope. services:manage
remove_domain Remove a custom domain from a service: it stops serving traffic at once and its certificate is removed. Adding it back needs a new TXT record. Ask the user first. Needs the services:manage scope. services:manage

Staying in control #

  • Everything the assistant does with your key counts as done by your team — give it the narrowest scopes that work.
  • delete_service needs the services:delete scope and the service's slug as confirmation, and the server asks the assistant to check with you first.
  • Env variable values are write-only: the assistant can set them but never read them back. Generated template passwords are returned once, at creation.
  • Revoke a key in the dashboard at any time; the assistant loses access immediately.

Something missing or wrong? Tell us — or open a ticket from the dashboard.