Koskamo

run.zero MCP

An official MCP server provided by run.zero that allows AI agents to deploy web apps, APIs, and managed Postgres databases. It supports OAuth authentication and exposes tools for creating apps, pushing files, deploying, waiting for builds, and retrieving logs, enabling developers to manage their PaaS infrastructure directly through AI assistants like Claude Code.

Visit Get IT Done GmbH

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

run.zero MCP logo, by Get IT Done GmbHVendor evidenceStreamable HTTPNo sign-inEndpoint checked 2026-11-06Operated by Get IT Done GmbH
You need:OAuth sign-in
MCP endpoint (Streamable HTTP)
https://api.run-zero.de/mcp
Vendor documentation

What its tools do

50 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

Read-only (23)

Can change data (27)

50 of 50 have a description · 50 of 50 declare behavior hints · 47 of 47 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Passed Official MCP Registry namespace is tied to run-zero.de ·
  • Passed Endpoint is on the registry namespace domain ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Deploy web applications and APIs via AI chat
  • Manage managed Postgres database instances
  • Push code files and trigger deployments
  • Retrieve build logs and status updates

Source and maintenance

Vendor evidenceRegistry 1.0.2
mcp-registry: de.run-zero/mcp@1.0.2Source repositoryProject website
Maintenance checked

Protocol and capabilities

Server
run-zero 1.2.0
MCP protocol negotiated in check
2025-11-25
Tools
50 advertised
Resources
Not advertised
Resource templates
Not advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {}
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

run.zero (run-zero.de) is a Platform-as-a-Service from Get IT Done GmbH — Heroku-style ergonomics on European infrastructure. Use these tools to manage apps, services, addons, and deployments on behalf of the authenticated user. ## Core concepts - **App**: top-level container, linked to one Git repository. Has a stable slug like "my-app-a1b2c3d4" that appears in every URL. - **Service**: a runtime process built from a path inside the repo. Each app can have multiple (e.g. "backend" + "frontend"). Each gets a default domain: https://<service>-<app-slug>.run-zero.app - **Addon**: managed resource (postgres, keycloak). Attaching an addon to a service injects its credentials as environment variables (e.g. DATABASE_URL). - **Domain**: custom hostname mapped to a service. TLS via Let's Encrypt automatically. ## Typical workflow 1. runzero_create_app — name only (omit repo to author code yourself), or with a Git repo URL to deploy existing code. 2. Get code into the app: - Author it yourself: runzero_push_files writes UTF-8 text files into the app's repo as ONE atomic commit and auto-creates a platform-managed repo on the first push. Binary assets: NEVER inline them — runzero_upload_assets gives the user a dashboard upload link, or sourceUrl fetches a file from the web server-side. Read back via runzero_list_files / runzero_read_file. Call runzero_get_help topic 'files' FIRST — it has the full flow, code layout rules and the run-zero.yaml format. - Or connect an existing repo. Buildpack auto-detects Node/Python/Go/PHP/Java from the source. Use a Procfile for custom start commands. The web process MUST listen on $PORT (default 8080). 3. runzero_deploy ONCE after the first push/link — it creates the service(s) from the repo root or the run-zero.yaml. Later pushes rebuild automatically. Logs via runzero_get_logs. 4. Attach addons / set secrets / map custom domains as needed. ## Data Local files are lost on every restart and deploy. Keep SQLite, PocketBase data and uploads on a volume: `volumes:` in run-zero.yaml (help topic files), and act on `warnings` in the runzero_deploy result. ## More info Call runzero_get_help with a topic (workflow, files, addons, procfile, domains) for structured guidance on any of these areas. ## Auth scope Each request is scoped to the user identified by the bearer token. Tools only return resources the user owns or collaborates on — server-side authorization is the same as the REST API. ## Safety Every tool carries annotations. destructiveHint=true marks tools that delete, overwrite or change what visitors see (delete_*, deploy with prune, scaling to 0, publish/restore_release/activate_version, set_secrets, push_files, runzero_db_query with allow_write=true). Confirm the exact action with the user before calling one of them; never call them to "clean up" on your own. ## Support Docs: https://github.com/getitdone-gmbh/run-zero-mcp · contact: info@itdone.de

Tools

50 advertised

runzero_get_help — Platform help
Advertised by the server during the last successful anonymous check.
Advertised read-only

Look up structured guidance on platform concepts and conventions. Topics: workflow, files, addons, procfile, domains. Call this whenever you need to understand addons, the Procfile/PORT convention, or the typical workflow for a new app. Returns markdown.

runzero_get_help input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "topic": {
      "enum": [
        "workflow",
        "files",
        "addons",
        "procfile",
        "domains"
      ],
      "type": "string",
      "description": "One of: workflow, files, addons, procfile, domains. Omit to get a list of available topics."
    }
  },
  "additionalProperties": false
}
runzero_get_help annotations
{
  "title": "Platform help",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_list_apps — List apps
Advertised by the server during the last successful anonymous check.
Advertised read-only

List the apps the authenticated user has access to (own + collaborated), newest first — one compact row each (name, slug, url, kind, status, flags). Details of one app: runzero_get_app.

runzero_list_apps input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {},
  "additionalProperties": false
}
runzero_list_apps annotations
{
  "title": "List apps",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_get_app — Get app details
Advertised by the server during the last successful anonymous check.
Advertised read-only

Get one app: slug, status, publish mode, services (URL, replicas, health, env var NAMES), addons, domains. Secret values are never returned.

runzero_get_app input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "name"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Name of the app"
    }
  },
  "additionalProperties": false
}
runzero_get_app annotations
{
  "title": "Get app details",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_create_app — Create app
Advertised by the server during the last successful anonymous check.
Open-world

Create a new app. Optionally links to a Git repository — if no repo is given, you can attach one later.

runzero_create_app input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "name"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "App name (3-30 chars, lowercase, letters/numbers/hyphens)"
    },
    "repo": {
      "type": "string",
      "description": "Git repository URL (https://github.com/org/repo)"
    },
    "branch": {
      "type": "string",
      "description": "Git branch (default: main)"
    },
    "companionOf": {
      "type": "string",
      "description": "Name/slug of an existing app this one is a companion of (e.g. a preview or staging environment, or an A/B variant). The new app reuses the parent's repo and joins a shared project so the two show up stacked, while staying its own separate deployment. Pair with a different branch for a prod/preview split."
    }
  },
  "additionalProperties": false
}
runzero_create_app annotations
{
  "title": "Create app",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
runzero_list_templates — List templates
Advertised by the server during the last successful anonymous check.
Advertised read-only

List the curated template library: finished, deployed page designs (landing pages, shops, portfolios …) that can be adopted as the starting point of a NEW app instead of building from scratch. Each entry has a live URL and a screenshot URL plus kind/industries/tags for matching. Adopting a matching template is far cheaper and better-looking than writing a page from zero — check here FIRST on any first build.

runzero_list_templates input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {},
  "additionalProperties": false
}
runzero_list_templates annotations
{
  "title": "List templates",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_adopt_template — Create app from template
Advertised by the server during the last successful anonymous check.

Create a NEW app as a full copy of a template from runzero_list_templates: app + repo + running instance, owned by the caller. Use this INSTEAD of runzero_create_app when a template matches the request, then adapt the copy (texts, colors, images — placeholder assets keep their paths and get overwritten). The copy provisions asynchronously; follow with runzero_wait_for_build as usual.

runzero_adopt_template input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "sourceSlug"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Name for the new app (short kebab-case, derived from the subject)"
    },
    "sourceSlug": {
      "type": "string",
      "description": "Slug of the template (from runzero_list_templates)"
    }
  },
  "additionalProperties": false
}
runzero_adopt_template annotations
{
  "title": "Create app from template",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
runzero_list_services — List services
Advertised by the server during the last successful anonymous check.
Advertised read-only

List the services (runtime processes) of an app with their build source, port, replicas and status.

runzero_list_services input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    }
  },
  "additionalProperties": false
}
runzero_list_services annotations
{
  "title": "List services",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_get_logs — Get service logs
Advertised by the server during the last successful anonymous check.
Advertised read-only

Get the runtime log output of one service (stdout/stderr of its running containers), last N lines.

runzero_get_logs input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "service"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "tail": {
      "type": "integer",
      "maximum": 1000,
      "description": "Number of log lines (default: 60 — the error is in the last lines; raise only if they do not explain it)",
      "exclusiveMinimum": 0
    },
    "service": {
      "type": "string",
      "description": "Name of the service"
    }
  },
  "additionalProperties": false
}
runzero_get_logs annotations
{
  "title": "Get service logs",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_get_metrics — Get service metrics
Advertised by the server during the last successful anonymous check.
Advertised read-only

CPU and memory usage of a service over a time window (default last hour). Returns per-pod current/min/max/avg — CPU in millicores, memory in MiB — not raw time series, to stay compact.

runzero_get_metrics input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "service"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "range": {
      "enum": [
        "15m",
        "1h",
        "6h",
        "24h"
      ],
      "type": "string",
      "description": "Time window (default: 1h)"
    },
    "service": {
      "type": "string",
      "description": "Name of the service"
    }
  },
  "additionalProperties": false
}
runzero_get_metrics annotations
{
  "title": "Get service metrics",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_screenshot — Screenshot live page
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

SEE the deployed page with your own eyes: renders the live URL in a real browser and returns fresh screenshots as images — desktop (1280×800) and/or mobile (390×844). Use it after runzero_wait_for_build to review the visual result like a designer would (spacing, contrast, overlaps, broken mobile layout) and fix what you SEE, not what you assume. Never cached; but the rollout of a fresh build lands ~30-90s after build success, so a screenshot taken too early shows the previous version — if it looks unchanged, wait briefly and call again.

runzero_screenshot input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "path": {
      "type": "string",
      "description": "Page path to render, e.g. '/impressum' (default: '/')"
    },
    "service": {
      "type": "string",
      "description": "Service name (optional if the app has exactly one)"
    },
    "fullPage": {
      "type": "boolean",
      "description": "Render the whole page height (capped at 3200px) instead of the first screen, so sections further down are in the picture too (default: false)"
    },
    "viewport": {
      "enum": [
        "desktop",
        "mobile",
        "both"
      ],
      "type": "string",
      "description": "Which widths to render (default: both)"
    }
  },
  "additionalProperties": false
}
runzero_screenshot annotations
{
  "title": "Screenshot live page",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_rebuild_service — Rebuild service
Advertised by the server during the last successful anonymous check.
Open-world

Rebuild a service from the latest commit of its repo branch; on success the new version rolls out to the live URL. Use after an external repo changed; pushes via runzero_push_files rebuild on their own.

runzero_rebuild_service input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "service"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "service": {
      "type": "string",
      "description": "Name of the service to rebuild"
    }
  },
  "additionalProperties": false
}
runzero_rebuild_service annotations
{
  "title": "Rebuild service",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
runzero_delete_app — Delete app
Advertised by the server during the last successful anonymous check.
Advertised destructive

Permanently delete an app with all its services, addons (including database data), secrets and domains. Irreversible: only on an explicit request, and name the app back to the user before calling.

runzero_delete_app input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "name"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Name of the app to delete"
    }
  },
  "additionalProperties": false
}
runzero_delete_app annotations
{
  "title": "Delete app",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
runzero_deploy — Deploy app
Advertised by the server during the last successful anonymous check.
Advertised destructiveOpen-world

Deploy an app. Fetches the repo and checks for run-zero.yaml (or the older itdone.yaml). If found, syncs all services + addons + domains from config. If not, deploys the repo as a single service. Services missing from the config are scaled to 0; with prune=true they are DELETED. Run runzero_deploy_preview first to see the diff. Read `warnings` in the result: it reports data that will not survive a restart (a known image without room for its automatic volume, SQLite in the code without `volumes:`) and gives the exact fix. Apply it before you call the app done.

runzero_deploy input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "prune": {
      "type": "boolean",
      "description": "Delete services not present in config (default: false → scale to 0 instead)"
    }
  },
  "additionalProperties": false
}
runzero_deploy annotations
{
  "title": "Deploy app",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": true
}
runzero_deploy_preview — Preview deploy changes
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Preview what a deploy would change without making any changes. Use this before runzero_deploy to verify the diff.

runzero_deploy_preview input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    }
  },
  "additionalProperties": false
}
runzero_deploy_preview annotations
{
  "title": "Preview deploy changes",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_add_service — Add service
Advertised by the server during the last successful anonymous check.
Open-world

Add a new service to an app. Clones the repo, builds with buildpacks, and deploys. The web process must listen on $PORT.

runzero_add_service input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "name",
    "repo"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "name": {
      "type": "string",
      "description": "Service name (3-30 chars, lowercase)"
    },
    "path": {
      "type": "string",
      "description": "Subdirectory inside the repo for monorepo builds"
    },
    "port": {
      "type": "integer",
      "maximum": 9007199254740991,
      "description": "Container port to expose (default: 8080)",
      "exclusiveMinimum": 0
    },
    "repo": {
      "type": "string",
      "description": "Git repository URL"
    },
    "branch": {
      "type": "string",
      "description": "Git branch (default: main)"
    },
    "replicas": {
      "type": "integer",
      "maximum": 10,
      "minimum": 0,
      "description": "Replica count (default: 1)"
    },
    "git_token": {
      "type": "string",
      "description": "GitHub PAT for private repos"
    }
  },
  "additionalProperties": false
}
runzero_add_service annotations
{
  "title": "Add service",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
runzero_delete_service — Delete service
Advertised by the server during the last successful anonymous check.
Advertised destructive

Permanently delete one service of an app: its running containers, its public URL and its configuration. Irreversible, and it also deletes the persistent volume of the service with all its backups; to only stop it, scale it to 0 with runzero_scale_service.

runzero_delete_service input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "service"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "service": {
      "type": "string",
      "description": "Name of the service to delete"
    }
  },
  "additionalProperties": false
}
runzero_delete_service annotations
{
  "title": "Delete service",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
runzero_scale_service — Scale service
Advertised by the server during the last successful anonymous check.
Advertised destructive

Set the replica count of a service (0-10). Scaling to 0 takes the service offline (its URL stops answering) without deleting it; scale up again to bring it back. A service with a persistent volume runs 0 or 1 replicas and keeps its data at 0.

runzero_scale_service input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "service",
    "replicas"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "service": {
      "type": "string",
      "description": "Name of the service"
    },
    "replicas": {
      "type": "integer",
      "maximum": 10,
      "minimum": 0,
      "description": "Replica count (0-10)"
    }
  },
  "additionalProperties": false
}
runzero_scale_service annotations
{
  "title": "Scale service",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
runzero_volume_status — Volume status
Advertised by the server during the last successful anonymous check.
Advertised read-only

Show the persistent volume of a service: mount path, size, last backup, the backups that can be restored, and the state of a running or last restore. Volumes are declared under `volumes:` in run-zero.yaml (runzero_get_help topic files).

runzero_volume_status input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "service": {
      "type": "string",
      "description": "Service name (default: the only service)"
    }
  },
  "additionalProperties": false
}
runzero_volume_status annotations
{
  "title": "Volume status",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_backup_volume — Back up volume
Advertised by the server during the last successful anonymous check.

Start a backup of the persistent volume now, on top of the automatic daily one. The service keeps running. It runs in the background; runzero_volume_status lists it once it is finished.

runzero_backup_volume input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "service": {
      "type": "string",
      "description": "Service name (default: the only service)"
    }
  },
  "additionalProperties": false
}
runzero_backup_volume annotations
{
  "title": "Back up volume",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
runzero_restore_volume — Restore volume
Advertised by the server during the last successful anonymous check.
Advertised destructive

Replace the data on the persistent volume with a backup. The service stops, the current data is backed up first, the backup is unpacked, and the service starts again. Takes minutes; follow it with runzero_volume_status (`restore.phase` ends at `done`, with `error` if it failed and the data stayed unchanged).

runzero_restore_volume input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "backupId"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "service": {
      "type": "string",
      "description": "Service name (default: the only service)"
    },
    "backupId": {
      "type": "string",
      "description": "Id of the backup, from runzero_volume_status"
    }
  },
  "additionalProperties": false
}
runzero_restore_volume annotations
{
  "title": "Restore volume",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": true
}
runzero_set_secrets — Set secrets
Advertised by the server during the last successful anonymous check.
Advertised destructive

Set one or more environment variables for an app or a specific service. Existing keys are overwritten; other keys are preserved. Affected services are redeployed automatically.

runzero_set_secrets input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "secrets"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "secrets": {
      "type": "object",
      "description": "Key/value pairs. Keys must start with a letter and contain only letters, numbers, and underscores.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "type": "string"
      }
    },
    "service": {
      "type": "string",
      "description": "Scope secrets to a single service. Omit for app-wide secrets."
    }
  },
  "additionalProperties": false
}
runzero_set_secrets annotations
{
  "title": "Set secrets",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
runzero_list_secrets — List secret names
Advertised by the server during the last successful anonymous check.
Advertised read-only

List the secret keys for an app (values are never returned). Includes both app-wide and per-service secrets.

runzero_list_secrets input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    }
  },
  "additionalProperties": false
}
runzero_list_secrets annotations
{
  "title": "List secret names",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_delete_secret — Delete secret
Advertised by the server during the last successful anonymous check.
Advertised destructive

Delete a single secret from an app or a service. Affected services are redeployed automatically.

runzero_delete_secret input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "key"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "key": {
      "type": "string",
      "description": "Secret key to delete"
    },
    "service": {
      "type": "string",
      "description": "Service scope. Omit for app-wide secrets."
    }
  },
  "additionalProperties": false
}
runzero_delete_secret annotations
{
  "title": "Delete secret",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
runzero_list_builds — List builds
Advertised by the server during the last successful anonymous check.
Advertised read-only

List recent build records for an app. Returns kpack Build status (success/failed/running) per service. To WAIT for a build to finish, use runzero_wait_for_build instead of calling this in a loop.

runzero_list_builds input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    }
  },
  "additionalProperties": false
}
runzero_list_builds annotations
{
  "title": "List builds",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_list_versions — List versions
Advertised by the server during the last successful anonymous check.
Advertised read-only

Earlier versions of a service that can be put back online, newest first. Each entry has an `image` (pass it to runzero_activate_version or runzero_preview_version), when it was built, and `summary` — the commit message, i.e. what changed. `active: true` marks what is online now. Use this when the user refers to an earlier state ("wie gestern", "vor der Umgestaltung"). Omit `service` when the app has only one.

runzero_list_versions input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "service": {
      "type": "string",
      "description": "Service name (default: the only service)"
    }
  },
  "additionalProperties": false
}
runzero_list_versions annotations
{
  "title": "List versions",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_preview_version — Preview earlier version
Advertised by the server during the last successful anonymous check.

Show an earlier version under a SECOND address without touching the live site — use this whenever the user wants to look before deciding. Returns a url; the pod needs a few seconds, so a first request may fail — retry once. Pass `stop: true` (without `image`) to tear the preview down again; it costs nothing once stopped.

runzero_preview_version input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "stop": {
      "type": "boolean",
      "description": "Remove the preview instead of creating one"
    },
    "image": {
      "type": "string",
      "description": "Image of the version to show, from runzero_list_versions"
    },
    "service": {
      "type": "string",
      "description": "Service name (default: the only service)"
    }
  },
  "additionalProperties": false
}
runzero_preview_version annotations
{
  "title": "Preview earlier version",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_work_url — Get preview link
Advertised by the server during the last successful anonymous check.

The URL where this app's UNPUBLISHED changes can be looked at, and a link that opens it (the plain hostname refuses without one). Call this after EVERY change to an app that publishes on request, and give the user the link with a plain sentence: their change is on the preview, their real site is untouched, and it goes live when they say so. Without that sentence they look at their own website, see nothing, and conclude the change was lost.

runzero_work_url input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    }
  },
  "additionalProperties": false
}
runzero_work_url annotations
{
  "title": "Get preview link",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_list_releases — List releases
Advertised by the server during the last successful anonymous check.
Advertised read-only

What the user has PUBLISHED, newest first, with the sentence they described each change with, and which one visitors see right now. This is the list to use when someone says "wie letzte Woche" or "vor der Umgestaltung" — not runzero_list_versions, which lists every build including the platform's own bookkeeping commits and is unreadable for a person. Also reports whether something is built and waiting.

runzero_list_releases input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    }
  },
  "additionalProperties": false
}
runzero_list_releases annotations
{
  "title": "List releases",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_publish — Publish changes
Advertised by the server during the last successful anonymous check.
Advertised destructive

Put the waiting changes on the real site — this is what VISITORS see, so only ever on an explicit request ("mach das live", "veröffentliche das"), never on your own initiative after finishing a change. Write `description` in the user's own words and in their language ("Tag der offenen Tür angekündigt"), because that sentence is what they will read next month when they want to go back. Only for apps that publish on request; an app that publishes automatically has nothing to publish.

runzero_publish input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "description"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "description": {
      "type": "string",
      "maxLength": 500,
      "description": "What changed, in the user's words — shown in their version list"
    }
  },
  "additionalProperties": false
}
runzero_publish annotations
{
  "title": "Publish changes",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": true
}
runzero_restore_release — Restore release
Advertised by the server during the last successful anonymous check.
Advertised destructive

Put an earlier published state back on the real site. Use the id from runzero_list_releases. This CHANGES what visitors see. It does not touch the code: anything changed since is still there and still waiting, so this undoes what is published, not the work. If the user wants an announcement removed rather than the whole site rolled back, edit the page instead — going back also removes every other change made since.

runzero_restore_release input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "release"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "release": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": -9007199254740991,
      "description": "Release id from runzero_list_releases"
    }
  },
  "additionalProperties": false
}
runzero_restore_release annotations
{
  "title": "Restore release",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
runzero_set_publish_mode — Set publish mode
Advertised by the server during the last successful anonymous check.
Advertised destructive

Switch between publishing every change immediately (auto) and collecting changes on a preview until the user releases them (manual). Explain the consequence before switching to manual: from then on nothing reaches their visitors until they say so, which is the point but also a way to wonder for days why a change never appeared. Switching back to auto publishes whatever was waiting, immediately.

runzero_set_publish_mode input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "mode"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "mode": {
      "enum": [
        "auto",
        "manual"
      ],
      "type": "string",
      "description": "auto = live at once, manual = release first"
    }
  },
  "additionalProperties": false
}
runzero_set_publish_mode annotations
{
  "title": "Set publish mode",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
runzero_activate_version — Activate version
Advertised by the server during the last successful anonymous check.
Advertised destructive

Put an earlier version back online — this CHANGES what visitors see. Only do this when the user explicitly asks to go back; never on your own initiative after a failed build (fix the code instead). While an older version is active, new builds are built but NOT published, until you call this again with image "latest". If the service has a database, the container goes back but the data does not — say so and pass acknowledge_data only after the user confirms.

runzero_activate_version input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "image"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "image": {
      "type": "string",
      "description": "Image from runzero_list_versions, or \"latest\" to follow new builds again"
    },
    "service": {
      "type": "string",
      "description": "Service name (default: the only service)"
    },
    "acknowledge_data": {
      "type": "boolean",
      "description": "Required when the service has an addon: confirms the database is not rolled back"
    }
  },
  "additionalProperties": false
}
runzero_activate_version annotations
{
  "title": "Activate version",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
runzero_wait_for_build — Wait for build
Advertised by the server during the last successful anonymous check.
Advertised read-only

Wait server-side until the newest build of an app is finished AND the new version is serving traffic — use this INSTEAD of polling runzero_list_builds, sleeping, or re-checking the site in a loop. Blocks up to 45 seconds per call and returns {status: "success" | "failed" | "running", phase, rollout, builds}. "running" with phase "building" or "rolling-out" means: call it again. A rollout follows every successful build by 30-90 s, and until it lands the live URL, curl and screenshots still show the OLD version — do not push a fix for what you see in that window. "success" with phase "live" means every pod serves the new build; phase "done" means built but not live for a reason named in `hint` (the app publishes on request, an older version is pinned, not deployed yet). On "failed", read runzero_get_build_logs with the failed build id.

runzero_wait_for_build input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "service": {
      "type": "string",
      "description": "Only wait for this service (default: all services)"
    }
  },
  "additionalProperties": false
}
runzero_wait_for_build annotations
{
  "title": "Wait for build",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_get_build_logs — Get build logs
Advertised by the server during the last successful anonymous check.
Advertised read-only

Get the full log stream for a specific build (all kpack steps concatenated). Use runzero_list_builds first to find the build id.

runzero_get_build_logs input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "build_id"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "tail": {
      "type": "integer",
      "maximum": 800,
      "description": "Number of log lines from the END (default: 120). A failed build explains itself in its last lines; raise only if they do not.",
      "exclusiveMinimum": 0
    },
    "build_id": {
      "type": "string",
      "description": "Build id from runzero_list_builds"
    }
  },
  "additionalProperties": false
}
runzero_get_build_logs annotations
{
  "title": "Get build logs",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_push_files — Push files
Advertised by the server during the last successful anonymous check.
Advertised destructiveOpen-world

Push changes into the app's Git repository as ONE atomic commit (create, patch, and delete in a single push). CHANGING an existing file? Use `edits` — an exact-snippet replacement, like your editor's edit tool. Use `files` only to create a NEW file or to genuinely rewrite one end to end: it resends the whole document, so a twelve-line change costs you the entire file. Both may appear in the same push (different paths). If the app has no repository yet, a platform-managed repo is created automatically on the first push. Text files only (UTF-8) — for binary assets (icons, images, fonts) NEVER attempt to inline the bytes; models cannot generate valid binary data. Instead use runzero_upload_assets (the user uploads via the dashboard) or set sourceUrl on a file entry (the server downloads it from the web). IMPORTANT: after the FIRST push on a fresh app, run runzero_deploy once — it creates the service(s) from the repo (single service from the root, or several from a run-zero.yaml). Later pushes rebuild existing services automatically. See runzero_get_help topic 'files' for the full flow, code layout rules and the run-zero.yaml format. Only works with platform-managed repositories, not external repos. `deletions` and `files` overwrite or remove files in the repo; earlier content stays in the Git history.

runzero_push_files input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "edits": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "path",
          "oldString",
          "newString"
        ],
        "properties": {
          "path": {
            "type": "string",
            "maxLength": 256,
            "minLength": 1,
            "description": "Path of an EXISTING file in the repo"
          },
          "newString": {
            "type": "string",
            "maxLength": 200000,
            "description": "Replacement text. An empty string deletes the matched snippet."
          },
          "oldString": {
            "type": "string",
            "maxLength": 200000,
            "minLength": 1,
            "description": "Exact text to replace, copied verbatim from the file including indentation and line breaks. Must match exactly once unless replaceAll is set — include a surrounding line or two to make it unique."
          },
          "replaceAll": {
            "type": "boolean",
            "description": "Replace every occurrence instead of requiring a unique match (default: false)"
          }
        },
        "additionalProperties": false
      },
      "maxItems": 200,
      "description": "Patches to existing files — the cheap way to change code. Applied in order; several edits may target the same file and are applied one after another."
    },
    "files": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "path"
        ],
        "properties": {
          "path": {
            "type": "string",
            "maxLength": 256,
            "minLength": 1,
            "description": "File path within the repo (e.g. index.html, assets/logo.png)"
          },
          "content": {
            "type": "string",
            "maxLength": 6000000,
            "description": "UTF-8 text content (exactly one of content/sourceUrl per file)"
          },
          "sourceUrl": {
            "type": "string",
            "maxLength": 2000,
            "description": "https URL the platform downloads server-side and commits as this file — use for images/fonts that already exist on the web"
          }
        },
        "additionalProperties": false
      },
      "maxItems": 200,
      "description": "Files to create or rewrite completely. To change part of an existing file use edits instead."
    },
    "message": {
      "type": "string",
      "maxLength": 500,
      "description": "Commit message"
    },
    "deletions": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 256
      },
      "maxItems": 200,
      "description": "File paths to delete from the repo"
    },
    "trigger_build": {
      "type": "boolean",
      "description": "Trigger a build after pushing (default: true)"
    }
  },
  "additionalProperties": false
}
runzero_push_files annotations
{
  "title": "Push files",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}
runzero_list_files — List files
Advertised by the server during the last successful anonymous check.
Advertised read-only

List all files in the app's Git repository (platform-managed repos only). Optionally filter by path prefix.

runzero_list_files input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "path": {
      "type": "string",
      "maxLength": 256,
      "description": "Path prefix filter (e.g. src/)"
    }
  },
  "additionalProperties": false
}
runzero_list_files annotations
{
  "title": "List files",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_read_file — Read file
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read a file from the app's Git repository (platform-managed repos only), UTF-8. Returns at most 250 lines per call (a note at the end says how to continue) — read the part you need with startLine/endLine instead of the whole file; every returned line is paid for on every later step.

runzero_read_file input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "path"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "path": {
      "type": "string",
      "maxLength": 256,
      "minLength": 1,
      "description": "File path within the repo"
    },
    "endLine": {
      "type": "integer",
      "maximum": 9007199254740991,
      "description": "Last line to return (default: startLine + 249)",
      "exclusiveMinimum": 0
    },
    "startLine": {
      "type": "integer",
      "maximum": 9007199254740991,
      "description": "First line to return (1-based, default 1)",
      "exclusiveMinimum": 0
    }
  },
  "additionalProperties": false
}
runzero_read_file annotations
{
  "title": "Read file",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_upload_assets — Get asset upload link
Advertised by the server during the last successful anonymous check.
Advertised read-only

Get the dashboard upload link for an app so the USER can upload binary assets (icons, images, fonts) via drag & drop — real bytes, nothing travels through the model. Give the returned URL to the user, wait until they confirm the upload, then call runzero_list_files with path 'assets/' and reference the files in the code.

runzero_upload_assets input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    }
  },
  "additionalProperties": false
}
runzero_upload_assets annotations
{
  "title": "Get asset upload link",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_list_users — List app users
Advertised by the server during the last successful anonymous check.
Advertised read-only

List the end-users of an app's login realm (requires the app's keycloak addon). Returns id, username, email and enabled state.

runzero_list_users input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    }
  },
  "additionalProperties": false
}
runzero_list_users annotations
{
  "title": "List app users",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_create_user — Create app user
Advertised by the server during the last successful anonymous check.

Create an end-user in the app's login realm. Returns the generated password ONCE if none is given — relay it to the user, it cannot be retrieved later.

runzero_create_user input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "username"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "email": {
      "type": "string",
      "format": "email",
      "pattern": "^(?:[A-Za-z0-9_'+\\-]+\\.)*[A-Za-z0-9_'+\\-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$",
      "description": "Email address"
    },
    "password": {
      "type": "string",
      "maxLength": 256,
      "minLength": 8,
      "description": "Initial password (generated if omitted)"
    },
    "username": {
      "type": "string",
      "maxLength": 64,
      "minLength": 3,
      "description": "Username (letters, digits, . _ -)"
    }
  },
  "additionalProperties": false
}
runzero_create_user annotations
{
  "title": "Create app user",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
runzero_delete_user — Delete app user
Advertised by the server during the last successful anonymous check.
Advertised destructive

Permanently delete an end-user (account, sessions, login data) from the app's login realm. Irreversible; to only block the login use runzero_set_user_enabled.

runzero_delete_user input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "user_id"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "user_id": {
      "type": "string",
      "description": "Keycloak user id (from runzero_list_users)"
    }
  },
  "additionalProperties": false
}
runzero_delete_user annotations
{
  "title": "Delete app user",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
runzero_reset_user_password — Reset app user password
Advertised by the server during the last successful anonymous check.
Advertised destructive

Replace an end-user's password in the app's login realm; the old one stops working at once. Returns the new password ONCE (generated if none given).

runzero_reset_user_password input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "user_id"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "user_id": {
      "type": "string",
      "description": "Keycloak user id"
    },
    "password": {
      "type": "string",
      "maxLength": 256,
      "minLength": 8,
      "description": "New password (generated if omitted)"
    }
  },
  "additionalProperties": false
}
runzero_reset_user_password annotations
{
  "title": "Reset app user password",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": true
}
runzero_set_user_enabled — Enable or block app user
Advertised by the server during the last successful anonymous check.
Advertised destructive

Enable or disable (block) an end-user in the app's login realm. A disabled user cannot log in but is not deleted.

runzero_set_user_enabled input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "user_id",
    "enabled"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "enabled": {
      "type": "boolean",
      "description": "true = enable, false = block"
    },
    "user_id": {
      "type": "string",
      "description": "Keycloak user id"
    }
  },
  "additionalProperties": false
}
runzero_set_user_enabled annotations
{
  "title": "Enable or block app user",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
runzero_list_identity_providers — List login providers
Advertised by the server during the last successful anonymous check.
Advertised read-only

List external login providers (Google, GitHub, …) configured on the app's login realm. Secrets are never returned.

runzero_list_identity_providers input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    }
  },
  "additionalProperties": false
}
runzero_list_identity_providers annotations
{
  "title": "List login providers",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_create_identity_provider — Add login provider
Advertised by the server during the last successful anonymous check.
Open-world

Add an external login provider (Google, GitHub, Microsoft, generic OIDC/SAML) to the app's login realm, so end-users can sign in with it. You need an OAuth client id/secret from the provider first. IMPORTANT: the response contains a redirect URI that the user must register in the provider's OAuth app — surface it to them. For generic 'oidc' also pass authorization_url and token_url.

runzero_create_identity_provider input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "alias",
    "provider_id",
    "client_id",
    "client_secret"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "alias": {
      "type": "string",
      "maxLength": 64,
      "minLength": 2,
      "description": "Short id, e.g. \"google\" (lowercase, digits, -)"
    },
    "client_id": {
      "type": "string",
      "description": "OAuth client id from the provider"
    },
    "token_url": {
      "type": "string",
      "description": "Generic OIDC only"
    },
    "provider_id": {
      "enum": [
        "google",
        "github",
        "microsoft",
        "oidc",
        "saml"
      ],
      "type": "string",
      "description": "Provider type"
    },
    "display_name": {
      "type": "string",
      "description": "Button label shown on the login page"
    },
    "client_secret": {
      "type": "string",
      "description": "OAuth client secret from the provider"
    },
    "authorization_url": {
      "type": "string",
      "description": "Generic OIDC only"
    }
  },
  "additionalProperties": false
}
runzero_create_identity_provider annotations
{
  "title": "Add login provider",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
runzero_generate_image — Generate image
Advertised by the server during the last successful anonymous check.
Advertised destructiveOpen-world

Generate an image with AI (FLUX) and commit it into the app's repo. Costs credits. Use for hero images, backgrounds, illustrations. The file is committed at the given path (e.g. assets/hero.jpg), replacing a file already there, and a rebuild is triggered; reference it in the code afterwards. The prompt is sent to Black Forest Labs (EU endpoint).

runzero_generate_image input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "prompt",
    "path"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "path": {
      "type": "string",
      "maxLength": 256,
      "minLength": 1,
      "description": "Target path in the repo, e.g. assets/hero.jpg (.png for PNG)"
    },
    "prompt": {
      "type": "string",
      "maxLength": 2000,
      "minLength": 3,
      "description": "What the image should show"
    },
    "aspect_ratio": {
      "enum": [
        "1:1",
        "16:9",
        "9:16",
        "4:3",
        "3:4",
        "21:9"
      ],
      "type": "string",
      "description": "Aspect ratio (default: 16:9)"
    }
  },
  "additionalProperties": false
}
runzero_generate_image annotations
{
  "title": "Generate image",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": true
}
runzero_db_query — Run SQL query
Advertised by the server during the last successful anonymous check.
Advertised destructive

Run one SQL statement against an app's PostgreSQL addon (owner/admin only). Read-only by default: the statement runs in a READ ONLY transaction that is rolled back. With allow_write=true it CAN WRITE: INSERT/UPDATE/DELETE and DDL (DROP, ALTER, TRUNCATE) are committed immediately and cannot be undone. Before setting allow_write, show the user the exact SQL and get their explicit confirmation. Results are capped at 1000 rows; statements time out after 15s.

runzero_db_query input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "app",
    "sql"
  ],
  "properties": {
    "app": {
      "type": "string",
      "description": "Name of the app"
    },
    "sql": {
      "type": "string",
      "maxLength": 20000,
      "minLength": 1,
      "description": "A single SQL statement"
    },
    "allow_write": {
      "type": "boolean",
      "description": "Must be true for INSERT/UPDATE/DELETE/DDL; default false = read-only"
    }
  },
  "additionalProperties": false
}
runzero_db_query annotations
{
  "title": "Run SQL query",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": true
}
runzero_describe_addon — Describe addon
Advertised by the server during the last successful anonymous check.
Advertised read-only

Show exactly which environment variables an addon injects into an attached service, straight from the platform (the source of truth — use this instead of guessing env var names). Call it BEFORE writing code that reads addon credentials.

runzero_describe_addon input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "type"
  ],
  "properties": {
    "type": {
      "enum": [
        "postgres",
        "keycloak",
        "redis",
        "mongodb"
      ],
      "type": "string",
      "description": "Addon type"
    }
  },
  "additionalProperties": false
}
runzero_describe_addon annotations
{
  "title": "Describe addon",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_get_legal_profile — Get legal profile
Advertised by the server during the last successful anonymous check.
Advertised read-only

Get the user's saved legal profile (their Impressum details: name/company, address, contact, and for a company the representative, register and VAT id). Read this BEFORE asking the user for Impressum data, so you reuse what they already gave and only ask for what is missing. Returns the profile (or null) and imprintReady = whether it has the §5 DDG minimum.

runzero_get_legal_profile input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {},
  "additionalProperties": false
}
runzero_get_legal_profile annotations
{
  "title": "Get legal profile",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
runzero_set_legal_profile — Save legal profile
Advertised by the server during the last successful anonymous check.
Advertised destructive

Save or update the user's legal profile so it is reused across their apps and the legal pages can be regenerated. Send only what the user actually provided; omitted fields are cleared. NEVER invent legal data.

runzero_set_legal_profile input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "city": {
      "type": "string",
      "description": "City"
    },
    "email": {
      "type": "string",
      "description": "Contact e-mail"
    },
    "phone": {
      "type": "string",
      "description": "Contact phone (optional)"
    },
    "vatId": {
      "type": "string",
      "description": "VAT id / USt-IdNr., if any"
    },
    "street": {
      "type": "string",
      "description": "Street + house number"
    },
    "country": {
      "type": "string",
      "description": "ISO country code, default DE"
    },
    "legalName": {
      "type": "string",
      "description": "Name or company incl. legal form"
    },
    "entityType": {
      "enum": [
        "person",
        "company"
      ],
      "type": "string",
      "description": "'person' or 'company'"
    },
    "postalCode": {
      "type": "string",
      "description": "Postal code"
    },
    "represented": {
      "type": "string",
      "description": "Represented by / Geschäftsführer (company)"
    },
    "registerCourt": {
      "type": "string",
      "description": "Register court (company)"
    },
    "registerNumber": {
      "type": "string",
      "description": "Register number (company)"
    },
    "supervisoryAuthority": {
      "type": "string",
      "description": "Chamber / supervisory authority (regulated trades)"
    }
  },
  "additionalProperties": false
}
runzero_set_legal_profile annotations
{
  "title": "Save legal profile",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not advertised

No resource definitions available.

90-day uptime

A lightweight connection check about every six hours, sampled on hosts with many listings. It shows the server answered, not that its tools work.

Too few checks for a percentage yet (2 of 2 answered).

  1. 2026-11-07: 2 of 2 checks answered

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
1674 ms
95th percentile latency
1674 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 1674 ms · metadata changed · 50 tool(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http run-zero-mcp https://api.run-zero.de/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add run-zero-mcp --url https://api.run-zero.de/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable run-zero-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "run-zero-mcp": {
      "url": "https://api.run-zero.de/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "run-zero-mcp": {
      "type": "streamableHttp",
      "url": "https://api.run-zero.de/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start run-zero-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "run-zero-mcp": {
      "type": "http",
      "url": "https://api.run-zero.de/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http run-zero-mcp https://api.run-zero.de/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://api.run-zero.de/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "run-zero-mcp": {
      "serverUrl": "https://api.run-zero.de/mcp"
    }
  }
}

Let your agent find its tools

Find servers like run.zero MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Connect Koskamo Explore workflows
See all 621

Do you run run.zero MCP?

Prove ownership with a DNS record, a well-known file, or your Official MCP Registry entry, and your edits publish immediately. Proofs are re-checked weekly; admins can still hide or remove a listing.

Claim this listing