mcp server.md

Render MCP Server — Manage your Render resources from Claude, Codex, and Cursor.

Render's Model Context Protocol (MCP) server enables you to manage your Render infrastructure directly from compatible AI apps, such as Claude Code, Claude Desktop, Codex Desktop, Codex CLI, and Cursor:

[video]

Using natural language prompts, you (and your agents) can:

...and more! For inspiration, see some example prompts.

Model Context Protocol (MCP) is an open standard for connecting AI apps and agents to external tools and data. An MCP server exposes a set of actions that AI apps can invoke to help fulfill relevant user prompts (e.g., "Find all the documents I edited yesterday").

To perform an action, an MCP server often calls an external API, then packages the result into a standardized format for the calling application.

How it works

The Render MCP server is hosted at the following URL:

https://mcp.render.com/mcp

You can configure compatible AI apps (such as Claude Code, Codex, and Cursor) to communicate with this server. When you provide a relevant prompt, your tool intelligently calls the MCP server to execute supported platform actions:

[image: Diagram of using the hosted Render MCP server with Cursor]

In the example diagram above:

  1. A user prompts Cursor to "List my Render services".
  2. Cursor intelligently detects that the Render MCP server supports actions relevant to the prompt.
  3. Cursor directs the MCP server to execute the list_services "tool", which calls the Render API to fetch the corresponding data.

Setup

1. Connect to the MCP server

Authenticating the MCP server grants access to your workspaces and services.

Before proceeding, make sure you're comfortable granting your AI tool access to your Render account. The MCP server supports potentially destructive operations, including modifying a service's environment variables and triggering deploys.

Official Render plugins for Claude Code, Codex, and Cursor configure this server with OAuth automatically. Select your tool below for manual setup or API-key instructions.

Tab: Claude Code

Claude Code setup

Select Render plugin to add the MCP server and Render's skills. For non-interactive environments, select API key instead:

Subtab: Render plugin

  1. In Claude Code, run the following command:
   /plugin install render@claude-plugins-official

  1. Select a scope of access for the plugin.

  2. Run /reload-plugins.

  3. The first time Claude uses the MCP server, it opens an authorization flow in your browser to connect your Render account.

For more details, see the Claude Code plugin documentation.

Subtab: API key

  1. Create an API key from your Account Settings page:

[image: Creating an API key in the Render Dashboard]

  1. Run the following command, substituting your API key where indicated:
   claude mcp add --transport http render https://mcp.render.com/mcp --header "Authorization: Bearer <YOUR_API_KEY>"

You can include the --scope flag to specify where this MCP configuration is stored. For more details, see the Claude Code MCP documentation.

Tab: Claude Desktop

Claude Desktop setup

Select OAuth to sign in through your browser, or API key to authenticate in non-interactive environments:

Subtab: OAuth

  1. In Claude Desktop, navigate to Customize > Connectors.

  2. Search for the Render connector, then click Connect.

  3. Complete the authorization flow in your browser.

For more details, see the Claude Desktop connector documentation.

Subtab: API key

  1. Create an API key from your Account Settings page:

[image: Creating an API key in the Render Dashboard]

  1. Add the configuration below to your Claude Desktop MCP settings. By default, this file is located at the following paths based on your operating system:
   {
     "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>"
         }
       }
     }
   }

Replace <YOUR_API_KEY> with your API key.

For more details, see the Claude Desktop MCP documentation.

Tab: Codex

Codex Desktop and CLI setup

Select OAuth to sign in through your browser, or API key to authenticate in non-interactive environments:

Subtab: OAuth

  1. Run the following command:
   codex mcp add render --url https://mcp.render.com/mcp --oauth-client-id codex
  1. Complete the authorization flow in your browser to connect your Render account.

For more details, see the Codex MCP documentation.

Subtab: API key

  1. Create an API key from your Account Settings page:

[image: Creating an API key in the Render Dashboard]

  1. Add the following configuration to Codex's config file, ~/.codex/config.toml:
   [mcp_servers.render]
   url = "https://mcp.render.com/mcp"
   http_headers = { Authorization = "Bearer <YOUR_API_KEY>" }

Replace <YOUR_API_KEY> with your API key.

For more details, see the Codex MCP documentation.

Tab: Cursor

Cursor setup

Select Render plugin to add the MCP server and Render's skills. For non-interactive environments, select API key instead:

Subtab: Render plugin

  1. In a Cursor agent window, run:
   /add-plugin render

  1. Select the scope of access for the plugin, then click Add plugin.

  2. Cursor prompts you to click Authenticate to finish the authorization flow in your browser.

For more details, see the Cursor MCP documentation.

Subtab: API key

  1. Create an API key from your Account Settings page:

[image: Creating an API key in the Render Dashboard]

  1. Add the following configuration to ~/.cursor/mcp.json:
   {
     "mcpServers": {
       "render": {
         "url": "https://mcp.render.com/mcp",
         "headers": {
           "Authorization": "Bearer <YOUR_API_KEY>"
         }
       }
     }
   }

Replace <YOUR_API_KEY> with your API key.

For more details, see the Cursor MCP documentation.

Tab: Other tools

Setup for other apps

See the documentation for other popular AI apps:

2. Set your workspace

To start using the Render MCP server, you first tell your AI app which Render workspace to operate in. Each MCP server action is scoped to the selected workspace.

You can set your workspace with a prompt like:

Set my Render workspace to [WORKSPACE_NAME]

[image: Selecting an active Render workspace in Cursor]

If you don't set your workspace, your app usually directs you to specify one if you submit a prompt that uses the MCP server (such as List my Render services):

[image: Selecting an active Render workspace in Cursor]

With your workspace set, you're ready to start prompting! Get started with some example prompts.

Example prompts

Your AI app can use the Render MCP server to perform a wide variety of platform actions. Here are some basic example prompts to get you started:

Service creation

Create a new database named user-db with 5 GB storage

Deploy an example Flask web service on Render using https://github.com/render-examples/flask-hello-world

Deploys

Redeploy the API service and clear the build cache

Data analysis

Using my Render database, tell me which items were the most frequently bought together

Query my read replica for daily signup counts for the last 30 days

Service metrics

What was the busiest traffic day for my service this month?

What did my service's autoscaling behavior look like yesterday?

Troubleshooting

Pull the most recent error-level logs for my API service

Why isn't my site at example.onrender.com working?

Supported actions

The Render MCP server provides a "tool" for each platform action listed below (organized by resource type). Your AI app (the "MCP host") can combine these tools however it needs to perform the tasks you describe.

For more details on all available tools, see the project README.

Workspaces
Services
Deploys
Logs
Metrics
Render Postgres
Render Key Value

Running locally

We strongly recommend using Render's hosted MCP server instead of running it locally.

The hosted MCP server automatically updates with new capabilities as they're added. Run locally only if required for your use case.

You can install and run the Render MCP server on your local machine as a Docker container, or by running the executable directly:

Tab: Docker image

Docker setup

This method requires docker.

With this configuration, your AI app pulls and runs the Render MCP server as a Docker container.

Add JSON with the format below to your tool's MCP configuration (substitute <YOUR_API_KEY> with your API key):

{
  "mcpServers": {
    "render": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "RENDER_API_KEY",
        "-v",
        "render-mcp-server-config:/config",
        "ghcr.io/render-oss/render-mcp-server"
      ],
      "env": {
        "RENDER_API_KEY": "<YOUR_API_KEY>"
      }
    }
  }
}

The mcpServers key above might differ for specific tools. For example, Zed uses context_servers and GitHub Copilot uses servers. Consult your tool's documentation for details.

Tab: Executable

Local executable setup

With this configuration, your AI app runs the Render MCP server executable directly.

  1. Install the MCP server executable using one of the methods described in Local installation, then return here.

  2. Add JSON with the format below to your tool's MCP configuration (substitute your API key and the path to your MCP server executable):

   {
     "mcpServers": {
       "render": {
         "command": "/path/to/render-mcp-server-executable",
         "env": {
           "RENDER_API_KEY": "<YOUR_API_KEY>"
         }
       }
     }
   }

Local installation

Follow these instructions only if you're running the MCP server locally and without Docker.

We strongly recommend instead using Render's hosted MCP server, because it automatically updates as new capabilities are added.

Tab: Install script

This method requires macOS or Linux.

  1. Run the following curl command:
   curl -fsSL https://raw.githubusercontent.com/render-oss/render-mcp-server/refs/heads/main/bin/install.sh | sh
  1. Note the full path where the install script saved the downloaded executable. The output includes a message like the following:
   ✨ Successfully installed Render MCP Server to /Users/example/.local/bin/render-mcp-server

Tab: Direct download

  1. Open the MCP server's GitHub releases page.

  2. Under the most recent release, download and unzip the executable that corresponds to your system's architecture.

  1. Move the executable to the desired directory and note its full path.

Note for macOS users:

You might need to grant a system exception to run the downloaded executable, because it's from an "unknown developer." Learn more.

Tab: Build from source

We recommend building from source only in the following cases:

  1. Install the Go programming language if you haven't already.

  2. Clone the MCP server repository and build the executable:

   git clone https://github.com/render-oss/render-mcp-server.git
   cd render-mcp-server
   go build

This creates a render-mcp-server executable in the repo's root directory.

  1. Note the full path to the newly built executable.

Limitations

The Render MCP server attempts to minimize exposing sensitive information (like connection strings) to your AI app's context. However, Render does not guarantee that sensitive information will not be exposed. Exercise caution when interacting with secrets in your AI app.

Note the following additional limitations:

Other service types are not yet supported.

Appendix: Glossary definitions
environment variable

Config values you can apply to a service to customize its behavior at build and runtime, such as NODE_VERSION or OPENAI_API_KEY.

Render sets some environment variables for your service by default.

Related article: https://render.com/docs/configure-environment-variables.md

service type

When you deploy code on Render, you select a service type based on the capabilities you need.

For example, you create a web service to host a dynamic web app at a public URL.

Related article: https://render.com/docs/service-types.md

web service

Deploy this service type to host a dynamic application at a public URL.

Ideal for full-stack web apps and API servers.

Related article: https://render.com/docs/web-services.md

static site

Deploy this service type to host a static website (HTML/CSS/JS) over a global CDN at a public URL.

Related article: https://render.com/docs/static-sites.md

cron job

Deploy this service type to execute a command or script on a predefined schedule.

Ideal for intermittent tasks like sending email digests or generating reports.

Related article: https://render.com/docs/cronjobs.md

Render Postgres

Fully managed PostgreSQL databases that support point-in-time recovery, read replicas, high availability, and more.

Related article: https://render.com/docs/postgresql.md

Render Key Value

Fully managed, Redis®-compatible storage ideal for use as a job queue or shared cache.

Related article: https://render.com/docs/key-value.md

instance count

The number of individual instances currently running for a given service. Can be scaled manually or automatically based on resource usage.

Related article: https://render.com/docs/scaling.md

outbound bandwidth

The amount of network traffic you send to destinations outside of Render (HTTP responses, third-party API calls, and so on).

Your workspace receives a monthly included amount of outbound bandwidth. If you exceed this amount, Render bills you for a supplementary amount.

Related article: https://render.com/docs/outbound-bandwidth.md