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.
SingularityByte.com values the privacy of our users. Therefore, this privacy policy explains in detail how we use and protect the information we collect when you visit our website.. Read this privacy policy completely. Please refrain from visiting the site if the terms outlined below are not satisfactory to you. We reserve the right to change this policy at any time and will list these changes in the updates section of the policy. By reading this notice and visiting the site, you agree that you understand that customers will not be personally notified when this policy changes. Therefore, we advise our customers to frequently review our privacy policy so that they remain aware of its updates. By using the site, you accept that the posted policy and all its changes apply to your interaction with SingularityByte.com.
Information Collected by SingularityByte.com
Personal information may be collected by this site in many ways. This information includes:
Personal identifying information like your name, address, email, phone number, age, gender, and other personal data
Server data related to the IP address you used to visit our website, which includes your address, browser, OS, access time, and site activity.
Financial information related to your orders including your payment method and identifying payment information. We rarely store financial information collected on our site for transaction purposes. That information gets sent directly to our payment processor.
Social network data including Facebook permissions and user information from other networks, provided you log onto our site using one of these media sites.
Mobile device information such as your device ID, model, and location, if you use our site by accessing trough our website.
How We Use This Information
Our website uses information collected to: • Manage your account information • Customize ads • Deliver promotions • Email your account confirmation • Manage purchases and payments • Increase site efficiency • Notify you of updates • Offer new products • Monitor and prevent theft • Request your customer feedback • Resolve account disputes • Respond to your service requests
Information Disclosure
Normally, your information stays on our site. However, below we have listed the situations that may require us to share the information we collect from you: • When required by law, such as for fraud protection • With our third-party providers for payment processing and hosting • With your consent for marketing purposes • When you post comments on the site • To our advertisers, affiliates, and partners • If this site goes bankrupt and data must be transferred
Cookies, Trackers, and Online Ads
We may use cookies, trackers, web beacons, and other technology to customize our website to improve your experience. We may customize the site using this information. These trackers do not have access to your personal information and can be removed from your browser options. In addition, third-party software provides ads for our site for marketing campaigns. These programs have access to tracking technology to optimize your ad experience. For more information about these ads, visit [link to the privacy policies of affiliate advertisers]. Website analytics such as through Google Analytics may also be used to track users and remarket our website. We do not give these vendors access to your personal information.
Other Sites
Our website may contain links to third-party websites in the form of policies, ads, and other non-affiliated links. Once you leave our site, we are no longer responsible for how your information is collected and disclosed. Please refer to the privacy policies of those third-party sites for more information.
Information Security
We take technical and administrative precautions to protect your data, but we cannot guarantee its safety against all types of fraud or misuse. If you provide personal information, we cannot verify its total security against all types of interception.
Do-Not-Track
Some browsers offer Do-Not-Track settings to prevent any information from being distributed. Since these settings have not been legally established as standard practice, we do acknowledge these settings.
Additional Options
At any time, you may opt to review or change your account settings, including contact information. If you wish to delete your account, you may do so to remove most of your information, however, some identifying information will be retained to prevent fraud. You may also opt-out of emails and other correspondences from our site at any time.
Microsoft Clarity
We partner with Microsoft Clarity and Microsoft Advertising to capture how you use and interact with our website through behavioral metrics, heatmaps, and session replay to improve and market our products/services. Website usage data is captured using first and third-party cookies and other tracking technologies to determine the popularity of products/services and online activity. Additionally, we use this information for site optimization, fraud/security purposes, and advertising. For more information about how Microsoft collects and uses your data, visit the Microsoft Privacy Statement.
Contact Us
If you have questions or concerns about this privacy policy, please feel free to contact us at: desk@SingularityByte.com
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.
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.
Route
License
Setup
Best for
How Claude drives it
Cost
Remotion
Remotion License (source-available)
Node, about 570 MB per project with the browser
Long films, many clips, data-driven video, 3D, transparent layers
React code, 13 official skills
Free up to 3 employees, then from $25/seat/month
HTML + headless Chromium
Your own code
Chromium, Node 22+, FFmpeg
Short ads and teasers, brand-exact one-offs
Plain HTML and JavaScript
Free
HyperFrames
Apache 2.0
Node 22+, one skills command
The HTML route as a maintained framework
Skills, plus a Claude connector
Free (optional paid app)
Claude Motion
Part of claude.ai
None
A quick animated explainer inside a chat
Built in, type /motion
Team or Enterprise plan
Photoproduct
Hosted service
One MCP connection
Footage, voice and music that code cannot draw
MCP tools, 1,717 models
Per 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.
Skill
What it teaches Claude
remotion-best-practices
The router: which of the others to load for a task
remotion-create
Starting a project or a new composition
remotion-markup
The big one: 33 topic files on timing, sequencing, fonts, audio, 3D, transitions, motion blur, video editing
remotion-render
Exporting video, stills, or an OpenTimelineIO timeline for an editor
remotion-studio
Opening the live preview
remotion-interactivity
Writing markup that stays editable in Studio
remotion-captions
Transcribing, showing and animating captions
remotion-maps, -multimedia, -saas
Map animations, browser media processing, building an app around Remotion
remotion-docs, -license, -upgrade
Searching 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.
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)
Time
File size
Still, half size
2.1 s
37 KB PNG
H.264, 1920x1080
5.1 s
99 KB
H.264, 3840x2160 (--scale=2)
11.4 s
259 KB
ProRes 4444 with alpha, 1920x1080
10.5 s
41 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"
Chapters with picture notes and a source for every claim
Claude writes, a human approves before anything is generated
Spoken text
A Python lint turns the script into what the voice reads and blocks unknown audio tags
Script
Voice
One take per chapter with a text-to-speech model
Claude, over MCP
Alignment
FFmpeg silencedetect finds the pauses and fits sentence ends to them. No Whisper needed.
Script
Timing
One timing.ts table drives the clips, the music fit and the edit
Generated
Picture
One Remotion composition per clip, text layers rendered transparent
Claude
Check
Stills, contact sheets, a 720p preview mix with measured loudness
Claude
Edit
A Final Cut Pro 7 XML rough cut that opens in Premiere, plus a footage folder
Claude 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.
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.
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.
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