Render MCP Server Cursor IDE Setup (2026)

How do you connect Render to Cursor? Add a render entry to ~/.cursor/mcp.json pointing at Render's hosted MCP endpoint (https://mcp.render.com/mcp), then authorize either via browser OAuth or an API key from your Render Dashboard. Once connected, Cursor can list and create services, trigger deploys, tail logs, pull metrics, and run read-only queries against Render Postgres — all from chat.

Render's MCP server is workspace-scoped the same way the Render Dashboard is: your account can belong to multiple workspaces (personal plus any teams), and the MCP connection operates against whichever workspace is currently selected. Forget to switch it and you'll get confused answers about "my services" that are actually a teammate's staging environment — not a bug, just an easy first-week mistake.

What the Render MCP Server Can Do

Once connected, typical prompts include:

Unlike Heroku's MCP server (which wraps the full Heroku CLI, including destructive Postgres commands), Render's Postgres tool is explicitly read-only — it can query your database but not modify it. That's a meaningful safety difference if you're deciding which platform's AI tooling to trust with a production database connection.

Prerequisites

Method 1: Browser OAuth (Recommended)

This is the fastest path and needs no key management.

Add this to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "render": {
      "type": "http",
      "url": "https://mcp.render.com/mcp"
    }
  }
}

Restart Cursor. On the first tool call, Cursor opens a browser window for Render's authorization flow — approve it, and the session persists without a secret sitting in your config file. Most tools work through OAuth; if a specific action requires elevated access, Render will prompt for it at that point rather than up front.

Method 2: API Key (For Scripted or Headless Setups)

Use this if you're provisioning Cursor's MCP config from a script, a shared team template, or a machine where an interactive OAuth popup isn't practical.

Step 1: Generate a Render API Key

1. Log in to the Render Dashboard
2. Go to Account Settings → API Keys
3. Generate a new key and copy it immediately

Step 2: Add to ~/.cursor/mcp.json

{
  "mcpServers": {
    "render": {
      "url": "https://mcp.render.com/mcp",
      "auth": {
        "type": "apiKey",
        "apiKey": "<YOUR_RENDER_API_KEY>"
      }
    }
  }
}

An API key carries the same access as your account (or your team's, depending on which workspace it's tied to) — there's no documented way to scope it down to a single service or a read-only role. Treat it like any other account-wide secret: don't commit it, and rotate it if it leaks.

Self-Hosting the Server

Render also publishes the MCP server as open source (render-oss/render-mcp-server on GitHub) with a Docker image and a downloadable binary for teams that want to run it themselves instead of hitting the hosted endpoint. The hosted OAuth and API-key routes above are the documented, supported default for most setups — check that repo directly if self-hosting is a hard requirement for your infra, since install commands there can change independently of this guide.

Restart Cursor and Verify

Quit and reopen Cursor, then test in chat:

List my Render workspaces and current services

Real workspace and service names coming back confirms the connection (and, for OAuth, that you approved the right account).

Available Tool Categories

Practical Workflows

Ship a Hotfix and Confirm It's Live

Trigger a new deploy for api-prod from the latest commit on main, 
then poll deploy status until it's live and tell me how long it took.

Investigate a Spike in Errors

Show me error-level logs for api-prod from the last 30 minutes, then 
check whether CPU or memory usage on the same service spiked around 
the same time.

Sanity-Check Data Before a Support Reply

Run a read-only query against my Postgres instance to check whether 
user ID 48213 has an active subscription, then summarize what you find.

Set Up a New Environment

Create a new web service on the starter plan pointed at my repo's 
staging branch, and list the environment variables it currently has.

When Not to Use This

If your Render usage is a single hobby project you check on manually a few times a month, the OAuth setup is more ceremony than the workflow needs — the Dashboard is faster for occasional glances. This earns its keep once you're context-switching between logs, metrics, and deploys often enough that describing what you want ("why did api-prod's memory spike an hour ago") beats clicking through four Dashboard tabs to find out.

Troubleshooting

OAuth popup never appears
Confirm your Cursor version supports type: "http" remote MCP entries. If it does and nothing happens, check that mcp.render.com isn't blocked on your network, then remove and re-add the server in Cursor's MCP settings to force a fresh authorization attempt.

Tool calls return the wrong workspace's data
Ask Cursor to list your workspaces and set the active one explicitly — Render's MCP server operates against whichever workspace is currently selected, and that selection doesn't always default to the one you expect if your account belongs to more than one.

API key setup returns "unauthorized"
The key was copied incorrectly, revoked, or belongs to a different workspace than the one you're targeting. Regenerate it under Account Settings → API Keys and confirm you're checking the right workspace's services.

Postgres queries fail with a permissions-style error
That's expected for anything that isn't a SELECT. The Postgres tool is read-only by design — there's no write mode to enable, unlike some other database MCP servers.

Frequently Asked Questions

Q: Can the Render MCP server modify my Postgres data, not just read it?
A: No. Render's Postgres tool is read-only — it can run queries to inspect data but has no write, update, or delete capability. That's a deliberate design choice, different from platforms like Heroku whose MCP server exposes the full psql surface including destructive statements.

Q: Do I need to pick between OAuth and an API key, or can I use both?
A: You configure one auth method per mcp.json entry. OAuth is the recommended default for interactive use since there's no secret to store; use an API key instead for automated or scripted environments where a browser popup isn't practical.

Q: What happens if my account belongs to multiple Render workspaces?
A: The MCP server operates against whichever workspace is currently active for the connection. Use the workspace-listing and workspace-setting tools to check and switch before running commands, especially right after connecting for the first time.

Q: Is there a way to scope an API key to just one service?
A: Not currently documented. A Render API key carries the same access as the account or team it belongs to across all services in that workspace. For a narrower blast radius, create the key from a team member account with limited workspace access rather than your primary account.

Q: Can I self-host the MCP server instead of using Render's hosted endpoint?
A: Yes — it's open source at render-oss/render-mcp-server with a Docker image and downloadable binary. Most teams should start with the hosted OAuth or API-key routes above; self-hosting is worth it mainly if your infra requires running the process yourself.

Q: How does this compare to Fly.io's MCP server?
A: Both are platform-native (CLI-embedded on Fly's side, hosted-endpoint-first on Render's) rather than third-party wrappers, but the tool surfaces diverge — Fly's covers Machines, volumes, and certs directly, while Render's centers on services, deploys, and its read-only Postgres tool. See the Fly.io MCP server setup guide if you're weighing both platforms.

Related Guides

---