# Claude Code + Render: Deploy and manage your Render apps from Claude Code.

[Claude Code](https://docs.anthropic.com/en/docs/claude-code) is Anthropic's terminal-based coding agent. Paired with Render, it can deploy web services, create Render Postgres databases, inspect logs and metrics, update environment variables, and help plan infrastructure changes from your shell. The combination is well-suited to long-running production apps: Render's managed infrastructure, real Postgres with HA and read replicas, persistent disks, background workers, no cold starts, and `render.yaml` Blueprints for infrastructure-as-code mean Claude has stable surfaces to act against.

## Agent details

- Agent: Claude Code
- Short name: Claude
- Vendor: Anthropic
- Docs: [Claude Code docs](https://docs.anthropic.com/en/docs/claude-code)
- Install: `npm install -g @anthropic-ai/claude-code`
- Start: `claude`
- Skills mode: Agent-invoked

## Quick start

1. *Install Claude Code globally.*

   ```shell
   npm install -g @anthropic-ai/claude-code
   ```

2. *Add the Render MCP server to Claude Code.* Generate an API key in your [account settings](https://dashboard.render.com/u/settings#api-keys), then run:

   ```shell
   claude mcp add --transport http render https://mcp.render.com/mcp --header "Authorization: Bearer $RENDER_API_KEY"
   ```

3. *Install Render's official skills* so Claude knows how to deploy, debug, and monitor:

   ```shell
   npx skills add render-oss/skills
   ```

   The installer auto-detects Claude Code and installs the right files in `~/.claude/skills/`. If you already have the [Render CLI](cli) installed, `render skills install` works too. See the Render skills section below for both options.

4. *Start Claude Code.*

   ```shell
   claude
   ```

5. *Set your Render workspace.* If your Render account has multiple workspaces, tell Claude which one to operate against. For example, *"Set my Render workspace to `<YOUR_WORKSPACE_NAME>`."*

6. *Deploy a template.* Try a prompt like *"Deploy the Next.js + Postgres template from render.com/templates and walk me through any choices."*

## Quick links

- [Skills on GitHub](https://github.com/render-oss/skills)
- [MCP Server on GitHub](https://github.com/render-oss/render-mcp-server)
- [The Render CLI docs](cli)
- [Claude Code docs](https://docs.anthropic.com/en/docs/claude-code)

## MCP configuration

The `claude mcp add` command from Quick start writes an entry into `~/.claude.json`.

- MCP install command: `claude mcp add --transport http render https://mcp.render.com/mcp --header "Authorization: Bearer $RENDER_API_KEY"`
- MCP config file: `~/.claude.json`
- OAuth: Not supported yet

The equivalent JSON looks like this:

```json:~/.claude.json
{
  "mcpServers": {
    "render": {
      "type": "http",
      "url": "https://mcp.render.com/mcp",
      "headers": {
        "Authorization": "Bearer $RENDER_API_KEY"
      }
    }
  }
}
```

> The Render MCP server currently uses *API-key authentication*. Generate a key in your [account settings](https://dashboard.render.com/u/settings#api-keys) and pass it as a `Bearer` token. OAuth support is on the roadmap.

For full setup details, including troubleshooting, scoping a key to a single workspace, and the complete tool reference, see the [Render MCP server repo](https://github.com/render-oss/render-mcp-server) and the [MCP server docs page](mcp-server).

The prompts below can use a combination of MCP tools, Render skills, the Render CLI, and guided Dashboard or API steps.

## Example prompts

- *Deploy:* Deploy this project to Render.
- *Data:* Create a Render Postgres database and wire DATABASE_URL to my web service.
- *Debug:* Check the deploy logs for the last failed deploy and fix the error.
- *Scale:* Review my service's scaling settings and recommend the safest path to autoscaling at 70% CPU.
- *Domain:* Set up a custom domain with SSL for app.example.com.
- *Blueprint:* Create separate staging and production environments using a render.yaml Blueprint.
- *AI app:* Deploy an AI chatbot with Postgres for chat history and a background worker for embeddings.
- *Template:* Set up n8n with Postgres and a persistent disk on Render.
- *SaaS:* Deploy a Next.js SaaS starter with Auth.js and Stripe webhooks.
- *Workflows:* Set up a Workflow to orchestrate my data pipeline with retries and subtasks.

## Render skills

Render's official *skills* give Claude Code the procedural know-how to deploy services, debug failed builds, run read-only database queries, and manage infrastructure changes. Skills are agent-invoked `SKILL.md` files that Claude Code picks automatically based on your prompt. They can combine MCP tools with the Render CLI, local code edits, and Dashboard or API guidance for workflows that MCP alone doesn't cover.

### Install skills

**npx (no setup)**

```shell
npx skills add render-oss/skills
```

Works without the Render CLI installed. The installer detects supported tools on your system (Claude Code, Codex, Cursor, OpenCode) and prompts you to select which skills to install.

**The Render CLI**

> *Requires version 2.10 or later of the [Render CLI](cli).*
>
> Check your current version with `render --version`.

```shell
render skills install
```

Use this if you already have the Render CLI on your system. It's the same flow as the `npx` installer, just routed through the CLI.

### Skills catalog

- [render-background-workers](https://github.com/render-oss/skills/blob/main/skills/render-background-workers/SKILL.md): Sets up and configures background workers on Render for queue-based job processing.
- [render-blueprints](https://github.com/render-oss/skills/blob/main/skills/render-blueprints/SKILL.md): Authors and validates render.yaml Blueprints for Render infrastructure.
- [render-cli](https://github.com/render-oss/skills/blob/main/skills/render-cli/SKILL.md): Installs and uses the Render CLI for deploys, logs, SSH, psql, Blueprint validation, and automation.
- [render-cron-jobs](https://github.com/render-oss/skills/blob/main/skills/render-cron-jobs/SKILL.md): Configures and troubleshoots scheduled tasks on Render using cron job services.
- [render-debug](https://github.com/render-oss/skills/blob/main/skills/render-debug/SKILL.md): Debug failed Render deployments by analyzing logs, metrics, and database state.
- [render-deploy](https://github.com/render-oss/skills/blob/main/skills/render-deploy/SKILL.md): Deploy applications to Render by analyzing codebases, generating render.yaml Blueprints, and providing Dashboard deeplinks.
- [render-disks](https://github.com/render-oss/skills/blob/main/skills/render-disks/SKILL.md): Attaches and manages persistent disks on Render services—mount paths, sizing, snapshots, file transfers, and single-instance constraints.
- [render-docker](https://github.com/render-oss/skills/blob/main/skills/render-docker/SKILL.md): Builds and deploys Docker containers on Render—Dockerfiles, multi-stage builds, Blueprint Docker fields, private registries, layer caching, and platform constraints.
- [render-domains](https://github.com/render-oss/skills/blob/main/skills/render-domains/SKILL.md): Configures custom domains and TLS certificates on Render—DNS setup, CNAME records, apex domains, wildcard domains, and certificate troubleshooting.
- [render-env-vars](https://github.com/render-oss/skills/blob/main/skills/render-env-vars/SKILL.md): Configures environment variables, secrets, and env groups on Render.
- [render-keyvalue](https://github.com/render-oss/skills/blob/main/skills/render-keyvalue/SKILL.md): Provisions and configures Render Key Value (Redis-compatible Valkey 8) instances for caching, session storage, and job queues.
- [render-mcp](https://github.com/render-oss/skills/blob/main/skills/render-mcp/SKILL.md): Connects and configures the Render MCP server for AI coding tools—setup per tool (Cursor, Claude Code, Codex), authentication, workspace selection, tool catalog, and troubleshooting.
- [render-migrate-from-heroku](https://github.com/render-oss/skills/blob/main/skills/render-migrate-from-heroku/SKILL.md): Migrate from Heroku to Render by reading local project files and generating equivalent Render services.
- [render-monitor](https://github.com/render-oss/skills/blob/main/skills/render-monitor/SKILL.md): Monitor Render services in real-time.
- [render-networking](https://github.com/render-oss/skills/blob/main/skills/render-networking/SKILL.md): Connects Render services over the private network—internal DNS, service discovery, and cross-service communication.
- [render-postgres](https://github.com/render-oss/skills/blob/main/skills/render-postgres/SKILL.md): Sets up and optimizes Managed PostgreSQL on Render—connection strings (internal vs external), creation constraints, storage autoscaling, connection limits, high availability, read replicas, backups, and MCP inspection.
- [render-private-services](https://github.com/render-oss/skills/blob/main/skills/render-private-services/SKILL.md): Configures Render private services—internal-only apps that accept traffic exclusively from other Render services over the private network.
- [render-scaling](https://github.com/render-oss/skills/blob/main/skills/render-scaling/SKILL.md): Scales Render services—configures autoscaling targets, chooses instance types, sets manual instance counts, and optimizes cost.
- [render-static-sites](https://github.com/render-oss/skills/blob/main/skills/render-static-sites/SKILL.md): Deploys and configures static sites on Render's global CDN—build commands, publish paths, SPA routing, redirects, custom headers, and PR previews.
- [render-web-services](https://github.com/render-oss/skills/blob/main/skills/render-web-services/SKILL.md): Configures Render web services—port binding, TLS, health checks, custom domains, auto-deploy, PR previews, persistent disks, and deploy lifecycle.
- [render-workflows](https://github.com/render-oss/skills/blob/main/skills/render-workflows/SKILL.md): Sets up, develops, tests, and deploys Render Workflows.

## Common workflows

### Deploy a Postgres database

- Ask Claude Code to create a Render Postgres database and pick a plan.
- Store the database's internal connection string as a service env var (`DATABASE_URL`).
- Run any required migrations from your service's pre-deploy command.
- For read-heavy workloads, ask it to evaluate whether high availability or a read replica belongs in your plan, then make that change from the Render Dashboard or API.

### Deploy a project from a Blueprint

- Ask Claude Code to read the project and propose a `render.yaml` Blueprint.
- Review the proposed services, databases, and env vars.
- Validate the Blueprint with the Render CLI, then apply it from the Render Dashboard or API.
- Confirm the first deploy succeeds by checking logs and the health-check endpoint.

### Debug a failing deployment

- Ask Claude Code to fetch the most recent failed deploy's logs.
- Have it identify the root cause (missing env var, port binding, OOM, build error).
- Apply the fix by updating env vars, editing code, or changing service settings through the Render Dashboard or API.
- Push the code fix or update the service settings, then watch the next deploy until the service is healthy.

### Configure environment variables and secrets

- Ask Claude Code to list the current env vars on the target service.
- Add or update values, marking sensitive secrets with `sync: false`.
- For values shared across services, ask it to propose an env group change.
- Confirm a new deploy starts, or redeploy from the Render Dashboard if needed.

### Set up a custom domain

- Ask Claude Code to walk through adding a custom domain to the service.
- It returns the required DNS record (CNAME or A/ALIAS for an apex).
- Add the DNS record at your registrar.
- Confirm verification and TLS issuance with a final status check.

## Tips for success

> - *Install the Render MCP server* so Claude Code can read service state, fetch logs and metrics, and apply supported env-var changes instead of guessing from your local repo.
> - *Define your infra in a `render.yaml` Blueprint.* Agents read and modify Blueprints reliably, and the file becomes the source of truth that your team and your agent share.
> - *Ask for service status before deploying.* A quick "what's the current state of my services?" prompt catches mismatches between local intent and what's actually deployed before you ship a change.

## FAQ

###### How do I give Claude Code access to Render?

Install the [Render MCP server](https://github.com/render-oss/render-mcp-server) and authenticate with a [Render API key](api). The MCP server exposes tools for creating supported services, inspecting databases, running read-only SQL queries, updating env vars, and more. Skills are then layered on top to give the agent procedural know-how for common tasks.

###### Can Claude Code deploy to existing Render services?

*Yes, with some limits.* The Render MCP server can inspect existing services and update their environment variables. For changes like scaling, instance types, custom domains, or redeploys, use Render skills with the Render CLI, Dashboard, API, or Blueprint changes as appropriate.

###### How do I debug a failed Render deployment with Claude Code?

Ask Claude Code to fetch the latest deploy logs for the failing service and diagnose the cause. The `render-debug` skill walks through the most common failure modes, including missing env vars, port binding, out-of-memory, and build errors, then proposes a fix you can review and apply.

###### Does the Render MCP server support OAuth?

Not yet. The Render MCP server currently uses API-key authentication. OAuth support is on the roadmap; until then, generate an API key from your [account settings](https://dashboard.render.com/u/settings#api-keys) and pass it as a `Bearer` token in the MCP server's `Authorization` header.

###### Can Claude Code manage Render Workflows?

*Yes.* Use the `render-workflows` skill alongside the MCP server to scaffold a Workflow service, edit task definitions, run workflows locally, and deploy to Render. See the [Workflows docs](workflows) for the underlying concepts.

###### What's the difference between Render skills and the Render MCP server?

The MCP server exposes Render's API as agent tools for creating supported services, fetching logs, and running read-only database queries. Skills are agent-invoked `SKILL.md` files that teach the agent how to chain those tools together for tasks like "deploy this app" or "diagnose this failure". Use them together: MCP is the toolbox, skills are the procedures.

###### Does Claude Code work with Render Workflows?

*Yes.* The `render-workflows` skill walks Claude Code through scaffolding a Workflow service, defining tasks with retries and subtasks, running locally, and deploying to Render.

## Troubleshooting

### `claude mcp` command fails or hangs

Confirm Claude Code is at least version `1.0.30` with `claude --version`. The HTTP MCP transport used here was added in that release. Upgrade with `npm install -g @anthropic-ai/claude-code@latest`.

### Authentication errors from the Render MCP

The `Authorization` header must be the literal string `Bearer <KEY>`. If your shell didn't expand `$RENDER_API_KEY`, the header will contain the literal `$RENDER_API_KEY` and the server will reject it. Run `echo $RENDER_API_KEY` to confirm the variable is set, or paste the key value directly into the header.

### Claude can't find the `render` CLI

The `render skills install` command needs the [Render CLI](cli) on your `PATH`. Install it with Homebrew (`brew install render`) or the install script, then confirm with `render --version`.

## Community

*Render MCP Server*

Open-source MCP server source, install instructions, and tool reference.

*Render Skills*

The full skill catalog with `SKILL.md` files for every supported task.

*Render Discord*

Get help from the Render team and community in real time.

*Render on GitHub*

Open-source repos, examples, and the platform changelog.

- [Start a new project](https://dashboard.render.com)
- [Read the docs](docs)