Anysphere

Generate videos in Cursor

Render video from the editor you already have open. Renderly runs a hosted MCP server, so Cursor renders from the templates you already built - and previews cost nothing.

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

Cursorexample session

You

Turn the top entry in CHANGELOG.md into a launch video for the socials.

Read the 2.4.0 entry - three headline features. Checking which of your templates fits a vertical social post.

renderly_list_templates
Searches the template library
25 in Social Media · picking a 9:16 feature recap
renderly_get_variables
Reads the fields it must fill
headline · feature_1 · feature_2 · feature_3 · version
renderly_preview_render0 credits
Previews it for free and looks at the frames
?mode=grid · warning: feature_2 clipped at 42 chars

The second feature name overflows its line. Shortening it to "Batch renders" and previewing again - still free.

renderly_preview_render0 credits
Updates the same preview in place
revision 2 · no warnings
renderly_create_render1 credit
Renders the final video
1 job queued · 48 seconds at 1080p
renderly_get_render_status
Polls until the file is ready
COMPLETED · launch-2-4-0.mp4

Done, and the MP4 URL is in the chat. Renderly does not post it anywhere - that is yours to schedule.

2 previews, charged nothing1 credit spent, on the render alone

Cursor is where a lot of marketing work quietly happens - the landing page, the changelog, the launch copy. Renderly adds the missing output format to that list. Point Cursor at our hosted MCP server and the agent can render a finished MP4 from a template you designed earlier, using values it reads out of the very file you are editing. A release note becomes a launch clip; a product JSON becomes a set of variations, one per SKU. Because Cursor keeps the whole repository in view, it tends to find the data itself rather than asking you to paste it. The preview loop is what makes that safe: the agent can look at what it produced, for free, and correct a wrong price or a clipped headline before a single credit is spent. Setup is one JSON object. Cursor ships no command that adds an MCP server for you, so the file is the interface - which is also what makes this the easiest of these setups to commit and hand to a team.

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

The free preview loop

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

Setup

Connect Renderly to Cursor

Cursor reads MCP servers from a JSON file - one for the project, one for your whole account. No command writes it for you, so the file below is the setup.

~/.cursor/mcp.json - every project

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

Use .cursor/mcp.json at the project root instead to share it with your team. The field is url - Cursor wants neither a type nor a serverUrl here.

~/.cursor/mcp.json - with a key from the environment

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

Cursor resolves ${env:NAME} in both url and headers. Remote servers do not support envFile, so set RENDERLY_API_KEY in your shell profile or system environment.

Any terminal - check it from the Cursor CLI

agent mcp list
agent mcp list-tools renderly

The CLI reads the same mcp.json, with project taking precedence over global. There is no agent mcp add, so the file above remains the only way in.

Create ~/.cursor/mcp.json, or .cursor/mcp.json at your project root, with the first block above.
Open Cursor Settings → MCP and confirm Renderly appears with its ten tools listed.
If you left the headers block out, complete the Renderly sign-in when Cursor prompts on first use. Our authorisation server supports dynamic client registration, so there is no client ID or secret to paste.
Ask the agent to list your Renderly templates to confirm it is really connected.
If nothing appears, open the Output panel and pick MCP Logs from its dropdown - server startup, tool calls and errors all land there.

Either a browser sign-in or an API key

Either credential works. Leave the headers block out and Cursor discovers our authorisation server from the 401 challenge and runs a browser sign-in; because dynamic client registration is supported, you never paste a client ID or secret. Add the headers block and it uses your rnd_ key with no browser step at all - the better option for a shared project file, where the key should come from the environment rather than the repository. Cursor reserves its static OAuth block for providers that cannot do dynamic registration, which is not us.

How this was checked. Server verified live on 2026-08-19 against production, including the RFC 9728 challenge and Dynamic Client Registration. The mcp.json shape, both config paths, the ${env:} interpolation and the CLI commands were confirmed against Cursor's current MCP documentation and survived an independent adversarial recheck. Not driven end to end from this machine. Anysphere’s documentation

The surface

Ten tools Cursor gets

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

What this client is good at

Cursor keeps its MCP servers in a plain JSON file, which makes the setup easy to share: commit .cursor/mcp.json and everyone on the project inherits the server with no instructions to follow. It accepts either credential, so you can click through a browser sign-in on your own machine while a team pins an environment-backed key instead. And because Cursor is an editor rather than a chat window, the values it renders from are usually already on disk - a product JSON, a changelog entry, a copy deck - which removes the paste step and lets the agent find the data itself. It also resolves ${env:NAME} inside both the url and the headers, so a file you commit can reference a key without containing one. Remote servers do not read an envFile, so that variable has to come from your shell profile or system environment.

Questions people actually hit

Should I put Renderly in the project mcp.json or the global one?

Use ~/.cursor/mcp.json for your own account when the work spans several repositories. Use .cursor/mcp.json at the project root when you want teammates to inherit the server automatically - it is the version-controlled option, and the project file takes precedence when both exist. Keep the shared entry there and reference the key from an environment variable rather than writing it in.

Does Cursor need mcp-remote to reach a hosted server?

No. Cursor connects to remote HTTP MCP servers directly from a bare url field, with no stdio bridge in between. The mcp-remote package exists for clients that only speak stdio, and Cursor is not one of them. Adding it would put an extra local process in the path for no benefit, and would break the OAuth flow that Cursor already runs for you.

Cursor has no command that adds an MCP server. Do I edit the file by hand?

Yes, and that is the intended route. The Cursor CLI can list servers, list their tools, log in and enable or disable them - agent mcp list and agent mcp list-tools renderly are the two worth knowing - but there is no agent mcp add, so the JSON above is how a server gets there in the first place. The CLI and the editor read the same file, so writing it once covers both.

Can the Cursor agent see the video, or only read JSON about it?

It can see it. A preview returns a public URL, and appending ?mode=grid renders a labelled contact sheet of frames as ordinary images. Any agent that can open a page and screenshot it can then look at the result and describe what is wrong - a collided caption, a wrong colour, an image that is not what you meant. No validator catches those.

How do I keep my Renderly API key out of a committed mcp.json?

Reference it rather than writing it. Cursor expands ${env:RENDERLY_API_KEY} inside both the url and the headers, so the committed file carries the name of the variable and never its value. Remote servers do not read an envFile, so set the variable in your shell profile or system environment. The other safe option is the plain url form, which signs each teammate in as their own Renderly account and their own credit balance.

My team is on a managed Cursor plan and Renderly will not connect.

An administrator most likely has not allowlisted it. Cursor lets team admins restrict MCP servers by URL pattern under Team Settings, so on a managed team renderly.video has to be permitted before anyone's mcp.json takes effect. Ask an admin to add it, then reload. This is a team-level control, so no change to your own configuration will work around it.

Why does Renderly show fewer templates than I expect in Cursor?

renderly_list_projects only returns projects that have at least one personalizable variable, because a project with nothing marked dynamic has nothing for an agent to fill in. If a project is missing, open it in the editor and mark the overlays you want to vary as dynamic. Public system templates are listed separately by renderly_list_templates.

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