Warp

Generate videos in Warp

Render a week of clips without leaving your terminal. Renderly runs a hosted MCP server, so Warp renders from the templates you already built - and previews cost nothing.

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

Warpexample session

You

week.csv has 14 clips for next week's drop. Render them all from my Daily Drop project.

renderly_list_projects
Finds Daily Drop in your library
1 match · 5 dynamic variables
renderly_get_variables
Reads the project's variable contract
sku, headline, price, hero, cta · hero takes a URL

I read the header with head -1 in this pane. hero_url maps to hero, and there is no cta column, so that keeps its project default. Previewing Monday's row first.

renderly_preview_render0 credits
Resolves row 1 with no credit cost
previewUrl live for 24h · resolved 4/5 · no warnings

?mode=grid looks right: the price fits on one line and the hero loads. All 14 clips run 26s each, so 0.5 credits apiece, 7 credits total. Shall I queue them?

renderly_create_render7 credits
Queues all 14 clips once you confirm
14 jobs accepted · 0.5 credits each · 7 charged
renderly_get_render_status
Polls the batch until it settles
14/14 completed · 14 MP4 URLs returned

All 14 rendered. I wrote the URLs to out/urls.txt and pulled the files down with xargs curl, named by sku.

1 preview, charged nothing7 credits spent, on the render alone

Warp is a terminal, so the agent inside it starts out holding most of what a batch of videos needs: the CSV your ops rota exports every Friday, the S3 URLs sitting in your shell history, the out/ directory you were going to drop files into anyway. It can read those files and run those commands. Turning a row of that data into a finished MP4 is the one step it cannot take by itself, and that is the step Renderly's hosted MCP server supplies. Nothing gets installed for it. Warp talks to https://renderly.video/api/mcp directly, and the MCP servers page then lists ten Renderly tools under the renderly row, beside your other servers. Put the same three lines in ~/.warp/.mcp.json instead and Warp spawns the server on launch, because global Warp servers auto-spawn by default. From there the agent can pull the variable list off a project you built in the Renderly editor, map it onto the columns of whatever file sits in your working directory, check that mapping for free, and only then spend a credit. That order is worth keeping when one prompt fans out into fourteen renders, because a wrong column mapping shows up in a free preview rather than in fourteen charged ones.

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 Warp asked for it.

The free preview loop

Warp 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 Warp catches that before it becomes a charge.

Setup

Connect Renderly to Warp

Registering a server is not a CLI step in Warp. `warp mcp list` reports what is already registered, but you add a remote server either from the MCP servers page in Settings or by writing a JSON file that Warp watches. Both routes take the same snippet, and they are stored in different places.

~/.warp/.mcp.json (global, file-based)

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

This server type has just two properties: url, which is required, and headers, which is optional. There is no type or transport key, and Warp negotiates Streamable HTTP or SSE itself, so the legacy /api/sse endpoint is not needed. Global Warp servers in this file auto-spawn by default, and a server that needs OAuth shows its login modal on the first spawn. The identical snippet also pastes into + Add, but that route keeps the server in Warp's own configuration instead of writing this file, so choose one route rather than both.

~/.warp/.mcp.json (static key instead of OAuth)

{
  "mcpServers": {
    "renderly": {
      "url": "https://renderly.video/api/mcp",
      "headers": {
        "Authorization": "Bearer rnd_your_key_here"
      }
    }
  }
}

Custom Headers is Warp's documented way to pass a Bearer token. It is the right choice where a browser round trip is not available, which is the case for cloud agents. Note that sharing a server with teammates scrubs sensitive values from env, not from headers, so treat a snippet like this as a secret.

~/.warp_cli/.mcp.json (macOS, Warp Agent CLI)

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

The Warp Agent CLI keeps its own MCP config, separate from the app's, and reads only its global file: project-scoped files in repos are not detected there. Configured servers start on their own once you are logged in. Run /mcp inside the CLI to see the exact path it reads, each server's status and tool count, and to start or re-authenticate one.

Open Settings > Agents > MCP servers, or follow the warp://settings/mcp link.
Click + Add, choose the "Streamable HTTP or SSE Server (URL)" type, and paste the JSON above. Typing https://renderly.video/api/mcp into the url field does the same job.
Press Start on the renderly row. A browser window opens for the WorkOS AuthKit login on the first spawn. If you wrote ~/.warp/.mcp.json instead of using + Add, Warp spawns the server for you and the same login appears.
Confirm the row lists the ten Renderly tools. If it does not, press View Logs on that row.
Ask the agent to list your Renderly projects, then to preview one before rendering it.

Either a browser sign-in or an API key

Warp handles both paths. With url alone, the first spawn opens your browser for the WorkOS AuthKit login; Warp then stores the credentials on that device and reuses them for later sessions, you re-authenticate when you open Warp on a new machine, and you can revoke access from the MCP servers pane. If a token gets stuck, rm -rf ~/.mcp-auth clears it, but that deletes every MCP auth token stored locally, not only Renderly's, so you sign in to your other servers again too. The headers variant suits cloud agents, where no browser round trip is available.

How this was checked. Server verified live on 2026-08-19: an unauthenticated POST returns 401 with an RFC 9728 challenge, WorkOS AuthKit advertises Dynamic Client Registration, and all ten tools are registered. The setup below was confirmed against Warp's current MCP documentation and survived an independent adversarial recheck on the same date. Nobody here drove Warp end to end. Warp’s documentation

The surface

Ten tools Warp gets

You never call these by hand. Warp 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 Warp

What this client is good at

Warp puts each MCP server on the MCP servers page as a row you can Start, Stop, rename, share and read logs for, with the live tool list printed underneath it. For a metered tool that is practical: when a render does not happen, one glance tells you whether Renderly is even connected. Warp also reads other agents' config files, including Claude Code's ~/.claude.json, Codex's ~/.codex/config.toml and ~/.agents/.mcp.json, so a Renderly entry you wrote for another tool can appear here without being retyped, though only Warp's own global file auto-spawns without a toggle. Permissions are then set per execution profile rather than per server. In the settings file the field is mcp_permissions, and MCP tool calls default to agent_decides, which suits how Renderly's tools split: renderly_preview_render is read-only and free, while renderly_create_render declares itself not read-only, which is the flag a client reads before prompting. The agent previews as often as it likes, then stops to ask before it spends credits. Set mcp_permissions to always_ask for a prompt every time, or always_allow in a throwaway sandbox.

Questions people actually hit

I added Renderly in the Warp app, but the warp CLI cannot see it. What did I miss?

Nothing: the Warp Agent CLI keeps its own MCP configuration, separate from the app's. On macOS that file is ~/.warp_cli/.mcp.json. The CLI's config directory moves by platform, to ~/.config/warp-terminal/cli/ on Linux and %LOCALAPPDATA%\warp\Warp\config\cli\ on Windows, so rather than guess, type /mcp in the CLI and it prints the exact path it is reading along with each server's status and tool count. Add the same renderly snippet there and the CLI picks the change up on its own. /tui-migrate-setup copies global server definitions across from the app, but never credentials or OAuth state, so you sign in to Renderly again on that side.

Our repo has .warp/.mcp.json checked in, so why does Renderly never start for anyone who clones it?

Because project-scoped servers never auto-spawn, by design. Warp detects a .warp/.mcp.json at the repo root but will not launch anything from a cloned repo until a human toggles that server on from the MCP servers page, and the approval is session-scoped: after you restart Warp, you toggle it on again if you still trust the repo. Editing an MCP config file also needs your explicit approval, which stops an agent quietly adding a server. Put Renderly in the global ~/.warp/.mcp.json if you want it up on every launch, since global Warp servers do auto-spawn, and keep the repo copy for people who only render inside that project.

I added Renderly through Settings and cat ~/.warp/.mcp.json shows nothing. Where is it?

In Warp's own configuration, not in a file. A server you add with + Add is held by Warp itself, whereas file-based servers are the separate mechanism that ~/.warp/.mcp.json and .warp/.mcp.json cover, so adding one route never populates the other. Nothing is broken: check the row on the MCP servers page instead. If you want Renderly on disk, either write the file yourself or ask the agent to run the bundled /agent-add-mcp skill, which asks whether to save globally or in the current project. To hand it to teammates, use the share icon on the row, which scrubs sensitive env values and prompts them for their own.

The Renderly row will not start. Where does Warp keep its MCP logs?

Press View Logs on that row first, which is the fastest route. The files are on disk too: macOS puts them in $HOME/Library/Group Containers/2BBY89MBSN.dev.warp/Library/Application Support/dev.warp.Warp-Stable/mcp, Windows in %LOCALAPPDATA%\warp\Warp\data\logs\mcp, and Linux in ${XDG_STATE_HOME:-$HOME/.local/state}/warp-terminal/mcp. A 401 carrying a www-authenticate header means the OAuth handshake never finished, so press Start again and complete the browser login. If the login loops, run rm -rf ~/.mcp-auth and retry. Strip these logs before pasting them anywhere, because Warp warns they can contain API keys, and a headers-based rnd_ key lands in them verbatim.

Can a Warp cloud agent render through Renderly, or is this desktop only?

It can, but not over OAuth: Warp's documentation states that it does not currently support OAuth-based MCP servers for cloud agents. Give the cloud copy a headers entry carrying an Authorization Bearer rnd_ key, and hold that key as an Agent Secret rather than inline in the snippet. Expect one more difference in behaviour: a cloud agent run continues without any configured MCP server that fails to start inside the 20-second startup window, rather than failing the run, so a missing Renderly tool list there usually means a slow or unauthenticated start, not a bad prompt.

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 Warp 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.