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.

Seconds to transcode a 10-second 1080p clip to 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.

ffmpeg.wasm and ReelSDK, what the same transcode costs
OptionWho paysThis clip1,000 clips
ffmpeg.wasm, single-threadThe visitor's device$0, 79 s in the tab$0
ffmpeg.wasm, multithreadedThe visitor's device, page served with COOP and COEP$0, 52 s in the tab$0
ReelSDK ffmpegYou, $0.02 per compute minuteUnder 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 and ffmpeg.wasm compared
ReelSDKffmpeg.wasm
Where it runsOur servers; this job ran on 4 vCPUsIn the visitor's browser tab
This clip8 s end to end, of which 4.1 s was ffmpeg79 s single-thread, 52 s multithreaded
Memory500 MB per input, 1 GB per job2 GB, a hard limit in WebAssembly
ThreadsNothing to set upSharedArrayBuffer only, so COOP same-origin and COEP require-corp on the page
FFmpegffmpeg 8.1@ffmpeg/core 0.12, built from FFmpeg 5.1
DownloadNone32 MB core per visitor, unless cached
Server-side useAny language over HTTPBrowser only; no Node.js support since 0.12.0
LicensePay per useMIT wrapper, GPL-2.0-or-later core
Limits3 concurrent jobs, 500 a day per key, 10-minute runsWhatever 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

ffmpeg-wasm.mjs
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

reelsdk.mjsTry it
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 fields and their ReelSDK equivalents
ffmpeg.wasmReelSDK
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
-threadsOptional; by default ffmpeg uses every core the job gets
COOP and COEP headersNot 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

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