Newsletter image

Subscribe to the Newsletter

Join 10k+ people to get notified about new posts, news and tips.

Do not worry we don't spam!

By pressing the Subscribe button, you confirm that you have read and are agreeing to our Privacy Policy and Terms of Use

Search

GDPR Compliance

We use cookies to ensure you get the best experience on our website. By continuing to use our site, you accept our use of cookies, Privacy Policy, and Terms of Service.

Claude, Remotion - Video Generation, AI Agent

Claude Remotion Tutorial: Make Videos With Claude Code (2026)

Claude cannot render a pixel, but it writes React, and Remotion renders React to MP4. Here is the full Claude Code setup, tested on Remotion 4.0.545, with the habits from 11 films and 370+ clips. Plus a 50-line HTML renderer and one MCP for 1,717 models.

TL;DR
  • Setup to first render in about two minutes: 13 official agent skills, a 102.5 MB headless browser, then a 5 s 1080p clip in 5.1 s.
  • Claude cannot watch video, but it reads stills. Checking frames before every render is how 11 films and 370+ clips got made.
  • Remotion is source-available and free up to 3 employees. The HTML plus headless Chromium route does the same job with no license at all.
System Requirements
RAMAbout 570 MB of disk per project, headless browser included. 16 GB of RAM rendered 4K films one composition at a time.
GPUNone for 2D. Without a GPU, 3D clips rendered at about 12 frames a minute at 4K, against about 45 for 2D.
VRAMNot needed: Chrome Headless Shell renders on the CPU, and FFmpeg ships with Remotion.

Claude cannot render a single pixel of video. It writes React all day, though, and Remotion turns React components into MP4 files one frame at a time. Put the two together and Claude Code becomes a motion designer that never complains about one more re-render.

This is not a weekend experiment. We used exactly this setup to make 11 films for the Mica Voss YouTube channel, the MINIRACK home lab series and the DAMAGE REPORT news show: more than 370 rendered clips, every one written, rendered and checked by Claude Code. For this tutorial we rebuilt the whole setup from scratch on Remotion 4.0.545 and ran every command on our own machine before publishing.

It also covers the two routes that skip React entirely: a 50-line HTML renderer driven by headless Chromium, and one MCP connection that gives Claude 1,717 generative models for the footage it cannot draw itself.

Claude Remotion: how Claude Code makes video with React

A Remotion video is a React component plus four numbers: frames per second, width, height and duration. Inside the component, useCurrentFrame() returns the frame being rendered, and every position, opacity and word on screen is computed from it. To render, Remotion opens the component in Chrome Headless Shell, captures each frame and encodes the result with an FFmpeg build it ships itself.

That model fits an agent unusually well. The whole timeline is a text file Claude can read, diff and edit. The same input always produces the same video, so a copy change is a re-render, not a re-edit. And React is something Claude writes fluently.

Remotion has leaned into this hard in 2026. It ships official Agent Skills and a Claude Code plugin, and its 11 November post says Agent Skills have "become the default way people make videos with Remotion." The repository sits at 74,944 GitHub stars, and v4.0.545 shipped on 18 November.

Read the license before you build a business on it

Remotion is not open source. It is source-available under the Remotion License, which limits who may use it for free, something no OSI-approved license does. The free license covers individuals, for-profit companies with up to 3 employees, non-profits, and anyone still evaluating it.

Everyone else needs a company license. "Remotion for Creators" is $25 per seat per month and covers manual work and AI agents with Studio. "Remotion for Automators" is $0.01 per render, billed in blocks of 1,000, with a $100 monthly minimum, and is meant for apps that render on demand. If either rules it out for you, the HTML route further down has no license question at all.

Five ways to get video out of Claude

Remotion is the main subject here, but it is not the only answer, and for some jobs it is not the best one. This is the whole field as we use it.

RouteLicenseSetupBest forHow Claude drives itCost
RemotionRemotion License (source-available)Node, about 570 MB per project with the browserLong films, many clips, data-driven video, 3D, transparent layersReact code, 13 official skillsFree up to 3 employees, then from $25/seat/month
HTML + headless ChromiumYour own codeChromium, Node 22+, FFmpegShort ads and teasers, brand-exact one-offsPlain HTML and JavaScriptFree
HyperFramesApache 2.0Node 22+, one skills commandThe HTML route as a maintained frameworkSkills, plus a Claude connectorFree (optional paid app)
Claude MotionPart of claude.aiNoneA quick animated explainer inside a chatBuilt in, type /motionTeam or Enterprise plan
PhotoproductHosted serviceOne MCP connectionFootage, voice and music that code cannot drawMCP tools, 1,717 modelsPer run, in credits

The first three draw what code can draw: type, shapes, charts, interfaces, your own footage composited. The last one makes the pictures and sounds that code cannot. In the films we used Remotion and Photoproduct together, and that combination is where this tutorial ends up.

Step 1: the prerequisites

Remotion needs less than you might expect. A fresh project's package.json asks for Node ^20.19.0 || ^22.13.0 || >=24. FFmpeg is bundled inside the @remotion/compositor-* package, so you do not install it, and the browser is downloaded per project.

That browser is Chrome Headless Shell, fetched with npx remotion browser ensure: a 102.5 MB download that unpacks to 243 MB inside node_modules/.remotion. Remotion's docs are explicit that you should not install Chrome through apt for this. A whole new project, browser included, came to 570 MB on our machine.

On Linux the headless browser needs a set of shared libraries. Remotion's Linux dependency page lists them per distribution, needs glibc 2.35 or newer, and does not support Alpine or NixOS. On Ubuntu it is one line, and it needs sudo, which is exactly why the hand-off prompt tells Claude to stop and give it to you.

# Ubuntu 24.04 (on 22.04 use libasound2 instead of libasound2t64). macOS and Windows: skip this.
sudo apt install -y libnss3 libdbus-1-3 libatk1.0-0 libasound2t64 libxrandr2 libxkbcommon-dev \
  libxfixes3 libxcomposite1 libxdamage1 libgbm-dev libcups2 libcairo2 libpango-1.0-0 libatk-bridge2.0-0

One more thing that costs people a day: fonts. If a composition names a font that is not installed, Chrome silently falls back to another one and the render succeeds anyway. Our film kit relied on fonts installed on the render machine, which works right up to the day you render on a second machine. Load fonts through @remotion/google-fonts or staticFile() and the problem goes away.

Step 2: scaffold the project and add the agent skills

Five commands get you from nothing to a project Claude knows how to work in. The scaffold refuses to run inside an existing git repository, initialises its own, and makes a first commit with your configured git identity.

npx -y create-video@latest --yes --blank my-video   # about 70 s, most of it npm install
cd my-video
npx remotion skills add                  # 13 skills into .agents/skills, symlinked into .claude/skills
npx remotion browser ensure              # Chrome Headless Shell, a 102.5 MB download
npx remotion add @remotion/google-fonts  # fonts that load the same way on every machine
npx remotion versions                    # ends with "All packages have the correct version."

The skills step took 4.8 seconds and wrote 1.5 MB of Markdown: 13 skills in .agents/skills, symlinked into .claude/skills so Claude Code picks them up, plus a skills-lock.json that records where each came from. The other agents it supports (Codex, Gemini CLI, OpenCode and more) read the same folder.

SkillWhat it teaches Claude
remotion-best-practicesThe router: which of the others to load for a task
remotion-createStarting a project or a new composition
remotion-markupThe big one: 33 topic files on timing, sequencing, fonts, audio, 3D, transitions, motion blur, video editing
remotion-renderExporting video, stills, or an OpenTimelineIO timeline for an editor
remotion-studioOpening the live preview
remotion-interactivityWriting markup that stays editable in Studio
remotion-captionsTranscribing, showing and animating captions
remotion-maps, -multimedia, -saasMap animations, browser media processing, building an app around Remotion
remotion-docs, -license, -upgradeSearching the docs, license questions, upgrading packages and skills together

If you would rather have the skills everywhere instead of per project, Remotion also publishes a Claude Code plugin. We prefer the project skills: they are versioned with the project, and /remotion-upgrade moves them forward together with the packages.

claude plugin marketplace add remotion-dev/claude-code-plugin
claude plugin install remotion@remotion
# restart Claude Code, then for example:
# /remotion:remotion-create Make a 20 second launch video for my CLI tool

Then open two terminals. Studio gives you, and Claude, a live preview with a scrubbable timeline. Since 4.0.518 it also exposes WebMCP tools so an agent can steer it, although Remotion's own docs say only Codex supports WebMCP among the major harnesses today.

# terminal 1: the Studio, a live preview with a timeline you can scrub
npm run dev            # http://localhost:3000 (or the next free port)

# terminal 2: Claude, in the same folder
claude

Step 3: give Claude house rules

The skills teach Claude Remotion. They do not teach it your habits, and most of our early trouble came from habits, not from the API. Drop this into CLAUDE.md at the project root and Claude reads it at the start of every session.

# Video project rules (Remotion)

## Determinism
- Every visual value is computed from useCurrentFrame(). No CSS transitions or animations,
  no setTimeout, no Date.now(). For randomness use random('some-seed') from remotion.
- Fonts come from @remotion/google-fonts or staticFile(). Never rely on a system font.

## Look before you render
- Before any full render: npx tsc --noEmit, then stills of the key moments:
  npx remotion still <id> out/<id>-<frame>.png --frame=<n> --scale=0.5
  Read every still. Fix what is wrong. Repeat until clean.
- After a batch of renders: ./contact-sheet.sh, then read out/contact-sheet.jpg.

## Rendering
- One composition at a time. Never edit a render script while it is running.
- Pictures: --codec=h264 --crf=18
- Text layers (titles, lower thirds, captions) are separate compositions with a transparent
  background, rendered as ProRes 4444 with alpha:
  --image-format=png --pixel-format=yuva444p10le --codec=prores --prores-profile=4444

## Timing
- All timings live in src/timing.ts. Compositions read it; nothing hardcodes seconds twice.

## Ask first
- Before installing packages, before renders longer than 60 seconds, before anything that costs money.

Every line there is a scar. The determinism rule exists because a single CSS transition renders differently on every frame capture. The stills rule exists because a 4K render of a mistake costs minutes and a half-size still costs two seconds. The one-at-a-time rule exists because three parallel 4K renders took down a 16 GB machine.

The transparent text layers come from editing the films in Premiere. When every title, lower third and chapter card is its own alpha layer, the footage under it can change without re-rendering a single word, and the editor can retime text by dragging it.

Step 4: your first video

Now ask Claude for something small. A prompt like "make a 5 second 1920x1080 title card: lime kicker, big white title that rises in, a lime bar that grows, and a subtitle that types itself" produces something close to this. It is the exact file we rendered for this article.

import {AbsoluteFill, Sequence, interpolate, spring, useCurrentFrame, useVideoConfig} from 'remotion';
import {loadFont} from '@remotion/google-fonts/Inter';

const {fontFamily} = loadFont('normal', {weights: ['400', '800'], subsets: ['latin']});

export type TitleCardProps = {kicker: string; title: string; sub: string; transparent: boolean};

const LIME = '#c8f542';

export const TitleCard: React.FC<TitleCardProps> = ({kicker, title, sub, transparent}) => {
  const frame = useCurrentFrame();
  const {fps, durationInFrames} = useVideoConfig();

  // Every value below is a pure function of the frame number. No CSS animation, no timers.
  const rise = spring({frame, fps, config: {damping: 200}});
  const bar = interpolate(frame, [10, 40], [0, 520], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'});
  const out = interpolate(frame, [durationInFrames - 15, durationInFrames], [1, 0], {extrapolateLeft: 'clamp'});

  return (
    <AbsoluteFill style={{backgroundColor: transparent ? undefined : '#0b0e14', fontFamily, opacity: out}}>
      <AbsoluteFill style={{justifyContent: 'center', padding: '0 160px'}}>
        <div style={{color: LIME, fontSize: 34, letterSpacing: 6, fontWeight: 800}}>{kicker}</div>
        <div style={{color: 'white', fontSize: 120, fontWeight: 800, lineHeight: 1.05,
          transform: `translateY(${(1 - rise) * 60}px)`, opacity: rise}}>{title}</div>
        <div style={{height: 10, width: bar, backgroundColor: LIME, margin: '36px 0'}} />
        <Sequence from={30} layout="none">
          <Sub text={sub} />
        </Sequence>
      </AbsoluteFill>
    </AbsoluteFill>
  );
};

const Sub: React.FC<{text: string}> = ({text}) => {
  const frame = useCurrentFrame(); // 0 again: inside a <Sequence> time starts at its "from"
  const chars = Math.floor(interpolate(frame, [0, 45], [0, text.length], {extrapolateRight: 'clamp'}));
  return <div style={{color: '#9aa4b2', fontSize: 48}}>{text.slice(0, chars)}</div>;
};

Three things in there are worth understanding before you let Claude loose. spring() gives physical easing without a timer. interpolate() maps a frame range to any value range, and the clamps stop it overshooting. Inside a <Sequence from={30}>, useCurrentFrame() starts at zero again, which is what makes components reusable at any point in a film.

Register the card twice in src/Root.tsx: once with a background, once as a transparent text layer. Then delete the scaffold's empty src/Composition.tsx.

import {Composition} from 'remotion';
import {TitleCard} from './TitleCard';

const props = {
  kicker: 'SINGULARITYBYTE TUTORIAL',
  title: 'Your first Claude video',
  sub: 'Written in React. Rendered frame by frame.',
  transparent: false,
};

export const RemotionRoot: React.FC = () => (
  <>
    <Composition id="title-card" component={TitleCard} durationInFrames={150} fps={30}
      width={1920} height={1080} defaultProps={props} />
    {/* the same card as a text layer: render it as ProRes 4444 and put any footage under it */}
    <Composition id="title-card-text" component={TitleCard} durationInFrames={150} fps={30}
      width={1920} height={1080} defaultProps={{...props, transparent: true}} />
  </>
);
The rendered result: 150 frames at 1920x1080, 99 KB of H.264, rendered in 5.1 seconds.

Step 5: look before you render

Claude cannot watch a video. It reads images very well, though, and that is the whole trick. Before any full render, Claude type-checks and renders stills of the moments that matter, then opens the PNGs and looks at them.

npx tsc --noEmit                                               # 1.6 s, no output means clean
npx remotion still title-card out/check.png --frame=75 --scale=0.5   # 2.1 s, then Claude reads the PNG

That loop is where most of the quality in the films came from. Overlapping labels, a title running off the frame, text sitting on a busy background: all of them show up in a half-size still, and fixing them costs seconds. Only when the stills are clean does the real render start.

# a normal picture: H.264
npx remotion render title-card out/title-card.mp4 --codec=h264 --crf=18

# the same frames at 4K: every pixel value doubles, the code does not change
npx remotion render title-card out/title-card-4k.mp4 --codec=h264 --crf=18 --scale=2

# the text layer with real transparency, for Premiere, Resolve or Final Cut
npx remotion render title-card-text out/title-card-text.mov \
  --image-format=png --pixel-format=yuva444p10le --codec=prores --prores-profile=4444

# check what came out: expect h264,1920,1080,150
ffprobe -v error -select_streams v:0 -show_entries stream=codec_name,width,height,nb_frames \
  -of csv=p=0 out/title-card.mp4
Render (150 frames, 5 s)TimeFile size
Still, half size2.1 s37 KB PNG
H.264, 1920x10805.1 s99 KB
H.264, 3840x2160 (--scale=2)11.4 s259 KB
ProRes 4444 with alpha, 1920x108010.5 s41 MB

Times are wall clock for the whole npx command on an otherwise idle machine. The same commands on a busy machine took about twice as long, so treat them as a floor.

Look at that last row before you make everything transparent. The alpha version of a 5-second card is 414 times bigger than the H.264 one. In the films a 32.8-second transparent hook at 4K came out at 4.46 GB, so budget the disk.

For a batch of clips, Claude should not open 30 videos. This script takes one frame from 75% into every render and tiles them into a single image, which Claude reads in one go.

#!/usr/bin/env bash
# One frame from 75% into every render in out/, tiled 4 across into out/contact-sheet.jpg.
# Claude reads that one image instead of watching every clip.
set -euo pipefail
tmp="$(mktemp -d)"; i=0
for f in out/*.mp4 out/*.mov; do
  [ -e "$f" ] || continue
  d="$(ffprobe -v error -show_entries format=duration -of csv=p=0 "$f")"
  # format=rgb24: alpha (.mov) and opaque (.mp4) frames must share one pixel format or tile breaks
  ffmpeg -loglevel error -y -ss "$(awk "BEGIN{print $d*0.75}")" -i "$f" -frames:v 1 \
    -vf "scale=640:-2,format=rgb24" "$tmp/$(printf %03d "$i").png"
  i=$((i+1))
done
ffmpeg -loglevel error -y -framerate 1 -i "$tmp/%03d.png" -vf "tile=4x$(( (i + 3) / 4 ))" \
  -frames:v 1 -update 1 out/contact-sheet.jpg
rm -rf "$tmp"; echo "out/contact-sheet.jpg: $i clips"

What a real production looks like

The title card is the hello world. The films are what the same loop looks like at scale: 4 to 12 minutes and 12 to 55 clips each, every clip its own composition, rendered at 4K and 25 frames per second. Two to watch: adding 10 Gbps to a Lenovo M920q and reaching a home lab from anywhere with NetBird.

StageWhat happensWho
ScriptChapters with picture notes and a source for every claimClaude writes, a human approves before anything is generated
Spoken textA Python lint turns the script into what the voice reads and blocks unknown audio tagsScript
VoiceOne take per chapter with a text-to-speech modelClaude, over MCP
AlignmentFFmpeg silencedetect finds the pauses and fits sentence ends to them. No Whisper needed.Script
TimingOne timing.ts table drives the clips, the music fit and the editGenerated
PictureOne Remotion composition per clip, text layers rendered transparentClaude
CheckStills, contact sheets, a 720p preview mix with measured loudnessClaude
EditA Final Cut Pro 7 XML rough cut that opens in Premiere, plus a footage folderClaude builds it, a human finishes it

The timing table is the part worth copying first. Every clip length and every animation cue comes from the voice takes, so when a line is re-recorded, one file changes and everything downstream follows.

// src/timing.ts: the one file that knows when anything happens
export const FPS = 25;
// [voice take, clip id, from (s in the take), to (s in the take), hold after the voice (s)]
['01', 'blind-spot', 0.00, 13.52, 0.0],
export const frames = (id: string) => Math.round(seconds(id) * FPS);

The other trick that paid off: parallel agents. For the canary film, three Claude Code agents drew 28 clips side by side. Each agent owned exactly one registry file, so no two of them ever edited the same line.

// src/Root.tsx of the canary film: three agents, one registry file each, merged here.
// Anything an agent has not drawn yet renders as a labelled placeholder, so the film
// always renders end to end while the work is still in progress.
const DRAWN: Record<string, React.FC> = {...DRAWN_A, ...DRAWN_B, ...DRAWN_C};
const CLIPS = PICTURES.map((id) => [id, DRAWN[id] ?? placeholder(id)]);

Gotchas we paid for

  • Memory. Three parallel 4K ProRes renders were killed on a 16 GB machine with no GPU. The fix was one render at a time and Config.setConcurrency(3) in remotion.config.ts.
  • /tmp can be RAM. On many distributions /tmp is a tmpfs, and Remotion's working files land there. Point TMPDIR at a real disk before long renders.
  • CRF and ProRes do not mix. Config.setCrf() in the config file breaks ProRes renders. Pass --crf on the H.264 command line instead.
  • 3D without a GPU is slow. Software GL (Config.setChromiumOpenGlRenderer('swangle')) rendered about 12 frames a minute at 4K, against about 45 for 2D clips. One 3D-heavy film took 2.5 to 3 hours to render.
  • ThreeCanvas does not redraw on its own while rendering. Hold a delayRender() until the model has drawn once, or the first frames come out empty.
  • Editing a script mid-render. Bash reads scripts as it runs them. Change render-all.sh while a queue is running and the queue runs something you never wrote.
  • Premiere drops all audio from a plain FCP7 XML. The fix was to copy the dialect of one of Premiere's own exports instead of following the spec.
  • Cut points. Compute end frames from rounded times, not rounded lengths, or clip boundaries drift by a frame.
  • Unique footage names. Two films shared a file called chapter-1.mov, and Premiere linked one film's cut to the other film's footage. Prefix every file with the project name.
  • Generated images misspell text. We dropped AI-generated diagram plates on the first night and drew everything in code. Text belongs in Remotion, pictures can come from a model.

Alternative 1: skip React and capture HTML with headless Chromium

Strip Remotion down to its core idea and you get this: a web page that can draw any moment of the video on request, a browser that asks for each frame in turn, and FFmpeg to glue the screenshots together. You can build that in about 50 lines, with no framework and no license.

Our first film actually started this way, on a hand-made HTML kit, and switched to Remotion the same day: for 70 clips with shared components and transparent layers, a framework earns its keep. A month later we went back to HTML for 15-second vertical ads. For a short, brand-exact piece it was quicker to build, and a 15-second 1080x1920 short renders in 85 to 130 seconds.

The page has to keep one contract: window.SHORT with the size and length, window.ready() that resolves when fonts and media are loaded, and window.seek(t) that draws time t. Here is the same title card as a single HTML file.

<!doctype html>
<html><head><meta charset="utf-8">
<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;800&display=block" rel="stylesheet">
<style>
  html, body { margin: 0; width: 1920px; height: 1080px; background: #0b0e14; overflow: hidden; font-family: Inter, sans-serif; }
  #card { position: absolute; inset: 0; display: flex; flex-direction: column; justify-content: center; padding: 0 160px; }
  .kicker { color: #c8f542; font-size: 34px; letter-spacing: 6px; font-weight: 800; }
  .title { color: #fff; font-size: 120px; font-weight: 800; line-height: 1.05; }
  .bar { height: 10px; background: #c8f542; margin: 36px 0; }
  .sub { color: #9aa4b2; font-size: 48px; min-height: 58px; }
</style></head>
<body>
<div id="card">
  <div class="kicker">SINGULARITYBYTE TUTORIAL</div>
  <div class="title" id="title">Your first Claude video</div>
  <div class="bar" id="bar"></div>
  <div class="sub" id="sub"></div>
</div>
<script>
  // The contract the renderer relies on: SHORT, ready(), seek(t). Nothing moves on its own.
  window.SHORT = { fps: 30, dur: 5, width: 1920, height: 1080 };
  const SUB = 'Written in HTML. Rendered frame by frame.';
  const clamp = (x) => Math.min(1, Math.max(0, x));
  const p = (t, a, b) => clamp((t - a) / (b - a));          // progress 0..1 between a and b
  const easeOut = (x) => 1 - Math.pow(1 - x, 3);
  const $ = (id) => document.getElementById(id);

  window.ready = async () => { await document.fonts.load('800 120px Inter'); await document.fonts.ready; return true; };
  window.seek = async (t) => {
    const rise = easeOut(p(t, 0, 0.8));
    $('title').style.transform = `translateY(${(1 - rise) * 60}px)`;
    $('title').style.opacity = rise;
    $('bar').style.width = `${p(t, 10 / 30, 40 / 30) * 520}px`;
    $('sub').textContent = SUB.slice(0, Math.floor(p(t, 1, 2.5) * SUB.length));
    $('card').style.opacity = 1 - p(t, 4.5, 5);
    await new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r)));
  };
  // open the page normally (?t=2.5) to preview one moment in a browser
  const q = new URLSearchParams(location.search).get('t');
  if (q !== null) window.ready().then(() => window.seek(Number(q)));
</script>
</body></html>

The renderer talks to Chromium over the DevTools protocol. Node 22 and newer have a built-in WebSocket, so it needs nothing from npm.

// Frame-by-frame renderer over the Chrome DevTools Protocol. Node 22+ (built-in WebSocket), no npm.
// usage: node render.mjs <page-url> <out-dir>    (Chromium must already run with --remote-debugging-port)
import { mkdirSync, writeFileSync } from 'node:fs';
const [url, outdir] = process.argv.slice(2);
const port = process.env.CDP_PORT || '9334';
mkdirSync(outdir, { recursive: true });

const page = (await (await fetch(`http://127.0.0.1:${port}/json/list`)).json()).find((t) => t.type === 'page');
const ws = new WebSocket(page.webSocketDebuggerUrl);
await new Promise((r) => ws.addEventListener('open', r, { once: true }));
let n = 0; const pending = new Map(); const events = [];
ws.addEventListener('message', (e) => {
  const m = JSON.parse(e.data);
  if (m.id && pending.has(m.id)) { pending.get(m.id)(m); pending.delete(m.id); } else if (m.method) events.push(m.method);
});
const send = (method, params = {}) => new Promise((r) => { const id = ++n; pending.set(id, r); ws.send(JSON.stringify({ id, method, params })); });
const run = async (expression) => {
  const r = await send('Runtime.evaluate', { expression, awaitPromise: true, returnByValue: true });
  if (r.result?.exceptionDetails) throw new Error(JSON.stringify(r.result.exceptionDetails));
  return r.result?.result?.value;
};

await send('Page.enable');
await send('Page.navigate', { url });
while (!events.includes('Page.loadEventFired')) await new Promise((r) => setTimeout(r, 50));
const meta = await run('window.SHORT');
await send('Emulation.setDeviceMetricsOverride', { width: meta.width, height: meta.height, deviceScaleFactor: 1, mobile: false });
await run('window.ready()');
writeFileSync(`${outdir}/meta.json`, JSON.stringify(meta));

const total = Math.round(meta.fps * meta.dur);
for (let i = 0; i < total; i++) {
  await run(`window.seek(${i / meta.fps})`);
  const shot = await send('Page.captureScreenshot', { format: 'jpeg', quality: 93 });
  writeFileSync(`${outdir}/f${String(i).padStart(4, '0')}.jpg`, Buffer.from(shot.result.data, 'base64'));
}
console.log(`rendered ${total} frames`);
ws.close();

And the wrapper that serves the page, starts a throwaway headless browser, renders, encodes and cleans up after itself.

#!/usr/bin/env bash
# Serve the page, start a throwaway headless Chromium, capture every frame, encode MP4, clean up.
# usage: ./make.sh <page-dir> <out.mp4>      needs: node 22+, python3, ffmpeg, chromium (or google-chrome)
set -euo pipefail
here="$(cd "$(dirname "$0")" && pwd)"; site="$1"; out="$2"
chrome="$(command -v chromium || command -v google-chrome || command -v chromium-browser)"
work="$(mktemp -d)"; export CDP_PORT="${CDP_PORT:-9334}"; http_port="${HTTP_PORT:-4199}"
cleanup() { kill "${chrome_pid:-}" "${http_pid:-}" 2>/dev/null || true; wait 2>/dev/null || true; rm -rf "$work"; }
trap cleanup EXIT
(cd "$site" && exec python3 -m http.server "$http_port" --bind 127.0.0.1 >/dev/null 2>&1) & http_pid=$!
"$chrome" --headless=new --remote-debugging-port="$CDP_PORT" --user-data-dir="$work/profile" \
  --hide-scrollbars about:blank >/dev/null 2>&1 & chrome_pid=$!
until curl -s "http://127.0.0.1:$CDP_PORT/json/version" >/dev/null && curl -s -o /dev/null "http://127.0.0.1:$http_port/"; do sleep 0.25; done
node "$here/render.mjs" "http://127.0.0.1:$http_port/index.html" "$work/frames"
fps="$(python3 -c "import json,sys; print(json.load(open(sys.argv[1]))['fps'])" "$work/frames/meta.json")"
ffmpeg -loglevel error -y -framerate "$fps" -i "$work/frames/f%04d.jpg" \
  -c:v libx264 -crf 18 -pix_fmt yuv420p -movflags +faststart "$out"
echo "wrote $out"
mkdir html-card && cd html-card      # index.html, render.mjs and make.sh go in here
chmod +x make.sh
./make.sh . html-card.mp4            # 14.6 s for 150 frames at 1080p, browser start included
The same card through the HTML route: 150 frames, 103 KB, 14.6 seconds including the browser start.

Three rules keep it deterministic. No CSS transitions, CSS animations, video playback or Date.now(), because each frame must be a pure function of t. Serve the folder over HTTP rather than file:// so fonts and videos load the way they do on the web. And prepare every embedded clip as all-intra video, because seeking a normal H.264 file lands on keyframes and stutters.

# make a source clip seek-exact: 30 fps, every frame a keyframe, no audio
ffmpeg -i in.mp4 -vf "fps=30,scale=1280:-2" -c:v libx264 -crf 16 -g 1 -pix_fmt yuv420p -an a/clip.mp4

HyperFrames: the same idea, maintained for you

If you like this route but would rather not own the renderer, HyperFrames from HeyGen is the packaged version. It is Apache 2.0, sits at 88,218 GitHub stars, and turns HTML, CSS, JavaScript and seekable animations into deterministic MP4s by seeking each frame in headless Chrome. It ships skills for Claude Code and a connector in Claude's directory.

npx skills add heygen-com/hyperframes   # Node 22+, Apache 2.0

Claude Motion: nothing to install

At the far end is Claude Motion, built into claude.ai. Type /motion, describe an explainer, and Claude writes code that animates text, charts, shapes and images, which you can tweak and download as MP4. It is a beta on Team and Enterprise plans, it has no video model behind it, and it lives in the chat, so it suits a one-off better than a production that reuses your own footage.

Alternative 2: Photoproduct, for the footage Claude cannot draw

Everything so far draws what code can draw. None of it can invent a cinematic shot of a server room, a narrator's voice or a music bed. For that, Claude needs generative models, and wiring up a dozen providers one API at a time is exactly the kind of work you wanted to avoid.

Photoproduct puts 1,717 image, video, speech, music and 3D models behind a single MCP connection: Kling, Seedance, Veo, FLUX, Nano Banana, ElevenLabs and the rest. Claude asks list_models what fits, gets each price before it commits, starts a job with run and collects the result with get_job. Every run is billed in credits from your own balance, and you set a daily credit limit for each app you connect.

The films used it for everything Remotion could not do: the narration (ElevenLabs v4 with audio tags), the music beds (MiniMax Music) and generated stills. The first DAMAGE REPORT episode came to about 59 credits of voice, music and clips. The hero image at the top of this page took 3 credits.

/plugin marketplace add photoproduct/skills
/plugin install photoproduct@photoproduct
# restart if asked, then run /mcp, pick photoproduct and sign in once in the browser

Then glue the two together. The generated image or clip goes into public/, and a composition lays the transparent title card from Step 4 over it. This is the file we rendered with this article's hero image as the plate.

import {AbsoluteFill, Img, OffthreadVideo, interpolate, staticFile, useCurrentFrame} from 'remotion';
import {TitleCard, TitleCardProps} from './TitleCard';

// A generated plate (still or clip) under the transparent title card from above.
export const PlateTitle: React.FC<TitleCardProps & {plate: string}> = ({plate, ...card}) => {
  const frame = useCurrentFrame();
  const push = interpolate(frame, [0, 150], [1, 1.08]); // slow push-in on a still
  return (
    <AbsoluteFill style={{backgroundColor: '#0b0e14'}}>
      {plate.endsWith('.mp4') ? (
        <OffthreadVideo src={staticFile(plate)} muted />
      ) : (
        <Img src={staticFile(plate)} style={{width: '100%', height: '100%', objectFit: 'cover', transform: `scale(${push})`}} />
      )}
      {/* darken the left side so the text stays readable */}
      <AbsoluteFill style={{background: 'linear-gradient(90deg, rgba(11,14,20,0.9) 0%, rgba(11,14,20,0.15) 75%)'}} />
      <TitleCard {...card} transparent />
    </AbsoluteFill>
  );
};
// add to src/Root.tsx, with the image or clip saved in public/
<Composition id="plate-title" component={PlateTitle} durationInFrames={150} fps={30}
  width={1920} height={1080} defaultProps={{...props, plate: 'plate.jpg'}} />

// render it with a clip instead of the still:
// npx remotion render plate-title out/plate-title.mp4 --props='{"plate":"plate.mp4"}'
A generated plate under the Remotion title layer. The plate cost 3 credits, the composite rendered in 8.1 seconds.

From there one prompt does the whole round trip. Claude picks the model, quotes the price, generates, saves the file and renders.

Generate a 5 second 16:9 plate of a dark server rack with slow camera movement, no text,
with a video model that costs under 20 credits. Show me the price before you run it.
Save the result as public/plate.mp4, then render plate-title with --props='{"plate":"plate.mp4"}'
and show me a still from frame 80 before the full render.

Which route for which job

  • A film, a series, or anything with dozens of clips: Remotion. Shared components, a timing table and transparent layers pay for the setup within the first hour.
  • A 15-second ad or teaser that must match a brand exactly: the HTML route, or HyperFrames if you want it maintained.
  • An explainer you need in the next ten minutes: Claude Motion, if your plan has it.
  • Real-looking footage, a voice, music: Photoproduct, composed in Remotion or the HTML route.
  • A company with more than 3 employees and no budget: the HTML route or HyperFrames. Do not ship Remotion without the license.

Limitations

Claude still cannot judge motion. Stills and contact sheets catch layout problems, but timing, pacing and whether an animation feels right still need your eyes in Studio. Plan for a human pass.

Render cost is real on modest hardware. 2D clips are fast, but 3D and ProRes eat time and disk, and the 4.46 GB hook layer above is not a typo. And Remotion's license is a business decision as much as a technical one, so settle it before a client project, not after.

Agent runbook

This block is written for Claude, and it is what the hand-off prompt at the top points to. Each step has a command, a check, and a stop rule. Every command in it was run on 2026-11-22 against Remotion 4.0.545.

AGENT RUNBOOK: Remotion for Claude Code
Tested 2026-11-22 on Remotion 4.0.545. Source: https://singularitybyte.com/tutorials/claude-remotion-tutorial-videos-with-claude-code.html
Work in a folder that is NOT inside a git repository. Show the user the result of every CHECK.

1. TOOLCHAIN
   RUN    node --version
   CHECK  v20.19 or newer on the 20 line, v22.13 or newer on the 22 line, or v24 and up.
          Older: STOP and ask the user to install Node 22 or 24 LTS.
   RUN    ldd --version | head -1          (Linux only)
   CHECK  glibc 2.35 or newer. Alpine or NixOS: STOP, Remotion does not support them.

2. LINUX LIBRARIES (Debian and Ubuntu only; skip on macOS and Windows)
   This needs sudo. Do NOT run it. Show it to the user and ask them to run it themselves:
   sudo apt install -y libnss3 libdbus-1-3 libatk1.0-0 libasound2t64 libxrandr2 libxkbcommon-dev libxfixes3 libxcomposite1 libxdamage1 libgbm-dev libcups2 libcairo2 libpango-1.0-0 libatk-bridge2.0-0
   (Ubuntu 22.04: libasound2 instead of libasound2t64.) Wait for the user to confirm.
   Other distributions (Arch, Fedora): see https://www.remotion.dev/docs/miscellaneous/linux-dependencies
   and skip this step unless the still in step 7 fails to render.

3. SCAFFOLD
   RUN    npx -y create-video@latest --yes --blank my-video
   RUN    cd my-video
   CHECK  package.json lists remotion and @remotion/cli at the same version.
   NOTE   create-video already ran git init and a first commit in my-video.
          Make no further commits unless the user asks.

4. AGENT SKILLS, BROWSER, FONTS
   RUN    npx remotion skills add
   RUN    npx remotion browser ensure
   RUN    npx remotion add @remotion/google-fonts
   RUN    npx remotion versions
   CHECK  ls .claude/skills shows remotion-best-practices and 12 more.
   CHECK  "Has browser at" was printed, and versions ends with "All packages have the correct version."

5. HOUSE RULES
   WRITE  CLAUDE.md with the exact block from the section "Step 3: give Claude house rules".

6. FIRST COMPOSITION
   WRITE  src/TitleCard.tsx and src/Root.tsx exactly as shown in "Step 4: your first video".
   RUN    rm src/Composition.tsx
   RUN    npx tsc --noEmit
   CHECK  no output.

7. LOOK BEFORE YOU RENDER
   RUN    npx remotion still title-card out/check.png --frame=75 --scale=0.5
   CHECK  read out/check.png: lime kicker, white title, lime bar, grey subtitle, nothing cut off.
          If anything is wrong, fix the code and repeat this step.

8. RENDER
   RUN    npx remotion render title-card out/title-card.mp4 --codec=h264 --crf=18
   RUN    npx remotion render title-card-text out/title-card-text.mov --image-format=png --pixel-format=yuva444p10le --codec=prores --prores-profile=4444
   RUN    ffprobe -v error -select_streams v:0 -show_entries stream=codec_name,width,height,nb_frames -of csv=p=0 out/title-card.mp4
   CHECK  prints h264,1920,1080,150
   NOTE   ffprobe reports the .mov as yuva444p12le although 10-bit was requested. That is normal
          for ProRes 4444: the alpha channel is there.

9. SELF-CHECK TOOL
   WRITE  contact-sheet.sh exactly as shown in "Step 5", then chmod +x contact-sheet.sh
   RUN    ./contact-sheet.sh
   CHECK  read out/contact-sheet.jpg: two tiles, the same card twice (the alpha one on black).

10. PREVIEW
   RUN    npm run dev   (long-running: start it in the background)
   DONE   Tell the user the Studio URL and the paths of both renders. Ask what video to make next.

Your next 10 minutes

Open an empty folder, start Claude Code, and paste the hand-off prompt from the top of this page. Ten minutes later you have Studio running, a 5-second card rendered twice, and the self-check loop in place. Then ask for the video you actually wanted, and make Claude show you the stills first.

New to Claude Code itself? Start with our Claude Code tutorial. For more on the generation side, see how one MCP endpoint gives an agent image, video and music and what an agent needs from a generation API. If you want open video models you can run yourself, our mid-2026 open video model check has the current state.

Sources and further reading

Tested on: Intel Core i7-1065G7 (4 cores, no discrete GPU) · 30 GB RAM · Omarchy Linux (Arch, kernel 7.2) · Remotion 4.0.545, Node 26.12, Chromium 155, FFmpeg 9.0.2. Film figures: a 6 vCPU Intel Core i7-7700T VM · 16 GB RAM · Debian 13 · no GPU · Remotion 4.0.534.
Date tested: 2026-11-22

Frequently asked questions

Is Remotion open source?

No. Remotion is source-available under the Remotion License. It is free for individuals, for-profit companies with up to 3 employees, non-profits and anyone evaluating it. Everyone else needs a company license, from $25 per seat per month, or $0.01 per render with a $100 monthly minimum for automated rendering. If you need an OSI license, HyperFrames (Apache 2.0) or a plain HTML plus headless Chromium renderer do the same job.

How do I add Remotion to Claude Code?

Scaffold a project with npx create-video --yes --blank my-video, then run npx remotion skills add inside it. That installs 13 official skills into .agents/skills and symlinks them into .claude/skills, where Claude Code finds them. Remotion also publishes a Claude Code plugin through the remotion-dev/claude-code-plugin marketplace if you want the skills in every project.

Do I need to install FFmpeg or Chrome for Remotion?

No. FFmpeg ships inside Remotion's compositor package, and npx remotion browser ensure downloads Chrome Headless Shell (102.5 MB) into the project. On Linux you still need a set of shared libraries and glibc 2.35 or newer. Alpine and NixOS are not supported.

Can Claude see the video it renders?

Not as video, but it reads images well. The working loop is stills: npx remotion still renders any frame as a PNG in about two seconds, Claude opens it, fixes what is wrong and only then renders the full video. For many clips, a contact sheet with one frame per clip does the same job in a single image.

Should I use Remotion or HyperFrames?

Both render by seeking each frame in headless Chrome and encoding with FFmpeg. Remotion uses React components, has 74,944 GitHub stars and is source-available. HyperFrames uses plain HTML with seekable animations, is Apache 2.0 and has 88,218 stars. Pick Remotion for large React-based productions, and HyperFrames when the license matters or you would rather write HTML.
Prev Article
Build a Local Voice Assistant on Nemotron 3.5 Bolt E4B
Next Article
How to create Logos with Midjourney

Related to this topic: