# Coolify

> Deploy to your own server from an agent — the self-hosted answer to Vercel and Railway.

[Canonical HTML page](https://top-mcps.com/mcp/coolify) · [server.json](https://top-mcps.com/mcp/coolify.json) · [methodology](https://top-mcps.com/about/methodology)

## Install

### Claude Desktop — `claude_desktop_config.json`

Paste under mcpServers. Fully quit and reopen Claude after editing.

```json
{
  "mcpServers": {
    "coolify": {
      "command": "npx",
      "args": [
        "-y",
        "coolify-mcp-server@latest"
      ],
      "env": {
        "COOLIFY_BASE_URL": "${COOLIFY_BASE_URL}",
        "COOLIFY_TOKEN": "${COOLIFY_TOKEN}"
      }
    }
  }
}
```

### Claude Code — `CLI or .mcp.json`

Run from your repo. Commit .mcp.json to share with your team.

```shell
# export COOLIFY_BASE_URL=https://coolify.example.com
# export COOLIFY_TOKEN=your_coolify_api_token
claude mcp add coolify -- npx -y coolify-mcp-server@latest
```

### Cursor — `.cursor/mcp.json`

Global path: ~/.cursor/mcp.json. Reload window after editing.

```json
{
  "mcpServers": {
    "coolify": {
      "command": "npx",
      "args": [
        "-y",
        "coolify-mcp-server@latest"
      ],
      "env": {
        "COOLIFY_BASE_URL": "${COOLIFY_BASE_URL}",
        "COOLIFY_TOKEN": "${COOLIFY_TOKEN}"
      }
    }
  }
}
```

### VS Code — `.vscode/mcp.json`

VS Code uses the "servers" key (not "mcpServers").

```jsonc
{
  "servers": {
    "coolify": {
      "command": "npx",
      "args": [
        "-y",
        "coolify-mcp-server@latest"
      ],
      "env": {
        "COOLIFY_BASE_URL": "${COOLIFY_BASE_URL}",
        "COOLIFY_TOKEN": "${COOLIFY_TOKEN}"
      }
    }
  }
}
```

### Windsurf — `~/.codeium/windsurf/mcp_config.json`

Open via Cascade → hammer icon → Configure.

```json
{
  "mcpServers": {
    "coolify": {
      "command": "npx",
      "args": [
        "-y",
        "coolify-mcp-server@latest"
      ],
      "env": {
        "COOLIFY_BASE_URL": "${COOLIFY_BASE_URL}",
        "COOLIFY_TOKEN": "${COOLIFY_TOKEN}"
      }
    }
  }
}
```

### Cline — `cline_mcp_settings.json`

Open via the Cline sidebar → MCP Servers → Edit.

```json
{
  "mcpServers": {
    "coolify": {
      "command": "npx",
      "args": [
        "-y",
        "coolify-mcp-server@latest"
      ],
      "env": {
        "COOLIFY_BASE_URL": "${COOLIFY_BASE_URL}",
        "COOLIFY_TOKEN": "${COOLIFY_TOKEN}"
      }
    }
  }
}
```

### Continue — `~/.continue/config.json`

Continue uses modelContextProtocolServers with a transport block.

```json
{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "npx",
          "args": [
            "-y",
            "coolify-mcp-server@latest"
          ],
          "env": {
            "COOLIFY_BASE_URL": "${COOLIFY_BASE_URL}",
            "COOLIFY_TOKEN": "${COOLIFY_TOKEN}"
          }
        }
      }
    ]
  }
}
```

### Codex CLI — `~/.codex/config.toml`

Codex uses TOML. Each server is a [mcp_servers.<name>] subtable.

```shell
# ~/.codex/config.toml
[mcp_servers.coolify]
command = "npx"
args = [
  "-y",
  "coolify-mcp-server@latest",
]
env = { COOLIFY_BASE_URL = "${COOLIFY_BASE_URL}", COOLIFY_TOKEN = "${COOLIFY_TOKEN}" }
```

### Zed — `~/.config/zed/settings.json`

Zed calls them "context_servers". Settings live-reload on save.

```jsonc
{
  "context_servers": {
    "coolify": {
      "command": {
        "path": "npx",
        "args": [
          "-y",
          "coolify-mcp-server@latest"
        ]
      },
      "env": {
        "COOLIFY_BASE_URL": "${COOLIFY_BASE_URL}",
        "COOLIFY_TOKEN": "${COOLIFY_TOKEN}"
      }
    }
  }
}
```

### ChatGPT — `ChatGPT → Apps directory`

Coolify doesn't ship a hosted HTTPS endpoint today. ChatGPT supports remote MCP servers only — to use this server in ChatGPT you'll need to deploy it to a public HTTPS URL first (e.g. via Cloudflare Workers or Vercel) or wait for an official remote build.

```none

```

## At a glance

- **Maintainer:** Community (wrediam)
- **Transport:** stdio
- **Auth model:** API key
- **Required secrets:** COOLIFY_BASE_URL, COOLIFY_TOKEN
- **Supported clients:** Claude, Cursor, VS Code, Windsurf, Any MCP-compatible client, Coolify v4 instances
- **License:** MIT
- **Language:** TypeScript
- **Latest version:** latest
- **Last verified:** 2026-09-17
- **GitHub stars:** 46 (fetched 2026-10-15T10:09:13.494Z)
- **Score:** 67/100 (rubric 2026-09 — see https://top-mcps.com/about/methodology)
- **Source:** https://github.com/wrediam/coolify-mcp-server
- **Homepage:** https://coolify.io/

## Tools & permissions

| Tool | Description | Args | Side effects |
|------|-------------|------|--------------|
| `create_public_application` | Create an application from a public Git repository. | `—` | write |
| `create_private_github_app_application` | Create an application from a private repo via a GitHub App. | `—` | write |
| `create_dockerfile_application` | Create an application from a Dockerfile, no Git required. | `—` | write |
| `create_dockercompose_application` | Create an application from a Docker Compose file. | `—` | write |
| `get_application` | Return one application by UUID. | `—` | read |
| `update_application` | Update an application by UUID. | `—` | write |
| `delete_application` | Delete an application by UUID. | `—` | write |
| `start_application` | Start an application. | `—` | write |
| `stop_application` | Stop a running application. | `—` | write |
| `restart_application` | Restart an application. | `—` | write |
| `get_application_logs` | Read application logs. | `—` | read |

## Security & scope

- **Access scope:** read-write
- **Sandbox:** No sandbox. The token addresses a live Coolify instance and everything it manages.
- **Gotchas:**
  - `delete_application` is immediate and takes only a UUID. There is no confirmation and no soft delete.
  - A Coolify API token is instance-wide — it reaches every project and server that instance controls, not one app.
  - Tool names and required arguments were read from a probe with placeholder credentials. A real instance may expose additional tools; treat this list as a lower bound.

## Quick answer

**What it does.** Exposes the Coolify v4 API as MCP tools across projects, servers, applications, databases and deployments — application creation in five source flavours, lifecycle control (`start_application`, `stop_application`, `restart_application`), and `get_application_logs`.

**Best for:**
- Deploying to your own VPS from an agent
- Creating apps from a Dockerfile or Compose file
- Restarting and reading logs without SSH
- Self-hosted or EU-data-residency requirements
- Avoiding per-build hosting bills

**Not for:**
- Teams with no server to run Coolify on
- Workflows needing vendor support on the MCP
- Managed-edge workloads (use Cloudflare or Vercel)

## Description

Coolify is the open-source PaaS people run on their own VPS when they want Heroku ergonomics without the per-seat bill or the vendor. This community MCP covers the API: create applications from a public repo, a private repo via GitHub App or deploy key, a Dockerfile, a Docker image or a Compose file; then start, stop, restart, and read logs.

## Why it matters

Every other hosting MCP in this category ties the agent to a vendor's control plane. Coolify is the one that points at infrastructure you own, which is the difference between an agent that can deploy and an agent that can deploy somewhere you can still reach if the vendor changes its mind.

## Key features

- Full v4 API coverage
- Five application source types including Docker Compose
- Lifecycle and log tools
- Points at infrastructure you own
- MIT

## FAQ

### Do I need to host Coolify myself?

Yes. Coolify is software you run on your own VPS; this MCP talks to that instance over its API. If you have no server yet, one of the managed hosts in this category is the faster start.

### Is it Coolify's own MCP?

No — it is a community wrapper around the documented v4 API. Coolify does not publish a first-party MCP server.

### How wide is the token?

Instance-wide. A Coolify API token reaches every project, server and application the instance manages, so treat it like a root credential rather than a per-app key.

## Changelog

- **2026-09-17** — Refreshed install snippets and fact sheet; verified for 2026.