What is CRF and what value should I use?

Constant Rate Factor — H.264's quality knob. 0 is lossless, 51 is worst, and 23 to 28 is the typical sweet spot. The default here is 28 (visually nearly identical, 30~60% smaller). Use 18 to 22 for archival-grade quality, 30 to 32 for messenger-friendly small files.

Compress Video

Lower the resolution and quality to shrink the file size — for email, messengers, and social media attachments.

Your video never leaves your browser. All processing happens locally via ffmpeg.wasm (WebAssembly).

First use: the video processing engine (ffmpeg.wasm, ~32MB) downloads automatically. Wi-Fi recommended. After that, it's cached in your browser and starts instantly.

📱 Mobile: we recommend videos at 720p or below and under 1 minute — for larger files, desktop Chrome is more reliable.

Drag a video file here, or click to choose

MP4 · MOV · WebM · MKV · AVI — recommended ≤ 500MB (mobile) / ≤ 1GB (desktop)

Resolution

Quality (CRF — lower means higher quality)

Recommended: 26~30 (visually near-identical, 30~60% smaller). 18 = nearly lossless, 35 = aggressive compression.

Audio handling

File-size guide by resolution and CRF

Estimated for a 5-minute 1080p source (~250MB). Actual size depends on video complexity (motion, detail).

Resolution	CRF	Estimated size	Use case
1080p	23	180~220MB	Archival / YouTube upload
1080p	28	80~120MB	Web default — visually lossless
720p	28	40~60MB	Plenty for messaging and social
720p	32	20~35MB	Close to email attachment limit (25MB)
480p	30	15~25MB	Messenger / preview clips

Why is the file bigger than a desktop app at the same CRF?

Even with an identical quality setting (CRF), the final file size depends heavily on how long the encoder is allowed to think. ffmpeg's -preset option controls that effort, ranging from ultrafast to veryslow — slower presets pack the same quality into a smaller file.

This tool encodes with libx264 -preset ultrafast. The fast preset is chosen for speed. Static hosting such as GitHub Pages cannot send the Cross-Origin-Opener-Policy / Cross-Origin-Embedder-Policy headers, so the browser disables SharedArrayBuffer and ffmpeg.wasm can only run single-threaded. With no multithreading, a slow preset could push a 5-minute clip to tens of minutes, so the tool favors a realistic wait time over maximum compression.

So here are realistic expectations. On desktop Chrome, encoding runs at roughly 0.3–1× the clip's duration (a 5-minute clip usually takes 1–3 minutes); mobile is about 2–3× slower. iOS Safari caps memory at around 500MB per tab, so long 1080p videos may stall midway.

The takeaway: it's normal for this tool to shrink less than a dedicated desktop app (e.g. HandBrake) at the same CRF. If you need a smaller file, raising the CRF a notch or two (e.g. 28→30) or dropping the resolution to 720p or below is the most reliable lever in this environment.

Related tools

Why does the first run download ~32MB?

Unlike images, videos can't be re-encoded with native browser APIs — we need ffmpeg.wasm, a WebAssembly build of ffmpeg. The core engine (~32MB) is downloaded once and cached in IndexedDB so subsequent visits start instantly. The video itself never leaves your device.

Can I close the page mid-compression?

Closing the page cancels the in-progress job. The downloaded ffmpeg library stays cached, so the next visit reuses it without redownloading.

Why isn't multi-threaded (faster) processing supported?

Static hosts like GitHub Pages can't set Cross-Origin-Opener-Policy / Cross-Origin-Embedder-Policy headers, which disables SharedArrayBuffer. That forces single-threaded execution — safe but slower (about 0.3 to 1× the source duration). For faster processing, use desktop and downscale to 720p or lower.

iOS Safari hangs on large videos.

iOS Safari caps single-tab memory at around 500MB, so 1080p videos longer than ~30 minutes may be force-killed. On mobile, stick to 720p or below + 5 to 10 minutes; use desktop for larger files.

Frequently asked questions

Is my video uploaded to a server?

No. The video is processed entirely in your browser via ffmpeg.wasm (WebAssembly). The site operator never sees the contents. Only the ffmpeg library itself (~32MB) is downloaded on first use; the video itself never leaves your device.

How long does it take?

On a single thread, a 5-minute 1080p video takes about 1 to 3 minutes on desktop Chrome. Mobile is 2 to 3 times slower. Raising CRF from 28 to 32 or downscaling to 720p makes it faster.

Which input formats are supported?

MP4, MOV, WebM, MKV, AVI, and most formats ffmpeg supports. Output is always MP4 (H.264 + AAC) — playable on virtually any device or messaging app.

What is CRF and how should I pick a value?

Constant Rate Factor — H.264's quality knob. 0 is lossless, 51 is worst, 23 to 28 is the usual range. The default here is 28 (visually nearly identical, 30~60% smaller). Use 18 to 22 for archival-grade, 30 to 32 for messenger-friendly small files.

Can it handle large videos?

On desktop Chrome, around 1 to 2GB. Mobile browsers may become unstable above ~500MB. For large videos, downscale to 720p first or use Trim Video to split into shorter pieces.

Is the audio preserved?

Default is AAC 128 kbps re-encode. For music videos where audio fidelity matters, choose Copy original (lossless). Some codecs (AC-3, DTS) can't be copied into MP4 and will fall back to AAC automatically.

References

Last verified: 2026-05-05 / Powered by ffmpeg.wasm (WebAssembly).

ffmpeg.wasm — official site (BSD/LGPL)
H.264/AVC standard — ISO/IEC 14496-10
CRF guide — FFmpeg Wiki

⚠️ For personal use only. Respect copyright when working with videos you don't own.