DeployLane / MCP v0.9.0
Model Context Protocol · live

Let AI drive your DeployLane account.

A hosted MCP endpoint that gives Claude Code, Claude Desktop, Cursor and any other MCP‑capable client read or read/write access to the apps, servers and deploys attached to your DeployLane workspace. No SDKs to install, no glue to maintain.

Endpoint https://mcp.deploylane.dev

01Quick start

Three steps from zero to chatting with your infra.

1

Generate a token

Open Settings → API access and click Generate token. Copy the value once — it’s shown only at creation.

2

Add DeployLane to your AI app

A few clicks in the Claude app, one command in Claude Code, or a short snippet in Cursor. Install walks you through it.

3

Ask in plain English

The model decides which tools to call. You describe what you want, not which API to hit.

02Install

Pick the AI app you use and follow its steps. You need two things: the address https://mcp.deploylane.dev and your token.

Have your token ready

Create one under Settings → API access in the dashboard. It starts with mcp_ and is shown only once, so keep it somewhere safe. Wherever the steps below say mcp_..., use your own token.

For the Claude desktop app and claude.ai in your browser. No files to edit.

  1. Open Claude and go to Customize → Connectors.
  2. Click + Add, then Add custom connector.
  3. Enter DeployLane as the name and https://mcp.deploylane.dev as the URL, then continue.
  4. For sign-in, choose No sign in.
  5. Under Request headers, add a header named Authorization with the value Bearer mcp_...: the word Bearer, a space, then your token.
  6. Click Add. Start a new chat and ask “Which apps do I have on DeployLane?”

Custom connectors need a paid Claude plan. On Team and Enterprise, an Owner adds the connector first.

03Authentication & scopes

Every request other than GET /health must carry a Bearer token. Each token has a scope you can change later from the dashboard — the plaintext stays the same so connected clients keep working.

read

Read‑only

List + inspect apps, servers, deploys, logs, metrics, backups and Umami analytics. Safe default — hand to any AI client you want to give visibility without trusting it to act on your account.

  • list_*
  • get_app, get_recent_deploys, get_deploy_log
  • tail_logs, get_server_metrics, get_diagnose
  • get_backup_history, get_pitr_status, get_umami_stats
write

Full access

Adds create / update / delete tools — provisioning new apps, setting env vars, managing cron jobs, deploying and rolling back, starting and stopping apps, rebooting and resizing servers. Only give to clients you trust to make changes.

  • create_app, add_web_route, set_env_vars
  • create_cron, update_cron, delete_cron
  • trigger_deploy, rollback_app, start_app, stop_app
  • reboot_server, resize_server, prune_docker, create_umami_website
Tokens are per‑user and scoped

Every tool query is scoped to the owning user’s data and cannot see other accounts. Revoke a leaked token from the dashboard — it’s effective immediately.

04Tools · 43

Everything the AI can call. Tool names are namespaced deploylane.<name> in clients (the prefix is muted below for readability).

deploylane.list_servers
read cheap
List all Hetzner servers in this DeployLane account. Returns id, alias, ipv4, status, location, server_type.
deploylane.list_apps
read cheap
List all apps in this DeployLane account with their server alias, primary domain (custom or auto-assigned), and derived status. Use deploylane.get_app for a single-app deep dive.
deploylane.get_app
read cheap
Full snapshot of one app: server, routes, auto-domain URLs (auto_urls), env var keys (no values), recent deploys. The go-to call for "tell me everything about this app".
deploylane.get_recent_deploys
read cheap
Deployment history for one app. Use to answer "which deploys failed today" / "how long did the last deploy take". Logs come from deploylane.get_deploy_log.
deploylane.get_deploy_log
read cheap
Full log text of a single deployment. Use after deploylane.get_recent_deploys to investigate a failure. Logs are capped at 256 KiB — truncation is flagged in the response.
deploylane.tail_logs
read expensive
Recent container stdout/stderr for an app — `docker compose logs --tail` over SSH. Useful for 'what is my app saying right now'. Omit `service` to get every service interleaved (each line prefixed with its service name); pass `service` to get exactly that one (e.g. "worker"). The response echoes `available_services` so you can discover service names without get_diagnose.
deploylane.get_server_metrics
read expensive
Snapshot of a server: CPU %, memory %, disk %, uptime. Use for operational health checks.
deploylane.get_diagnose
read expensive
Quick health check for one app: DNS resolution (custom domains + auto-domains), container state, recent Traefik error lines. Lightweight alternative to the dashboard's Diagnose tab — for the AI to triage 'something's wrong' questions.
deploylane.get_migration_guide
read cheap
Returns the full DeployLane migration guide as text — same content as the `make_deploylane_ready` MCP prompt. Use when your MCP client doesn't expose prompts, or when you want the AI to ingest the guide as a regular tool response.
deploylane.get_umami_status
read expensive
Find the user's self-hosted Umami analytics instance: where it runs, its public URL, and which websites are already registered. Account-scoped, not server-scoped — tracking is client-side, so an app on one server can report to an Umami on another. Call this FIRST when asked to add analytics to an app; if it returns enabled:false the user has to switch Umami on in the DeployLane dashboard (server → Settings → Analytics).
deploylane.get_umami_stats
read expensive
Totals from Umami analytics for one website over a period: pageviews, unique visitors, visits, bounce rate and average time on page. Pass path to restrict the totals to a single page — path only (/pricing), matched exactly; a full URL silently matches nothing. Set compare_to_previous to also get the immediately preceding period of the same length, which is how you tell whether a change actually moved anything. Identify the website with app_id (preferred — DeployLane looks up the app's NEXT_PUBLIC_UMAMI_WEBSITE_ID and falls back to matching its domains), or with domain or website_id directly. Umami records no search keywords, impressions or rankings — those never come from this tool.
deploylane.get_umami_timeseries
read expensive
Pageviews and sessions over time from Umami, bucketed by hour, day or month. Use this to find WHEN something changed — a traffic drop, a spike after a release — before digging into why with deploylane.get_umami_breakdown or deploylane.get_umami_page_report. Pass path to chart a single page. Buckets are UTC unless you pass timezone. Two caveats measured against Umami 3.2.0: only buckets with traffic are returned, so a gap in the series means no data rather than zero; and for ranges beyond roughly a month unit=hour is silently coarsened to daily, so read the real bucket width off the returned timestamps.
deploylane.get_umami_breakdown
read expensive
Top-N breakdowns from Umami for one website, several dimensions in a single call. Valid metrics: path, title, referrer, browser, os, device, screen, language, country, region, city, event, query. Ask for every dimension you need at once — they are fetched in one batch, so one call with five metrics is far cheaper than five calls. Pass path to break down the traffic of a single page (for example: which referrers send people to /pricing). Note that the page dimension is called path, not url — there is no url metric.
deploylane.get_umami_top_pages
read expensive
The most-visited pages of one website, each with its pageviews for the period, the same figure for the preceding period of equal length, the change, and whether the page is new. This is the starting point when someone asks which page to improve: rank first here, then call deploylane.get_umami_page_report on the page you picked. Identify the website with app_id (preferred), domain or website_id. If the previous-period query failed, previous_pageviews and is_new are null on every row and the failure is listed in errors — null means unknown, so do not read it as zero or as a newly launched page.
deploylane.get_umami_page_report
read expensive
Everything Umami knows about ONE page, in a single call: totals for the period and for the preceding period of equal length, the change between them, a pageviews timeseries, and top referrers, countries, devices, browsers and query parameters — all filtered to that page. Use this to ground content and SEO advice in real visitor behaviour instead of guesswork. Get the path from deploylane.get_umami_top_pages if you do not have one. The response always includes data_gaps: Umami records no search keywords, impressions or ranking positions, so never infer those from this data. If a sub-query fails the report still returns, with the failure listed in errors — treat a listed error as missing data, not as a zero. In particular, previous_totals is null (and every field of change is null) when the previous period could not be fetched; that means unknown, never "grew from nothing".
deploylane.compare_umami_periods
read expensive
Put two sides of the same website next to each other with the same metrics and the differences between them. Compare exactly ONE axis per call: either two date ranges (period_a_start/period_a_end vs period_b_start/period_b_end) — for questions like "did the rewrite on 12 July help" — or two page paths within one period (path_a vs path_b). Passing both axes, or neither, is an error. Umami records no search keywords, impressions or rankings.
deploylane.create_app
write expensive
Create a new app on one of your servers. Probes the GitHub repo for compose vs Dockerfile and validates an optional per-app PAT. Every app automatically gets a unique HTTPS auto-domain (<service>.<app>-<id>.apps.deploylane.dev) that goes live on the first deploy — no DNS setup needed. An optional `domain` adds a custom hostname alongside it. Use after deploylane.list_servers to pick a server.
deploylane.add_web_route
write expensive
Attach a custom domain to an existing app, in addition to its auto-domain. For multi-service apps, set `service_name` to the matching compose service. Aliases (redirect / additional) are optional. On an app that is deployed and running the domain goes live right away: DeployLane refreshes the Traefik labels, which recreates the app's web container(s) — a brief restart, no rebuild. Env var changes saved since the last deploy go live with it. `traefik_sync` in the result says whether that happened; if it was skipped or failed, follow its note. A Dockerfile-mode app or a failed sync needs deploylane.trigger_deploy. A stopped app is left stopped, and a deploy would start it, so ask the user first.
deploylane.set_env_vars
write expensive
Bulk-upsert env vars on an app. Default mode is additive (existing keys not in the call are left alone). To replace the full set, pass both `replace_all: true` AND `confirm_wipe: true` AND at least one entry — a safety guard against the AI accidentally wiping secrets. Values are encrypted at rest. Per-service vars supported via `service_name`. Keys that deploylane.get_app marks `managed: true` are owned by DeployLane: leave them out of `vars`. `replace_all` keeps them anyway, and one managed key refuses the whole call without writing anything. Returns only the key list; secret values are never echoed back.
deploylane.create_cron
write expensive
Schedule a recurring HTTP call from an app. The job runs in a one-shot curl container on the server's docker network, so URLs like http://<app-name>-app:3000/... reach the app directly. Header values are encrypted at rest. The host crontab is re-synced as part of this call.
deploylane.trigger_deploy
write expensive
Kick off a deploy for an app. Returns immediately with a `deployment_id` — the build runs in the background. Poll deploylane.get_deploy_log and deploylane.get_recent_deploys to track progress. Pass `commit_sha` for an exact pin, or `ref` for a branch/tag (defaults to the app's configured branch).
deploylane.list_crons
read cheap
List cron jobs configured for an app. Header VALUES are NOT returned (they may contain bearer tokens) — only `header_keys` is echoed. Pairs with create_cron / update_cron / delete_cron.
deploylane.get_cron_history
read expensive
Per-run history of an HTTP cron job, newest first, read from the host's JSONL run log. Each run includes ok, http_status, duration, curl_exit, response_excerpt, error and any webhook_error — enough to see why a scheduled call failed. Get the cron_id from deploylane.list_crons.
deploylane.list_backup_jobs
read cheap
List the pg_dump backup jobs configured for an app: schedule, enabled state, target Postgres service, and a snapshot of the last run (time/status/size). Discovery entrypoint — feed the returned `id` to get_backup_history or list_stored_backups. This is the scheduled snapshot backup, distinct from PITR (see get_pitr_status).
deploylane.get_backup_history
read expensive
Per-run history of a backup job, newest first, read from the host's JSONL run log. Each run includes status (success/failure/skipped), exit_code, duration, dump size, the S3 key, and `output_excerpt` — the tail of pg_dump/aws-cli stderr that explains a failure. Get the backup_job_id from deploylane.list_backup_jobs.
deploylane.list_stored_backups
read expensive
List the dump files actually stored in object storage for a backup job (key, size, last-modified), newest first. Reflects what is RETAINED right now — older dumps may have been expired by the bucket lifecycle rule. Complements get_backup_history (which reports run outcomes). Get the backup_job_id from deploylane.list_backup_jobs.
deploylane.get_pitr_status
read expensive
Point-in-time-recovery status for an app: enabled flag, stanza, mirrored last-base-backup outcome, and the LIVE recovery window (earliest/latest target time, WAL lag, healthy) from `pgbackrest info`. This is the continuous WAL-archiving backup system, distinct from the scheduled pg_dump jobs (see list_backup_jobs). Returns enabled:false when PITR was never turned on. `s3_credentials_missing: true` means DeployLane refuses restores and manual base backups until an admin adds an S3 key pair to the account; the window, WAL archiving and the nightly base backups keep running, because pgbackrest on the host keeps using the key of the last sync.
deploylane.delete_env_var
write expensive
Remove a single env var from an app. Idempotent — a missing row returns success. service_name follows the same scoping as set_env_vars: omit/null for the shared var, a string for that compose service's per-service var. Managed vars (`managed: true` in deploylane.get_app) cannot be deleted here.
deploylane.remove_web_route
write expensive
Detach a custom domain from an app by deleting its web route row. Get the route_id from deploylane.get_app (under `routes`). Auto-domains are managed separately by DeployLane (not routes), so they are unaffected. On an app that is running the domain leaves Traefik right away: DeployLane refreshes the Traefik labels, which recreates the app's web container(s) — a brief restart, no rebuild. Env var changes saved since the last deploy go live with it. `traefik_sync` in the result says whether that happened; if it was skipped or failed, follow its note. A Dockerfile-mode app or a failed sync needs deploylane.trigger_deploy. A stopped app is left stopped, and a deploy would start it, so ask the user first.
deploylane.delete_cron
write expensive
Delete a cron job and re-sync the host crontab so its wrapper script + crontab line are removed. Get the cron_id from deploylane.list_crons.
deploylane.update_cron
write expensive
Update fields of a cron job (any subset of: name, schedule, method, url, headers, webhook_url, webhook_method, webhook_headers, enabled, timeout_seconds). Header maps are FULL-REPLACE — pass `{}` to clear all headers. Pass `webhook_url: null` to clear the completion callback entirely. The host crontab is re-synced as part of this call. If that re-sync fails, the change is saved and the result has `synced: false` and a `warning`: the host may still run the job with its previous settings until a retry.
deploylane.restart_app
write expensive
Bounce an app's container(s) without rebuilding — `docker compose restart` for compose apps, `docker restart` for the single-container fallback. Use when a process needs a kick. A stopped app is refused — bring it back with deploylane.start_app first, or for a stack DeployLane manages (Umami) with its card on the server's Settings tab. Does NOT pick up env var changes — for those, set_env_vars then trigger_deploy.
deploylane.start_app
write expensive
Bring a stopped app's existing containers back — no rebuild, no git pull, and env var changes are NOT picked up. Recreates containers whose network was deleted while they were stopped (`recovered: true`). If the containers were pruned after a long stop, it refuses and deploylane.trigger_deploy is needed instead. The app is marked running only once a service is actually up. A stack DeployLane manages (Umami) is refused: switch it on from its card on the server's Settings tab in the dashboard, which also restores its backup job.
deploylane.stop_app
write expensive
Stop an app's container(s) without removing them — `docker compose stop` for compose apps, `docker stop` for the single-container fallback. Traffic to the app fails until deploylane.start_app brings it back; restart_app refuses a stopped app. The nightly cleanup removes containers that have been stopped for more than 24h; after that only trigger_deploy brings the app back (volumes are kept). Refuses the DeployLane app itself, since this MCP server runs in that stack. Also refuses a stack DeployLane manages (Umami): switch it off from its card on the server's Settings tab in the dashboard, which also pauses its backup job.
deploylane.create_umami_website
write expensive
Registers ONE website per WEB SERVICE in the user's Umami instance and returns a ready-to-paste tracking snippet (website id + script URL, as plain HTML and as a Next.js <Script> block). A DeployLane app can serve several public hostnames (e.g. `www` and `app` as separate compose services) — each needs its own Umami website, otherwise their paths and session stats are mixed into one unusable report. Call the tool once per service with `service_name` in that case; pass `app_id` and it will list the candidate services rather than guess. Services with no browser-facing HTML (`mcp`, `api`, `worker`) are flagged as not trackable — the browser script cannot load there. Idempotent per domain: an existing website with the same domain is reused instead of duplicated. Does NOT modify the target app: NEXT_PUBLIC_* values are build-time and would silently fail to reach the bundle without matching Dockerfile ARG/ENV and compose build.args, so adding the snippet stays the caller's job.
deploylane.prune_docker
write expensive
Reclaim docker disk space on a server: dangling images, containers stopped for more than 24h, unreferenced networks older than 24h, old pulled images (unused, once a later-built image from the same repository has been on the server for the wait, 7 days unless the server's docker-cleanup.conf says otherwise; app images, the versions DeployLane pins and the newest image of each repository stay), plus a build cache prune that both drops records unused for 24h and caps the cache at 15% of the disk (4-20 GB, least-recently-used evicted first). VOLUMES ARE NEVER TOUCHED (they hold Postgres data and app uploads). Returns the freed MB. Pair with deploylane.get_disk_usage_report for the inspect → reclaim → inspect cycle.
deploylane.get_disk_usage_report
read expensive
Detailed disk-usage breakdown for a server: filesystem, docker disk usage by type, per-resource breakdown, top /var/lib/docker subdirs, and how much an aggressive prune would free. Read-only — nothing is removed. Useful for 'my server is filling up, where's it going?' triage.
deploylane.restart_traefik
write expensive
Restart the Traefik reverse-proxy container on a server. Useful when Traefik wedges on a failed Let's Encrypt attempt — restarting clears the ACME backoff. Brief ingress outage (~5s) for ALL apps on the server.
deploylane.prune_orphaned_certs
write expensive
Find Let's Encrypt certificates in Traefik's acme.json that no live router and no DeployLane app on the server (running or stopped) uses any more; Traefik keeps failing to renew those. Dry run by default, nothing changes. apply: true with domains (orphans from a dry run) prunes them detached on the host, re-checked there first: Traefik is stopped ~5-10s, an ingress outage for ALL apps on the server, and a timestamped backup is kept. Pass the returned unit to read the outcome.
deploylane.reboot_server
write expensive
Reboot a Hetzner server (shutdown → wait → power-on). Takes EVERY app on this server offline for ~30-60s. REQUIRES confirm: true — the AI must opt in deliberately. Returns once power-on is accepted by Hetzner; poll deploylane.list_servers to see the status converge back to 'running'.
deploylane.resize_server
write expensive
Resize a Hetzner server: change its type (cores, RAM, optionally the disk). A running server is powered off for a few minutes and on again after, so EVERY app on it is offline meanwhile; a server that is already off is changed while off and stays off. Changes what the server costs. REQUIRES confirm: true — the AI must opt in deliberately. Refused for the server that runs DeployLane itself. Returns a run at once; the resize runs in the background. Use deploylane.get_resize_status with include_types: true first to see which types this server can move to, and with the run_id afterwards to follow it.
deploylane.get_resize_status
read cheap
Whether a server can be resized, its running resize (if any) and its recent resizes. With run_id: just that run. With include_types: true, also the current type and the types this server can move to (same architecture, offered at its location, disk at least as big), priced at its location.
deploylane.rollback_app
write expensive
Roll an app back to a previous successful deployment. Returns a NEW deployment_id; the actual rollback runs in the background. Compose-mode apps get a full redeploy at the old SHA; dockerfile-mode apps get a fast image swap. Get the deployment_id from deploylane.get_recent_deploys — must be status='success'.

05Prompts & resources

Server‑hosted prompt templates the AI invokes directly. In Claude Code: /mcp__deploylane__<name>. Clients that don’t surface prompts can invoke the equivalent tool instead.

Prompts

make_deploylane_ready Make this repo DeployLane-ready

Walk the current repo through the DeployLane migration checklist: strip Vercel-specific bits, swap Neon/Vercel Blob for sibling Postgres + Hetzner S3, generate Dockerfile + docker-compose, finish with the env-vars + cron config the user needs to paste into the DeployLane UI.

Resources

deploylane://spec/v1 text/markdown

DeployLane app spec (v1) — Conventions a repo must follow to be deployable via DeployLane. Placeholder until the full spec lands.

06Example prompts

Real questions you can paste into your AI client. The model decides which tools to call and chains them together as needed — you stay in plain English.

“Give me a status of all my apps.”
“Which Hetzner servers do I have, and where are they?”
“Are any of my apps in a failed state?”
“Show me apps that haven’t been deployed in the last 30 days.”
“How many apps do I have per server?”

07Rate limits

Per account, shared by all your tokens, in sliding 60‑second windows. Hitting a limit returns a clean tool error with a retry_after_seconds hint — not an HTTP 429 — so your AI client can back off without breaking the conversation.

cheap
120 / min

Pure DB reads — list_apps, list_servers, get_app, get_recent_deploys, get_deploy_log, list_crons, list_backup_jobs, get_migration_guide.

expensive
20 / min

Anything that SSHes into a server (tail_logs, get_server_metrics, get_diagnose), calls Umami or object storage, or mutates state. The cheap limit applies in addition.

cooldown
60 sec

Per‑app on trigger_deploy. Prevents parallel‑deploy storms from a runaway AI loop. Independent of deploy status.

Backoff hints, not HTTP 429

The MCP SDK has no concept of transport‑level retry semantics. AI clients DO read the error text — the rejected response includes a precise retry_after_seconds.

08FAQ

Open Settings → API access in the dashboard and click revoke on the token row. Effective immediately — the next request from that token fails auth.
Yes. Edit the token from the dashboard and change its scope. The plaintext stays the same so connected clients keep working without re-pasting.
MCP traffic uses POST to this same root path. A browser GET (Accept: text/html) gets this help page; an MCP client’s standalone GET SSE stream (Accept: text/event-stream) is declined with 405, since our stateless transport sends no server-initiated notifications.
It doesn’t. Read tools return only key names. Write tools accept new values but never echo them back. Values are encrypted at rest.
A backup job is a scheduled pg_dump snapshot uploaded to object storage — inspect its runs with get_backup_history and the stored files with list_stored_backups. PITR (point-in-time recovery) is continuous WAL archiving via pgbackrest that lets you restore to any moment in the retention window; check it with get_pitr_status. They are independent and an app can use either or both.