---
name: coolify-api-mcp
description: Inspect and operate the complete Coolify REST API through the mm-skills Coolify MCP, including servers, projects, environments, applications, services, databases, deployments, teams, GitHub Apps, cloud tokens, private-key metadata, Hetzner resources, backups, environment-variable metadata, and system operations. Use when an agent must understand or manage a self-hosted Coolify instance beyond the ten read-only tools provided by Coolify's built-in MCP. The default instance is panel.meyermedia.eu. All returned secret fields are redacted, while deployments, writes, destructive actions, root operations, logs, and sensitive reads remain behind separate server-side gates.
compatibility: Requires Node.js 20 or newer for local stdio use, or the hosted Streamable HTTP endpoint. Requires a team-scoped Coolify API token supplied through server environment variables, never chat or repository files.
license: Apache-2.0
---

# Coolify API MCP

Use the custom mm-skills MCP when Coolify's built-in read-only MCP does not expose enough infrastructure or API coverage.

The hosted server defaults to:

```text
Coolify API: https://panel.meyermedia.eu/api/v1
MCP path:    /mcp on the deployed mm-skills application
```

Do not confuse the custom MCP with Coolify's built-in `https://panel.meyermedia.eu/mcp` endpoint.

## Core behavior

- Load the current Coolify OpenAPI document and expose every operation as a direct MCP tool in expanded mode.
- Keep `coolify_api_search`, `coolify_api_describe`, and `coolify_api_call` available for catalog-driven use.
- Keep `coolify_api_request` as a path-restricted fallback for endpoints added before the OpenAPI cache refreshes.
- Never accept an arbitrary upstream origin. Requests stay below the configured `COOLIFY_BASE_URL`.
- Recursively redact passwords, tokens, private keys, environment values, webhook secrets, credentials in URLs, authorization headers, and recognizable secret patterns in logs.
- Never print, persist, or return the Coolify API token or the MCP access token.
- Treat tool availability as capability, not authorization.

Read [references/security.md](references/security.md) before changing token scopes or enabling any non-read gate.
Read [references/deployment.md](references/deployment.md) before hosting or updating the MCP on Coolify.
Read [references/api-coverage.md](references/api-coverage.md) when investigating missing or newly added Coolify operations.

## Preferred workflow

1. Call `coolify_api_status`.
2. Confirm the API base is `https://panel.meyermedia.eu/api/v1`, authentication is configured, and the OpenAPI catalog loaded successfully.
3. Use `coolify_infrastructure_snapshot` for a broad team-scoped map.
4. Search with `coolify_api_search` instead of guessing endpoint paths.
5. Inspect the selected operation with `coolify_api_describe` before supplying parameters or a request body.
6. Prefer the generated direct tool or `coolify_api_call` over the raw request tool.
7. Verify resource UUIDs immediately before a write or deployment action.
8. State the expected impact and rollback path before enabling or invoking any non-read operation.
9. Re-read the affected resource after the action and report the observed state, not only the API acknowledgement.

## Permission model

The server separates capabilities into independent gates:

| Capability | Environment gate | Default |
| --- | --- | --- |
| Metadata reads | `COOLIFY_API_TOKEN` with `read` | Enabled when token exists |
| Sensitive/full reads | `COOLIFY_SENSITIVE_TOKEN`, `COOLIFY_MCP_ALLOW_SENSITIVE_READS=true`, optionally `COOLIFY_MCP_FULL_READ=true` | Disabled |
| Deploy/start/restart actions | `COOLIFY_MCP_ALLOW_DEPLOY=true` | Disabled |
| Create/update actions | `COOLIFY_MCP_ALLOW_WRITES=true` | Disabled |
| Delete/stop/cancel/disable actions | `COOLIFY_MCP_ALLOW_DESTRUCTIVE=true` | Disabled |
| API/MCP root administration | `COOLIFY_MCP_ALLOW_ROOT=true` plus the relevant action gate | Disabled |

Every non-read call also requires the exact confirmation string returned by `coolify_api_describe`:

```text
CONFIRM <operationId>
```

Do not ask for or handle token values in conversation. Tell the operator which environment-variable name and Coolify permission are required.

## Read-only inspection

For normal inspection, use a token with only `read`. This exposes team-scoped infrastructure metadata while Coolify itself omits fields guarded by `read:sensitive`.

Use these tools first:

- `coolify_infrastructure_snapshot`
- `coolify_api_search`
- generated `coolify_list_*` and `coolify_get_*` tools
- `coolify_api_describe`

Environment-variable endpoints may be inspected for names and metadata; their values must remain redacted.
Private-key, cloud-token, GitHub-App, and credential endpoints may return identifiers and non-secret metadata only.

## Complete reads without secret output

Coolify groups environment values, private keys, passwords, logs, and Compose content under `read:sensitive`. When a complete view is required:

1. Use a separate token in `COOLIFY_SENSITIVE_TOKEN` with `read` and `read:sensitive`.
2. Give that token only the minimum team and expiration needed.
3. Set `COOLIFY_MCP_ALLOW_SENSITIVE_READS=true` only on the isolated MCP deployment.
4. Set `COOLIFY_MCP_FULL_READ=true` when every read should use the complete upstream view.
5. Keep recursive redaction enabled and treat it as defense in depth.

Without full-read mode, the sensitive token is used only for operations whose paths or operation IDs indicate logs, environment variables, private keys, cloud tokens, credentials, secrets, Compose content, or detailed deployment output.

## Writes and deployments

A user request to inspect or diagnose does not authorize deployment or mutation.

Before a non-read call:

1. Confirm the exact target UUID, team, project, environment, and current state.
2. Read the operation schema.
3. Explain the smallest intended change.
4. Verify the matching server-side gate is enabled.
5. Supply the exact confirmation string.
6. Re-read the target and deployment state after completion.

Keep destructive and root gates off in the general-purpose MCP. Run a separate short-lived administrative deployment when those capabilities are unavoidable.

## Raw API fallback

Use `coolify_api_request` only when:

- the current Coolify version exposes an endpoint absent from the loaded OpenAPI document;
- the operation catalog failed to refresh; or
- primary Coolify documentation confirms the endpoint and method.

The raw tool still enforces origin confinement, permission classification, confirmation, response-size limits, timeouts, and redaction.

Never place query strings in the path. Use the `query` object.
Never send authorization headers through tool arguments.

## Reporting

Return:

1. Coolify origin and team scope used;
2. operation ID, method, and path;
3. resource UUIDs affected;
4. redacted response status and decisive fields;
5. whether any capability gate was required;
6. verification after the call;
7. remaining risk or manual action.

Never claim access to a secret value. A redacted field proves only that a field existed, not that its value was validated.