Skip to main content
hc
Submit
3 compared

Hosting & deployment MCP servers compared

Hosting and deployment MCP servers that let Claude ship apps, compared on trust, platforms, and setup.

Open in the interactive comparison tool
FieldRender MCP Server

The official Render MCP server lets LLMs manage Render resources: create and manage web services, static sites, cron jobs, Postgres and Key-Value instances, monitor deploys, query logs and metrics, and run read-only SQL against Render Postgres.

Open dossier 		Heroku MCP Server for Claude

Official Heroku Platform MCP server that connects Claude and other MCP clients to Heroku apps, dynos, add-ons, pipelines, Private Spaces, maintenance mode, logs, deployments, one-off dynos, Heroku Postgres, and optional Heroku AI tools through the Heroku CLI.

Open dossier 		Coolify MCP Server

MCP server for Coolify infrastructure management, diagnostics, deployments, logs, projects, environments, applications, databases, services, env vars, storage, scheduled tasks, private keys, cloud tokens, teams, and docs search.

Open dossier
Trust
Install riskReview firstReview firstReview first
Notes Safety ✓ Privacy ✓ Safety ✓ Privacy ✓ Safety ✓ Privacy ✓
Categorymcpmcpmcp
Sourcesource-backedsource-backedsource-backed
Authorrender-ossHerokuStuart Mason
Added2026-06-112026-06-042026-06-06
Platforms
Claude CodeClaude Desktop
Claude CodeClaude Desktop
Claude CodeClaude Desktop
Source repo———
Safety notes✓Write-capable: tools can create and modify real Render infrastructure — create_web_service, create_static_site, create_cron_job, create_postgres, create_key_value, and update_environment_variables provision or change live resources that may incur billing. update_environment_variables replaces the complete environment variable set for a service; an incomplete array can drop existing variables. Created services run build and start commands you supply; treat generated commands as code execution on Render's platform. The server reaches Render's API over the network; the hosted option (https://mcp.render.com/mcp) sends your requests through Render's hosted MCP endpoint. Review and confirm tool calls before approving them, since an LLM can issue provisioning or env-var changes on your behalf.✓Heroku documents the server as early development, and the available functionality and tools may evolve. Re-check the Dev Center page and repo before using it for production-sensitive workflows. Prefer `heroku mcp:start` because it uses the current Heroku CLI authentication context and avoids placing a Heroku API token directly in MCP client configuration. The server can perform account-write and production-impacting operations: creating and renaming apps, transferring apps, deploying projects, running one-off dynos, scaling and restarting dynos, provisioning add-ons, toggling maintenance mode, creating and promoting pipelines, and managing Private Space resources. Heroku Postgres tools can execute SQL, inspect active queries and locks, manage credentials, terminate database processes, manage backups, and start upgrades. Treat those tools as database administration capabilities, not read-only observability. `deploy_one_off_dyno` can execute generated code or commands on a Heroku one-off dyno with file creation, network access, environment variables, and automatic cleanup. Do not run unreviewed code from prompts, issues, pull requests, or third-party repositories. The server does not document a global read-only mode. Limit the Heroku account, team, app, pipeline, and database permissions available to the MCP client before connecting it to an assistant. Cost-bearing operations such as app creation, dyno scaling, add-on provisioning, one-off dynos, AI model provisioning, database backups, and database upgrades should require explicit human approval and a clear target app or team. Use staging apps, disposable review apps, narrow Heroku teams, and short-lived authorization tokens before allowing an agent near production apps, production databases, Shield Spaces, or regulated workloads.✓Coolify MCP Server can start, stop, restart, redeploy, cancel deployments, update env vars, create or delete projects, environments, applications, databases, services, backups, storages, scheduled tasks, private keys, GitHub apps, and cloud tokens depending on API permissions. Batch tools such as `restart_project_apps`, `bulk_env_update`, `stop_all_apps`, and `redeploy_project` can affect multiple production services at once. Deployment, control, backup, storage, private key, cloud token, GitHub app, and scheduled-task operations should require explicit confirmation. Custom `--header` values may carry auth-proxy secrets; never let an agent invent, log, or modify them casually. Test on non-production projects or staging resources before allowing Claude to operate live Coolify infrastructure.
Privacy notes✓Authentication uses a RENDER_API_KEY scoped to your Render workspace(s); anyone with the key can manage those resources. Keep it in a server-scoped header or server-scoped env block, not a top-level/global env block shared with other MCP servers. query_render_postgres runs SQL against your Render Postgres and returns row data to the LLM — query results may include sensitive application data. Logs and metrics tools (list_logs, list_log_label_values, get_metrics) surface application log contents and performance data to the model. update_environment_variables and service details can expose configuration values; avoid sending secrets you don't want the model to see. When using the hosted server, requests transit Render's hosted MCP infrastructure rather than staying entirely local.✓Tool results can expose Heroku account context, team names, app names, regions, stack and runtime details, dyno names, process types, add-ons, pipeline names, Private Space names, database identifiers, logs, SQL text, query output, query plans, credentials metadata, backup metadata, and deployment details. `HEROKU_API_KEY` is an authorization token for the Heroku account context that created it. Keep it out of prompts, screenshots, shell history, repository files, shared MCP configs, and client logs. The preferred CLI-auth flow still grants the MCP server whatever access the local Heroku CLI session has. Review the active Heroku account before connecting the server to a client. App logs and deployment output can include request data, error traces, customer identifiers, webhook payloads, add-on connection hints, and secrets accidentally printed by application code. Postgres query results, backup output, locks, active queries, credential metadata, and upgrade output can contain sensitive schema names, tenant records, operational metadata, and personally identifiable information. Client-side transcripts, MCP debug logs, Heroku CLI output, VS Code debug settings, and assistant conversations may retain Heroku account and database details outside Heroku.✓Coolify access tokens, base URLs, custom headers, application UUIDs, server IPs, domains, logs, env vars, deployment logs, private keys, cloud-provider tokens, GitHub app data, team membership, backups, database metadata, and service configuration can be exposed to the MCP client. Application and deployment logs may contain secrets, customer data, build output, container metadata, private repository details, and runtime errors. Environment variable and cloud-token tools can reveal or mutate sensitive infrastructure credentials. Documentation search is local to the server, but Coolify API calls contact the configured Coolify instance. Keep tokens and auth-proxy headers in local MCP client configuration only, and avoid sharing transcripts that include infrastructure identifiers or logs.
Prerequisites
  • A Render account
  • A Render API key created from Account Settings (dashboard.render.com/u/settings)
  • An MCP-compatible client (e.g. Claude Desktop, Cursor)
  • For the local binary only: the unzipped release executable, or Go to build from source
  • Heroku account with access to the apps, teams, pipelines, Private Spaces, add-ons, Heroku Postgres databases, or AI resources Claude should inspect or manage.
  • Heroku CLI 10.8.1 or later installed globally and authenticated with the intended Heroku account.
  • Node.js 20 or later when running the npm package directly with `npx -y @heroku/mcp-server`.
  • MCP-capable client configuration for Claude Desktop, Cursor, VS Code, Zed, Windsurf, Cline, Trae, or another stdio-compatible client.
  • Running Coolify instance with API access enabled.
  • Coolify API access token scoped to the resources Claude may inspect or manage.
  • Node.js 20 or newer for the published npm server.
  • Review of which servers, projects, applications, databases, services, deployments, env vars, private keys, teams, cloud tokens, and scheduled tasks the token can access.
Install
# Recommended: use Render's hosted MCP server (no local install required).
# Optional local binary — download from GitHub Releases, then point your
# MCP client at the unzipped executable:
#   https://github.com/render-oss/render-mcp-server/releases

heroku mcp:start
npx -y @masonator/coolify-mcp
Config
// Hosted server (recommended) — HTTP clients such as Cursor / Windsurf:
{
  "mcpServers": {
    "render": {
      "url": "https://mcp.render.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}

// Hosted server for Claude Desktop via mcp-remote; env is scoped to render only:
{
  "mcpServers": {
    "render": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.render.com/mcp",
        "--header",
        "Authorization: Bearer ${RENDER_API_KEY}"
      ],
      "env": {
        "RENDER_API_KEY": "<YOUR_API_KEY>"
      }
    }
  }
}

// Local binary alternative (stdio transport); env is scoped to render only:
{
  "mcpServers": {
    "render": {
      "command": "/path/to/render-mcp-server",
      "args": ["--transport", "stdio"],
      "env": {
        "RENDER_API_KEY": "<YOUR_API_KEY>"
      }
    }
  }
}

{
  "mcpServers": {
    "heroku": {
      "command": "npx",
      "args": ["-y", "@heroku/mcp-server"],
      "env": {
        "HEROKU_API_KEY": "<YOUR_HEROKU_AUTH_TOKEN>",
        "MCP_SERVER_REQUEST_TIMEOUT": "30000"
      }
    }
  }
}
{
  "mcpServers": {
    "coolify": {
      "command": "npx",
      "args": [
        "-y",
        "@masonator/coolify-mcp"
      ],
      "env": {
        "COOLIFY_BASE_URL": "https://your-coolify-instance.example",
        "COOLIFY_ACCESS_TOKEN": "your-api-token"
      },
      "type": "stdio"
    }
  }
}
Citations
ClaimUnclaimedUnclaimedUnclaimed
More comparisons, weekly

A short, calm digest of reviewed Claude resources. Unsubscribe any time.