Remotion 4.0.542 best practices: seed random() so renders match, keep GPU-heavy CSS off cloud machines, use JPEG unless you need alpha and benchmark concurrency. ReelSDK renders captions at $0.03 a minute.

What are Remotion best practices?

Wrap scenes in <Sequence>, load assets with staticFile(), and resolve every delayRender() within 30 seconds or the render fails. At $0.03 a minute, ReelSDK renders captions and slideshows with none of this to tune.

LearnUpdated

At a glance

Remotion best practices at a glance

Each habit, why it matters and the API or flag behind it.

Remotion best practices at a glance
PracticeWhy it mattersAPI or flag
Place scenes on the timelineGives each scene a start and duration<Sequence>
Load project assets from publicUses Remotion's asset-loading patternstaticFile()
Use seeded randomnessAvoids different random values across render threadsrandom(seed)
Benchmark concurrencyFinds the fastest setting for your machinenpx remotion benchmark, --concurrency
Inspect slow framesShows which frames take longest--log=verbose
Render smaller when neededProduces smaller rendered dimensions--scale

Sources: Remotion performance tips, Remotion Sequence, Remotion random(), checked November 2026.

Structure scenes with Sequence and Series

Use <Sequence> to place scenes on your timeline, with from setting where a scene starts and durationInFrames setting how long it runs. Inside that sequence, frame 0 is the start of the scene, not the start of the whole video.

Keep that distinction in mind when you write animation code inside a scene. Work from the scene's local frame rather than treating it as the composition's frame. The sequence handles its placement on the timeline.

For scenes that play one after another, use <Series>. You don't need to place each scene separately when what you want is a continuous run of scenes.

Which should you reach for? Use <Sequence> when you're placing a scene at a particular point, and <Series> when you're arranging scenes to play in order.

Load assets the Remotion way

Put your assets in the public folder next to package.json, then reference them with staticFile(). Use that pattern for assets you keep with the project.

For video, use <Video> from @remotion/media for the best rendering performance.

Load fonts with loadFont() from @remotion/google-fonts, and pass the weights and subsets you need so it only loads those.

Fetch data in calculateMetadata or use delayRender() to hold the render while it loads. The recommended hook is useDelayRender().

A pending delayRender() must be cleared within 30 seconds by default, or the render fails. Don't leave it hanging. When you review data-loading code, check both where the render gets delayed and where that delay gets cleared, rather than stopping at the fetch itself.

Keep renders deterministic

Use random(seed) instead of Math.random(). Math.random() returns different values on different render threads, so it isn't the right choice for randomness that needs to stay consistent across a render.

You can still use random choices in your video. Make those choices through random(seed), with an explicit seed, rather than calling Math.random() wherever you need a value.

Check the scene code as well as any helpers it calls. If a helper supplies random values for a scene, use the seeded API there too.

And keep data fetching in the loading paths above, rather than mixing it into the code that describes each frame.

Make renders faster

Run npx remotion benchmark to find the fastest --concurrency for your machine. Use the benchmark's result instead of picking a concurrency value by guesswork.

Check where you're rendering, too. On cloud machines without a GPU, avoid GPU-heavy CSS such as box-shadow, text-shadow, gradients and blur filters, along with WebGL; precompute those effects as images instead.

For frame output, render JPEG unless you need transparency. PNG is slower. If you do need transparency, that's the reason to keep PNG rather than switching every render to JPEG.

Keep frame format and output codec separate in your settings. H.264 is the default codec; H.265, VP8, VP9, AV1 and ProRes are also available. VP8 and VP9 encode slowly, so account for that when choosing your output.

Use --scale when you want to render smaller. To inspect slow frames, run with --log=verbose, which shows the slowest frames. Look there when you need to identify which frames are taking the longest, rather than changing settings without checking.

Use the official AI skill

If you're using an AI coding agent, install the official agent skills with npx skills add remotion-dev/skills. Use the official package rather than substituting an unrelated skill with a similar name.

Running renders yourself is a separate choice. If you'd rather not, ReelSDK renders captions and slideshows from JSON at $0.03 per output minute.

FAQ

Questions, answered

Should I use Sequence or Series?

Use <Sequence> to place a scene at a chosen point on the timeline. Use <Series> to play scenes one after another.

Why does my data-loading render time out?

A delayRender() must be cleared within 30 seconds by default, or the render fails. Check that your loading code clears it; useDelayRender() is the recommended hook.

What's the fastest concurrency setting?

Find it for your machine with npx remotion benchmark. Use the result to choose --concurrency.

Should I render JPEG or PNG frames?

Use JPEG unless you need transparency. PNG is slower.

Ready to build?

Ship video from your app today

Your first $0.50 is free, and one key covers every endpoint.

Moonlit lake with a lit cabin under the mountains