Batch Video Generation: 200 Personalized Remotion Renders from One CSV

Batch video generation in Claude Code means binding a dataset to one parametrized Remotion composition and rendering one variant per row. With VideoKit you run /video data usage.csv to type and validate the dataset, build a parametrized template keyed on row props, then /video render --batch usage.csv to fan out every row — locally for small batches or on @remotion/lambda for hundreds in parallel. Two hundred personalized renders come from one composition and 200 data rows, not 200 hand-built videos. This post walks the complete pipeline, naming conventions, cost behavior, and the provenance policy that governs every asset VideoKit touches.

What makes Remotion the right substrate for batch video?

Remotion is React-based video: every frame is code, every render is reproducible, and every variant is a parameter. That is exactly the property batch generation needs. A composition is a function of its props; change the props, change the video. Build the template once, pay the design cost once, then each additional row is a prop-swap and some compute.

VideoKit ships 17 commands, 5 skills, and 3 read-only specialist agents at 12,602 measured tokens. The five skills cover scaffolding, composition patterns, captions, data visualization, and Lambda fan-out. The three agents operate as read-only auditors — a visual QA reviewer, a timing validator, and a provenance auditor — none of them block or require approval. Commands end with a verified output file, not a gated review queue.

No major free skill repo covers Remotion beyond its own rule files. That whitespace is the reason VideoKit exists. If you want to understand how it compares to assembling your own setup, the VideoKit vs. free prompt packs comparison is worth reading before you start.

How does the batch pipeline actually work?

Two commands drive a data-driven batch. The first builds the template; the second renders the matrix.

Step 1 — Bind and validate the dataset

/video data <file> starts with video-data running data-binding logic that attaches composition props to CSV or JSON rows with typed schema validation. This is blocking on schema errors — a malformed row fails fast, before you render 200 broken videos. From there, VideoKit chooses chart types per beat and maps data fields to a timeline.

The data-driven skills that animate numbers run in parallel where independent: bar charts, line charts, bar race, and counter-stat animations. A composer and scene sequencer assemble them into a master timeline; a motion-design skill tunes the reveal springs so the result does not look robotic.

Step 2 — One parametrized template

The output of step 1 is a single composition whose props are the dataset's columns. In a year-in-review use case — a 20-second video personalized per customer — you build one template keyed on customer props. Visual QA scores the template once, not every render. You QA the template; the rows inherit it.

Step 3 — Fan out the renders

/video render --batch <file> is where scale happens. The render command gates first — timing validation and frame QA run, and the render is refused below score 90, with up to three fix iterations before you see an error. Then a performance-profiling step sets safe concurrency and memory. The render target is picked automatically:

1. Local render — for a single render or a small batch on your machine; costs cores and time, no cloud bill.
2. Batch render — fans one composition over a CSV/JSON matrix; rows render in parallel on local hardware.
3. Lambda render — cloud fan-out via @remotion/lambda; site deploy, function, concurrency; scales to hundreds of renders; costs real cloud compute.

# Build the parametrized template from a dataset
/video data usage.csv
 
# Render every row; choose local for small batches, Lambda for hundreds
/video render --batch usage.csv --target lambda

/video demo handles a different use case — a single polished product walkthrough with click-and-type simulation — so do not confuse the two. For repurposing one long-form piece into many formats instead of rendering a data matrix, /video repurpose and the content repurposing matrix post cover that path.

What naming conventions survive a 200-row batch?

A 200-render batch is only useful if you can find render 147 in six months. VideoKit keys outputs off the dataset, so adopt a deterministic naming scheme from a stable column from the start.

Three practical rules to lock in before you kick off a big batch:

1. Name from a unique key, not row index. If your CSV has a customer_id or slug column, render to out/batch/<customer_id>.mp4. Row index breaks the moment you re-sort the CSV or add a row.
2. Encode the variant in the filename. For multi-format batches, suffix the aspect ratio: <key>-9x16.mp4, <key>-1x1.mp4. VideoKit supports 9:16, 1:1, and 16:9 from one source composition, so the suffix maps cleanly to the preset.
3. Emit a poster per render. React-based thumbnail rendering produces a still per MP4, keyed the same way — essential for building a review contact sheet across 200 videos without downloading every clip.

Deterministic names mean a re-run overwrites cleanly and a partial failure is trivially resumable: render only the keys that are absent in the output directory.

How much does a 200-render batch actually cost?

Cost has two distinct parts, and conflating them is the usual mistake.

Build cost (tokens). Designing the template is the token-heavy phase. A 50-customer example lands at roughly 52,000 tokens for the build and negligible cost per additional render after that. That is the whole economic point of parametrization: you pay the design cost once, then each additional row is cheap. Check the build cost before you start with ck tokens video, which reports measured context cost using VideoKit's token ledger (12,602 tokens for the full kit install).

Render cost (compute). Rendering is compute, not tokens. Local renders cost machine time and cores. Lambda renders cost cloud compute that scales with concurrency and clip length. The concurrency-tuning step exists specifically to cap that — right-sizing concurrency and memory for your local cores or your Lambda budget so a 200-render fan-out does not surprise you on the bill. For a large batch, set the concurrency cap deliberately rather than letting it default.

The honest framing: parametrization makes the marginal video cheap, but a 200-render Lambda batch is still real cloud spend. Budget the build in tokens and the render in compute, separately.

What makes a template that survives 200 different rows?

The template is where a batch succeeds or fails, because every weakness is multiplied by your row count. Two design principles matter most.

Every variable must have a safe default and a safe range. A name field that overflows the title bar at 30 characters will overflow on row 47 even if rows 1 through 46 look fine. VideoKit types composition props with a Zod schema, so out-of-range data fails at bind time rather than rendering a broken frame at row 47 of a 200-render batch.

The layout must reflow, not assume. A bar chart sized for a three-item dataset breaks on a row with seven items. Responsive layout composition makes a template reflow safely across content and aspect ratios. QA-ing the template against your widest and narrowest rows — not just the first row — is the single highest-leverage thing you can do before a large fan-out.

A template that passes QA at 94 on a representative edge case is a good template. A template that passes at 94 on row 1 but was never tested on the outlier rows is a liability.

How does failure handling work on a partial batch?

A 200-render batch will occasionally have a failed render — a transient Lambda error, a malformed row that slipped past validation, a timeout. The deterministic naming scheme is what makes this cheap to recover from: because each output is keyed to a stable dataset column, a failure leaves a precise gap. You re-run the batch filtered to the missing keys rather than re-rendering all 200.

Progress logging wires render callbacks for CI and dashboards, so you can see which rows completed and which need a retry without manually diffing the output directory. The combination — typed props that fail fast at bind time, deterministic keys, and progress logging — turns a batch from an all-or-nothing gamble into a resumable job.

If the whole composition fails QA (score below 90), the render command surfaces up to three fix iterations before returning an error. This means the most common failure mode — a layout bug that shows up in every render — is caught before a single frame renders rather than after 200 bad videos have been produced.

What is VideoKit's provenance policy for batch assets?

VideoKit only handles user-owned, royalty-free, or original Remotion compositions. It never processes copyrighted source video. Every ingestion skill validates provenance before touching a file — checking license metadata, asking you to attest ownership or paste a royalty-free license URL, and logging the attestation into the project manifest. If provenance cannot be established for an imported clip, image, font, or audio track, the skill halts and returns a provenance error rather than rendering it.

A project-level provenance audit sweeps the entire composition tree to flag any asset with no license record. This is not a disclaimer bolted on at the end — it is enforced at every point an external asset would enter the pipeline. For a batch, that means the data and the visual assets are yours or licensed; VideoKit will not render a clip it cannot account for.

This matters more for batch jobs than for single renders because the surface area is larger. A single unlicensed font used in the template will fail provenance on all 200 renders simultaneously. Audit provenance on the template before you kick off the matrix.

How does VideoKit fit into the broader ClaudeKit lineup?

VideoKit at /video is one of five kits. The full lineup as of June 2026:

All 13 agents are read-only specialists — auditors, reviewers, and researchers. None of them block execution or require approval. Commands produce evidence (a verified output file, a diff, a report) and stop there. If you want to understand the architecture that replaced the old reviewer-gate model, the blocking reviewer gate post explains the reasoning.

Installing VideoKit takes two commands:

ck auth <your-key>
ck install video

Or through the Claude Code plugin marketplace: /plugin marketplace add Madni-Aghadi/claudekit-video. The token ledger prints on every install so you see exactly what loads. ck doctor diagnoses path or auth issues; ck list shows what you have active.

Pricing for VideoKit alone is $14.99/month or $99 one-time. Pro ($29.99/month) gives you any three kits with one swap per cycle. All-Access ($49.99/month) covers all five. All plans include 3 devices and a 14-day refund window. Full pricing detail is at /pricing.

If your goal is repurposing rather than batch data rendering — taking one long video and cutting it into clips, captions, social formats, and a newsletter — VideoKit's /video repurpose command covers that path. The 12-asset repurposing matrix shows what one video can produce.

FAQ

How many videos can one CSV produce?

As many as the CSV has rows. The composition is parametrized, so 200 rows yield 200 renders from one template. The ceiling is your dataset size and your render budget, not VideoKit. The documented year-in-review example uses 50 customers; batches over 100 rows are where Lambda fan-out becomes worth the setup cost.

Does batch rendering cost 200x the tokens?

No. The token cost is concentrated in building the template — roughly 52,000 tokens in the 50-row example — and is negligible per additional render after that, because each row only swaps props into a composition that is already built. Rendering itself is compute (local cores or Lambda), not token spend. Budget the two separately; ck tokens video shows you the kit's baseline install cost (12,602 tokens) before you start the build phase.

Should I render locally or on Lambda?

Local rendering suits batches under roughly 20 to 30 clips and costs only machine time. Lambda renders hundreds of clips in parallel and costs cloud compute that scales with concurrency and clip length. The concurrency-tuning step that runs automatically before every batch render is worth reviewing before large Lambda jobs — it sets a safe cap, but you can override it if your Lambda budget or account limits require a lower ceiling.

What happens if 10 renders in a 200-clip batch fail?

Because outputs are keyed to a stable dataset column rather than row index, failures leave a precise gap in the output directory. Re-run the batch filtered to the missing keys. Progress logging records which rows completed and which did not, so you do not need to diff the directory manually. No need to re-render the 190 that succeeded.

Does VideoKit work with data formats other than CSV?

Yes. The /video data command accepts both CSV and JSON. JSON is useful when your dataset is already in an application format or has nested structure that does not flatten cleanly to CSV. Either format is typed and validated at bind time, so schema errors surface before rendering begins.

Can I generate videos for clients using their footage?

Only if the footage is user-owned, royalty-free, or original. VideoKit's provenance gate validates every external asset before it enters a composition and logs the attestation in the project manifest. If provenance cannot be established, the ingestion skill halts with an error. Attempting to batch-render a composition that includes an unlicensed asset will fail on provenance validation before any frames are rendered.

If batch video generation is part of your workflow — personalized onboarding clips, per-account year-in-review videos, data-story social cuts, or variant testing at scale — VideoKit at /video is the most complete Remotion-focused Claude Code kit available. The 17 commands, 5 skills, and 3 read-only auditors cover the full pipeline from dataset binding through Lambda fan-out, with typed validation and provenance enforcement at every step. Install takes under two minutes and the token ledger tells you exactly what you are loading.