Anthropic

Generate videos in Claude Code

One command, and your terminal can render video. Renderly runs a hosted MCP server, so Claude Code renders from the templates you already built - and previews cost nothing.

5 free credits · no card · hosted MCP, nothing to install

Claude Codeexample session

You

I have listings.csv with 40 new properties. Render the Listing Promo for every row.

renderly_list_projects
Finds Listing Promo in your library
1 match, 6 personalizable variables
renderly_get_variables
Reads what the template accepts
address · price · beds · baths · agent_name · hero_image

Your CSV has a list_price column but the template wants price. I will map it, and preview row 1 before rendering all 40.

renderly_preview_render0 credits
Checks row 1 for free
resolved 6/6 · warning: agent_name clipped at 22 chars

The agent's name overruns its line. Dropping the middle initial and previewing the same link again - still free.

renderly_preview_render0 credits
Updates the same preview in place
revision 2 · no warnings · ?mode=grid sheet read
renderly_create_render20 credits
Renders all 40, once you confirm
40 jobs queued · 0.5 credits each
renderly_get_render_status
Polls until every job lands
40 COMPLETED

All 40 rendered. Links written to listings-out.csv next to your input file.

2 previews, charged nothing20 credits spent, on the render alone

Claude Code already has your repository, your data files and your shell. What it does not have is a way to turn any of that into video. Renderly's hosted MCP server closes that gap in a single command: no local process to supervise, no SDK to install, no render pipeline to stand up. Once it is registered, Claude Code can read the variables on a template you designed earlier, fill them from a CSV sitting in your working directory, check the result for free, and only then spend a credit. That last part matters more in a terminal than anywhere else, because a terminal agent iterates fast and without much ceremony - it will happily try six variations of a headline before it is satisfied. With previews costing nothing, six attempts cost nothing. The registration is also the one you can commit. Project scope writes a .mcp.json at your repository root, so the repo that holds the data can hold the render setup beside it, and whoever clones it inherits a working server rather than a paragraph of instructions.

Renderly is the rendering engine, not the publisher. It hands back a finished MP4 at a URL - where that file goes next is up to you or one of our no-code integrations. The same engine and the same credits drive the REST API, so nothing about a render differs because Claude Code asked for it.

The free preview loop

Claude Code can check its work before you pay for it

An agent filling in a template will get something wrong - a mistyped variable name, a headline too long for its line. Renderly gives it a way to find out for nothing. A preview takes the same arguments as a real render and resolves them exactly the same way, but produces no video and costs no credits.

Preview0 credits
Fix, preview again0 credits
Once more0 credits
Rendercredits charged

It can look at the frames

Append ?mode=grid and the preview page draws a labelled contact sheet spanning the whole video, as ordinary images. Any agent that can open a page and screenshot it can then see a collided caption or a wrong colour - the failures no validator catches.

?mode=grid

Or one exact moment

Append ?frame=N to check a specific instant, where N is the second you care about multiplied by the frame rate. The page publishes its own rate, so the agent works it out rather than guessing from the nearest tile on the grid.

?frame=N

And fix it in place

Pass the previewId back with corrected values and the same preview updates. The link never changes, so the agent reloads and looks again. A revision counter goes up each time, which is how it knows it is seeing its own latest attempt and not a cached earlier one.

previewId

The warning that saves the most credits. If a variable name does not match, Renderly ignores it silently and renders the authored default instead - so the video comes back looking fine and carrying the wrong text. A preview returns a resolved map of what actually applied plus an UNKNOWN_REPLACEMENT warning, which is how Claude Code catches that before it becomes a charge.

Setup

Connect Renderly to Claude Code

Claude Code registers remote MCP servers from the command line. Nothing to edit for a personal setup, and a single JSON file when you want to commit it.

Any terminal - with OAuth

claude mcp add --transport http --scope user renderly \
  https://renderly.video/api/mcp

Then run /mcp inside Claude Code and complete the sign-in. Claude Code follows our 401 to the RFC 9728 metadata, finds the authorisation server and registers itself, so the URL alone is enough.

Any terminal - with an API key, for headless and CI use

claude mcp add --transport http --scope user renderly \
  https://renderly.video/api/mcp \
  --header "Authorization: Bearer rnd_YOUR_API_KEY"

-t and -H work as short forms of --transport and --header.

.mcp.json - project scope, checked into version control

{
  "mcpServers": {
    "renderly": {
      "type": "http",
      "url": "https://renderly.video/api/mcp"
    }
  }
}

This file belongs at the repository root, not inside .claude/. MCP servers are not read from settings.json, and "type" is required - a url without it is a hard config error.

.mcp.json - key from the environment, and a longer render window

{
  "mcpServers": {
    "renderly": {
      "type": "http",
      "url": "https://renderly.video/api/mcp",
      "headers": {
        "Authorization": "Bearer ${RENDERLY_API_KEY}"
      },
      "timeout": 600000
    }
  }
}

Claude Code expands ${VAR} in url, headers, command, args and env, with ${VAR:-default} fallbacks, so a committed file never carries the key itself. timeout is in milliseconds and values under 1000 are ignored.

Run one of the commands above. Use --scope user for every project on your machine, or --scope project to write a .mcp.json your team inherits.
On project scope, Claude Code asks once whether you trust the servers in that file before it connects. Approve it; claude mcp reset-project-choices clears the answer if you change your mind later.
Run /mcp inside Claude Code. With OAuth, complete the Renderly sign-in; with a key, the server should already read as connected.
Ask it to list your Renderly templates. If your own library comes back, you are done.
Optional: pre-approve the tools you are happy for it to run unattended with a permission rule such as mcp__renderly__renderly_preview_render, and leave the render tool prompting.
If something is wrong, claude mcp get renderly prints the resolved entry, and claude --debug=mcp writes the server's stderr under ~/.claude/debug/.

Either a browser sign-in or an API key

Both credentials work, and the key is the better one for automation. Generate one under Settings → API Keys and pass it with --header; there is no browser step, which is what makes this client usable inside CI. OAuth is better on your own machine, because the token refreshes itself and the key never reaches your shell history. Do not set both. If an Authorization header is present and the server rejects it, Claude Code reports the connection as FAILED and does not fall back to the sign-in flow, so remove the header to get OAuth back.

How this was checked. Server verified live on 2026-08-19: 401 with an RFC 9728 challenge, WorkOS AuthKit discovery, Dynamic Client Registration, and all ten tools registered. The commands, the .mcp.json shape and the timeout and permission behaviour were confirmed against Anthropic's current Claude Code MCP documentation. Not driven end to end from this machine. Anthropic’s documentation

The surface

Ten tools Claude Code gets

You never call these by hand. Claude Code picks the right one from what you asked for. They are listed because it is worth knowing which of them can cost you money - and that seven of the ten cannot.

They are thin wrappers over the same service layer the public REST API uses, so the two surfaces cannot drift apart.

Renderly MCP tools, what each does, and whether it costs credits
Tool	What it does	Cost
`renderly_whoami`Connect	Confirms the connection and reports your credit balance	free
`renderly_list_projects`Find	Lists your own projects that have something to personalise	free
`renderly_list_templates`Find	Lists the public system templates	free
`renderly_get_variables`Find	Reads which fields a template or project accepts, and their current values	free
`renderly_preview_render`Check	Resolves your values exactly as a render would, without producing a video - returns a public preview link, what actually applied, a credit quote and any warnings	free
`renderly_create_render`Render	Renders the video. Annotated as not read-only, so clients ask before calling it	credits
`renderly_get_render_status`Track	Polls the job and returns the finished video URL	free
`renderly_generate_captions`Add AI	Transcribes audio into word-synced captions you can drop straight onto a layer	credits
`renderly_generate_voiceover`Add AI	Turns a script into narration saved to your media library	credits
`renderly_get_ai_job`Add AI	Polls a captions or voiceover job for its result	free

Why Claude Code

What this client is good at

Claude Code runs where the data already is: a terminal, often on a build box or inside CI. That makes an API key the natural credential rather than a workaround, because a key in the header needs no browser round trip and the same registration works headless. It is also the client most likely to be holding what you want to render already - a scores file, a CSV export, a directory of images - so the distance between having the data and having the video is one sentence rather than a script. It gives you fine control over the parts that matter for rendering, too. Per-server timeouts are set in milliseconds on the server entry, so a long job need not be cut off. Permission rules can pre-approve the free Renderly tools while still stopping on the one that spends credits. And a call that outlives two minutes moves into /tasks rather than blocking the conversation.

Questions people actually hit

Does Claude Code support remote MCP servers over HTTP?

Yes, natively. Pass --transport http when you add the server and Claude Code speaks Streamable HTTP directly - there is no mcp-remote bridge or other local process to keep alive. Renderly is a hosted endpoint, so nothing runs on your machine and nothing needs updating when we ship new tools. The deprecated SSE transport also works against our legacy endpoint, but there is no reason to choose it.

Where does Claude Code actually write the Renderly server config?

It depends on the scope you chose. Project scope writes .mcp.json at your repository root, which is the file you commit so teammates inherit the server. Local and user scope both write to ~/.claude.json instead, or %USERPROFILE%\.claude.json on Windows. MCP servers are never read from settings.json, and .mcp.json must sit at the repository root rather than inside the .claude directory.

Claude Code says my server has a url but no type. What is missing?

The type field. If a JSON entry carries a url without a type, Claude Code reads it as a stdio server, skips it, and prints exactly that message. Add "type": "http" alongside the url and it connects. The value "streamable-http" is accepted as an alias. This only bites when you write the file by hand; the claude mcp add command sets the field for you.

Can I use this in CI, where no browser is available?

Yes, and this is the case API keys exist for. Register the server with a --header "Authorization: Bearer rnd_…" argument and no interactive sign-in is ever needed. Keep the key in your CI secret store and reference it as ${RENDERLY_API_KEY} rather than committing it. Note that non-interactive runs cannot complete an OAuth flow at all, so if you would rather use OAuth, sign in once from an interactive session first.

A long render times out in Claude Code. Can I give it longer?

Yes. HTTP servers have a 60-second timer to the first response byte and a five-minute idle timeout; raise both with a per-server "timeout" in milliseconds, or the MCP_TOOL_TIMEOUT environment variable. You rarely need to. Renderly queues a render and returns a job id straight away, so the call that could be slow is the poll, not the render. Separately, any call still running after two minutes is moved into /tasks and the session carries on.

How do I stop Claude Code burning credits while it experiments?

Tell it to call renderly_preview_render first, or simply say "preview it before you render". A preview resolves your values exactly as a real render would, costs nothing, and returns a public link plus a machine-readable list of problems. Terminal agents iterate quickly, so this is the difference between six free attempts and six charged ones.

Will Claude Code ask before it spends credits?

It should. renderly_create_render is annotated as not read-only, which is the signal MCP clients use to prompt rather than calling a tool silently. If the prompting gets tiresome, pre-approve only the free tools with permission rules like mcp__renderly__renderly_preview_render and leave the render tool asking. A bare mcp__* allow rule is skipped with a warning, so name the server explicitly.

The same server, in every other client

One endpoint, one account, one credit balance. Only the wrapper changes.

Using something not listed? Any client that speaks remote MCP over Streamable HTTP can connect to https://renderly.video/api/mcp - these pages exist because the setup differs, not the server.

Let Claude Code render the next one

Build a template once, then describe what you want. Previews are free, so the first thing you spend a credit on is a video you have already seen.