How to make videos with Claude (MCP, start to finished MP4)

Claude can't render video by itself. No language model can. What it can do, better than almost anything else, is author a precise, structured description of a video. Give it a tool that turns that description into pixels and you have a complete pipeline: you describe the video in plain English, Claude composes it as structured JSON, a deterministic GPU engine renders the MP4.

This guide sets that up end to end with the Clipkit MCP server: setup for every Claude surface, a full worked example of the authoring loop, the prompts that work well, troubleshooting, and honest notes on what this can and can't do. Ten minutes to first video, no video editor, and, depending on the path you pick, no account.

What's actually happening (60 seconds of architecture)#

MCP (Model Context Protocol) is how Claude connects to external tools. The Clipkit MCP server gives Claude a video toolbox, fifteen tools covering the full loop:

• Author: create_project, add_element, edit_element, delete_element, set_project
• Check: validate_project, describe_project, preview_still
• Learn: read_docs, get_schema (the protocol guide and JSON schema, served as tools so Claude grounds itself in the real format)
• Media & handoff: ingest_asset, open_in_editor, load_project, get_project, create_promo

The key design choice: Claude never generates video with an AI model. It writes a JSON document in the Clipkit Protocol (an open, documented format for scenes, text, images, audio, animations, and charts), and the Clipkit engine renders exactly what the document says. Same document, same video, every time. That determinism is why the workflow is reliable: a structured document can be validated before rendering, so Claude gets actionable errors instead of shipping something broken, and the frame you approve is the frame that exports.

Setup: pick your Claude#

Claude.ai / Claude Desktop via the hosted connector (zero install). On a paid plan: Settings → Connectors → Add custom connector → https://www.clipkit.dev/mcp (Streamable HTTP, no authentication). Done: the tools appear in your conversation's tool menu. Nothing to install, nothing to configure, no API key.

Claude Desktop via the local server. Works on any plan. Add to claude_desktop_config.json (Settings → Developer → Edit Config):

{
  "mcpServers": {
    "clipkit": {
      "command": "npx",
      "args": ["-y", "@clipkit/mcp-server"]
    }
  }
}

Restart Claude Desktop; look for the tools icon.

Claude Code (terminal). One command:

claude mcp add clipkit -- npx -y @clipkit/mcp-server

The same server works in Cursor, Cline, Windsurf, and ten other MCP clients. Per-client walkthroughs live in our docs at clipkit.dev/docs/mcp.

The worked example: watch the whole loop once#

Prompt:

Make a 12-second product announcement video, 1920×1080. Dark background, bold amber headline "SHIP FRIDAY" that slides in, a one-line subtitle under it, and end on "clipkit.dev". Snappy timing.

Here's what a real run looks like, tool by tool.

Claude calls create_project and gets back: "Created new project (project_id: …): 1920×1080, 10s, 30fps, mp4." It patches the duration to 12s and starts composing.

Claude calls add_element several times. This is the kind of document it's writing (real protocol JSON, not pseudocode):

{ "type": "text", "id": "headline", "text": "SHIP FRIDAY", "layer": 2,
  "x": 120, "y": 420, "font_size": 128, "fill_color": "#FFB800",
  "animations": [{ "type": "slide-in", "direction": "left", "duration": 0.6 }] }

A background rectangle on layer 1, the subtitle on layer 2 starting half a second later, the closing "clipkit.dev" card in the final seconds. Layers stack in ascending order (highest on top, like CSS z-index) and x/y is the top-left corner (like the CSS box model), conventions chosen because models already know them cold.

Claude calls validate_project. If it forgot something (say it omitted layer), the validator answers precisely: "Element rejected by schema: elements.0.layer: Required." Claude fixes it in the next call. This is the step that makes the workflow trustworthy: errors surface before rendering, named and located, not as a mangled export you have to eyeball.

Claude calls preview_still at t=1s and a rendered PNG of the actual frame lands in your conversation. You look at it and say: "Bigger headline, and move everything up a bit." Claude calls edit_element with a two-field patch (no regeneration, no starting over) and previews again.

Claude calls open_in_editor and hands you a link like clipkit.dev/public-editor?id=…. The composition opens in a free, no-login browser editor with a full timeline. You nudge the subtitle timing by hand, hit Export, and the MP4 renders in your browser on WebGPU. Free, no account, no render server, no watermark.

That loop (describe, compose, validate, preview, refine, hand off) is the entire workflow. The conversation is the editor.

Prompts that work well#

Patterns that consistently produce good first drafts:

• Give dimensions, duration, and mood up front. "15 seconds, 1080×1920 vertical, high-contrast, fast cuts" beats discovering constraints one revision at a time.
• Name the beats. "Open on the stat, hold two seconds, then the headline, end on the URL." Claude maps beats to timed elements directly.
• Feed it real content. Paste the release notes, the quote, the numbers. "Turn these three bullet points into scenes" outperforms "make it compelling."
• Revise by reference. "Make the headline amber and start it half a second earlier." Targeted edits patch one element; vague vibes regenerate guesses.
• Ask for a preview when it matters. "Show me the frame at 3 seconds" costs nothing and anchors the conversation on pixels instead of adjectives.

For charts, hand over the data and say so: "Animate these five quarterly revenue numbers as a bar chart, one bar per beat." The protocol has chart and data-visualization elements, and Claude wires real numbers into them.

Using your own media#

Claude composes with media you provide: pass any public URL and it becomes an element in the composition ({"type": "image", "src": "https://…", …}). For local files, ingest_asset re-hosts a file at a public CDN URL so compositions can reference it. Everything else (text, shapes, gradients, animated captions, charts, transitions, particles) the engine draws itself, deterministically, from the document.

What it will not do: invent footage. There's no generative model in the loop, by design: no faces, no landscapes, no Sora-style scenes. If you want generated footage, make the clip with a generation model, then hand the file to Clipkit for composition, captions, timing, and branding. The two stack cleanly; they're different layers.

Troubleshooting#

• Connector added but no tools appear: custom connectors require a paid claude.ai plan; on Desktop, the local-server config path works on any plan (check the config file's JSON syntax and restart the app).
• Claude says it can't make videos: nudge it with "use the clipkit tools to compose it." Once it calls create_project, the loop takes over.
• Validation keeps failing: ask Claude to call read_docs first. The docs-as-tools design exists exactly so the model grounds itself in the current format instead of guessing from training data.
• Preview looks wrong: iterate with edit_element in-conversation, or just take the editor link. Some fixes are faster with hands on a timeline.
• Fonts/emoji/unicode: supported in the engine, including per-glyph animation on emoji. If something renders unexpectedly, preview a frame and revise. Deterministic rendering means what you fix stays fixed.

Going further: charts, captions, and batches#

Three patterns worth knowing once the basic loop clicks:

Data into motion. Paste numbers and ask for them animated: "Turn these five quarterly revenue figures into an animated bar chart video, one bar per beat, brand color #FFB800." The protocol has chart and data-visualization elements, so the numbers you paste become the numbers rendered. No screenshots of spreadsheets, and updating next quarter means editing one array.

Captions and transcripts. Hand Claude a transcript (or an .srt) and ask for an animated-caption treatment over your footage: "Caption this clip with word-by-word animated captions, bold, bottom third." Captions are protocol elements like everything else: timed, styled, editable after the fact in the editor.

Batches. Because each video is a document, "make one per item" is a natural ask: "Make a 10-second variant of this announcement for each of these four product names." Claude loops the same composition with per-item edits: four documents, four editor links. For real volume (hundreds), graduate from conversation to pipeline: the same tools drive fully autonomous generation, covered in "Give your AI agent a video tool."

Costs, plainly#

Composing, validating, frame previews, and browser rendering: free, no account. A free Clipkit account makes projects durable and yours: the first signed-in person to open a composition in the editor becomes its owner. Cloud rendering (GPU renders via API, ProRes/AV1, no browser involved) is the paid tier, priced per second of output on a public rate card. A typical Claude-authored video costs you nothing end to end: compose free, preview free, export free in the browser.

How this compares to other ways of getting video out of Claude#

Worth situating, because there are three other routes people try. Claude writing Remotion/React code: works, and for bespoke design-system video it's the right call, but the code path measured 87% agent validity against this loop's 100% in our benchmark, because code fails at render time while documents fail at validation time. Claude driving a screen-recorded editor (computer use): a demo, not a workflow. Slow, fragile, and nothing is verifiable. Claude calling a generative video model: solves a different problem (inventing footage) and produces non-deterministic output you can't revise; pair it with this workflow rather than instead of it. The MCP-composition route is the only one of the four where every step (author, validate, preview, export) is checkable and repeatable.

Why this works so reliably (the measured version)#

We benchmark agent video authoring rather than assert it: across a 60-cell benchmark (5 briefs × 3 model tiers, real agent transcripts, every artifact validated and rendered), agents using Clipkit's schema-validated JSON path shipped a valid video in 15 of 15 runs, the only 100% in the benchmark, versus 87% for agents writing React render code for the same briefs, at effectively equal cost per video. The mechanism is the validation loop you watched in the worked example: structured data fails early and specifically; code fails late and vaguely. The full comparison, including where the code-based approach genuinely wins, is in our Clipkit vs Remotion breakdown.

Where to go next#

Connect the server, run the worked example, and then try the thing you actually need this week: the changelog video, the launch teaser, the chart animation. If you're building an agent product rather than chatting, the same fifteen tools drive autonomous pipelines: swap the editor handoff for the render API and read "Give your AI agent a video tool" for the schema-design details that keep unattended agents at 100%.