ReelSDK vs ffmpeg.wasm: 8 s at $0.02 a minute vs 79 s free
An ffmpeg.wasm alternative: a 720p transcode in 8 s, not 52 to 79 s, for under a fifth of a cent
ReelSDK runs that transcode on a server in 8 seconds end to end, for under a fifth of a cent at $0.02 per compute minute. ffmpeg.wasm runs FFmpeg in the browser for free, so your visitor's device pays instead: a 32 MB core download, a 2 GB memory ceiling, and on 2 CPUs 79 seconds single-threaded, or 52 seconds multithreaded with COOP and COEP headers, to turn a 10-second 1080p clip into 720p.
- ReelSDK API, request to finished file8 s
- Native ffmpeg on the same 2 CPUs9.3 s
- ffmpeg.wasm, multithreaded, -threads 252 s
- ffmpeg.wasm, single-thread79 s
Measured with @ffmpeg/core 0.12 in headless Chromium 158 on a shared host limited to 2 CPUs, best of two runs. Same input and arguments; every output came out at about 3.2 MB.
Which one to pick
Pick ReelSDK if
- Your users are on phones or cheap laptops, or files can pass what a tab can hold: ffmpeg.wasm stops at 2 GB
- You don't want to ship a 32 MB core, or serve your site with COOP and COEP headers just to get threads
- You want the same ffmpeg arguments to finish in seconds on a server, at $0.02 per compute minute, with inputs up to 500 MB
Pick ffmpeg.wasm if
- The file must never leave the user's device, for privacy or for offline use
- You want no server bill at all: the visitor's CPU does the work and the library is free
- Jobs are small, like trimming a clip or grabbing a frame, and a few seconds of waiting in the tab is fine
Price per minute
ffmpeg.wasm and ReelSDK, what the same transcode costs
ffmpeg.wasm costs you nothing per job because the work happens on your visitor's device; the price is their time, battery and a 32 MB download. ReelSDK bills raw ffmpeg at $0.02 per compute minute, by the second, with failed jobs free; see the pricing page. The job is a 10-second 1920x1080 clip scaled to 720p with libx264 at crf 23.
| Option | Who pays | This clip | 1,000 clips |
|---|---|---|---|
| ffmpeg.wasm, single-thread | The visitor's device | $0, 79 s in the tab | $0 |
| ffmpeg.wasm, multithreaded | The visitor's device, page served with COOP and COEP | $0, 52 s in the tab | $0 |
| ReelSDK ffmpeg | You, $0.02 per compute minute | Under a fifth of a cent for 4.9 s of compute | $1.64 |
Times are from our test on 2 CPUs. ffmpeg.wasm's own benchmark of a 10 s 720p webm shows the same gap: 5.2 s native, 60 s multithreaded and 129 s single-threaded. Prices from ffmpeg.wasm performance, checked November 2026.
Head to head
ReelSDK and ffmpeg.wasm, feature by feature
| ReelSDK | ffmpeg.wasm | |
|---|---|---|
| Where it runs | Our servers; this job ran on 4 vCPUs | In the visitor's browser tab |
| This clip | 8 s end to end, of which 4.1 s was ffmpeg | 79 s single-thread, 52 s multithreaded |
| Memory | 500 MB per input, 1 GB per job | 2 GB, a hard limit in WebAssembly |
| Threads | Nothing to set up | SharedArrayBuffer only, so COOP same-origin and COEP require-corp on the page |
| FFmpeg | ffmpeg 8.1 | @ffmpeg/core 0.12, built from FFmpeg 5.1 |
| Download | None | 32 MB core per visitor, unless cached |
| Server-side use | Any language over HTTP | Browser only; no Node.js support since 0.12.0 |
| License | Pay per use | MIT wrapper, GPL-2.0-or-later core |
| Limits | 3 concurrent jobs, 500 a day per key, 10-minute runs | Whatever the device and the tab allow |
Be honest
Where ffmpeg.wasm is the better choice
Privacy and offline use
With ffmpeg.wasm the file never leaves the device, which matters for medical, legal or personal video and for apps that work offline. ReelSDK fetches your inputs over HTTPS and keeps outputs for 7 days.
No server bill
Every job runs on the visitor's CPU, so a million transcodes cost you the same as one. If your users can wait and your files are small, nothing is cheaper than free.
No upload for small edits
Trimming a phone video or grabbing a thumbnail in the tab skips uploading the whole file first, which on a slow connection can take longer than the edit itself.
Migration
Moving a render from ffmpeg.wasm
Keep your ffmpeg arguments and move them from ffmpeg.exec() to the args of POST /v1/ffmpeg, with the input as a URL instead of writeFile(). The request below returned the 720p mp4 in 8 seconds, the same 3.2 MB as the wasm output, and cost under a fifth of a cent. See the output. In the browser, call your own backend so the API key stays secret.
ffmpeg.wasm today
import { FFmpeg } from "@ffmpeg/ffmpeg";
import { fetchFile } from "@ffmpeg/util";
// Loads the 32 MB core into the tab; multithreading also needs COOP and COEP headers
const ffmpeg = new FFmpeg();
await ffmpeg.load();
await ffmpeg.writeFile("in.mp4", await fetchFile("https://api.reelsdk.com/f/lib/demo/landscape.mp4"));
await ffmpeg.exec(["-i", "in.mp4", "-vf", "scale=-2:720", "-c:v", "libx264", "-crf", "23", "-c:a", "copy", "out.mp4"]);
const data = await ffmpeg.readFile("out.mp4");
const url = URL.createObjectURL(new Blob([data.buffer], { type: "video/mp4" }));
The same render on ReelSDK
const res = await fetch("https://api.reelsdk.com/v1/ffmpeg?wait=60", {
method: "POST",
headers: { Authorization: `Bearer ${process.env.REELSDK_KEY}`, "Content-Type": "application/json" },
body: JSON.stringify({
"inputs": {
"in.mp4": "https://api.reelsdk.com/f/lib/demo/landscape.mp4"
},
"args": [
"-i", "in.mp4", "-vf", "scale=-2:720", "-c:v", "libx264", "-crf", "23",
"-c:a", "copy", "out.mp4"
],
"outputs": ["out.mp4"]
}),
});
const { job } = await res.json();
// 200 OK after 8.0 s, trimmed
// {
// "job": {
// "id": "job_jb6ia9o60tlwovt4f5xn",
// "op": "ffmpeg",
// "status": "succeeded",
// "duration_s": 9.766,
// "outputs": { "out.mp4": "https://api.reelsdk.com/f/out/job_jb6ia9o60tlwovt4f5xn/out.mp4?s=..." }
// }
// }Field by field
| ffmpeg.wasm | ReelSDK |
|---|---|
ffmpeg.load() | Nothing to load |
ffmpeg.writeFile(name, data) | inputs: { name: url }, or upload first with POST /v1/uploads |
ffmpeg.exec(args) | args, the same array |
ffmpeg.readFile(name) | outputs: the names you want back, as download URLs |
-threads | Optional; by default ffmpeg uses every core the job gets |
| COOP and COEP headers | Not needed |
FAQ
ReelSDK vs ffmpeg.wasm, answered
Why is ffmpeg.wasm so slow?
Its core is FFmpeg compiled to WebAssembly with assembly turned off, so it loses the hand-tuned code that makes native ffmpeg fast. In our test it took 79 seconds single-threaded and 52 seconds multithreaded for a clip native ffmpeg encoded in about 9 seconds on the same 2 CPUs. Its own benchmark shows native at 5.2 s against 60 s and 129 s.
How do I enable multithreading in ffmpeg.wasm?
Load @ffmpeg/core-mt instead of @ffmpeg/core and serve the page with Cross-Origin-Opener-Policy: same-origin and Cross-Origin-Embedder-Policy: require-corp, so the browser allows SharedArrayBuffer. In our test it also helped to set -threads 2: with the default thread count the job had produced nothing after 280 seconds, twice.
What is the file size limit of ffmpeg.wasm?
2 GB, which the project calls a hard limit in WebAssembly. ReelSDK takes inputs up to 500 MB each and 1 GB per job.
Can I keep using my ffmpeg commands with ReelSDK?
Yes. POST /v1/ffmpeg takes the same arguments with ffmpeg 8.1, with inputs as URLs and outputs as file names. Network access, absolute paths and filters outside the 469 on the allowlist, such as movie, are blocked, and a job runs for up to 10 minutes.
Other comparisons
Sources, checked November 2026
Ready to build?
Ship video from your app today
Your first $0.50 is free, and one key covers every endpoint.
