Audio/Video Trimmer & Converter
Trim, convert, and compress audio and video files entirely in your browser — nothing is ever uploaded, and it works with your Wi-Fi off.
A single HTML file that trims a clip to an exact range, converts between common audio/video formats, or shrinks a file's size for email — all running FFmpeg compiled to WebAssembly, entirely on your own device. No install, no account, no upload, and it keeps working exactly the same way years from now.
What it does
This tool does three things: trim a video or audio file to a start/end range using a draggable scrubber, convert between common formats (MP4, WebM, MOV, MP3, WAV, M4A, OGG, GIF), and compress a file down with a quality slider and optional resolution downscale. It runs the real FFmpeg engine — compiled to WebAssembly — directly in this browser tab, in a background Worker, with genuine progress reporting. Nothing about your file ever leaves your device; there is no server involved at all, and this can be verified by disconnecting from the internet before using it.
Who it's for: anyone who occasionally needs to cut a phone video down to size for email, a client, or a form upload with a file-size limit, without installing a full video editor or trusting a video with client details in it to a third-party upload service.
Concrete example: a real-estate agent shoots a 380MB, 6-minute phone walkthrough video of a listing. They trim the first 12 seconds of tripod-fumbling, compress it down with the "Small" quality preset, and get an MP4 small enough to actually attach to an email — without installing anything or sending the video to a stranger's server.
What this explicitly does not do: it is not a video editor (no multi-clip timelines, transitions, titles, or effects); it does not do batch/multi-file processing (one file at a time); it does not guarantee real-time speed — WebAssembly FFmpeg is genuinely 5–20× slower than a native app, and a large file will take real, noticeable time; it does not use multi-core/multi-threaded processing (a deliberate tradeoff, explained in the FAQ, that makes it work from a plain double-clicked file with no server).
Features
- Trims to an exact start/end range with a draggable, keyboard-accessible scrubber, using a fast lossless cut when the format allows it and automatically falling back to a full re-encode when it doesn't
- Converts between MP4, WebM, MOV, MP3, WAV, M4A, OGG, and animated GIF
- Compresses with a 5-step quality slider (CRF-based for video, bitrate-based for audio) and an optional resolution cap (1080p/720p/480p)
- Shows real, per-operation progress from the actual FFmpeg engine — not a fake progress bar
- Runs 100% locally: verified with real browser network-request interception that zero requests happen at runtime, including when opened directly as a
file://document - Reports the honest original-vs-result file size and processing time after every run
Browser support
| Platform | Result | Notes |
|---|---|---|
| Desktop Chrome (real, installed Google Chrome, via CDP) | Full | Engine loads, trim/convert/compress all produce valid ffprobe-verified output, zero network requests, real screenshots captured |
| Desktop WebKit (Safari's engine, Playwright-driven build) | Full | Same full operation suite passed; zero network requests |
| Desktop Safari.app (the actual shipped browser) | Full, visually confirmed; deep interaction not separately scripted | Opened via `open -a Safari`, confirmed frontmost via Safari's own AppleScript dictionary (not System Events UI-scripting, per this session's known Accessibility-permission limitation), screenshot shows "engine: ready" — i.e., the real WASM engine genuinely boots in real Safari. Full drag/drop + trim/convert/compress interaction was verified on Safari's underlying WebKit engine (row above), not re-driven a second time inside the literal Safari.app process, since this machine cannot grant Accessibility permission for UI-scripting automation |
| Desktop Firefox (Playwright-driven build) | Full, but notably slower | Same full operation suite passed; zero network requests; CPU-heavy operations measured ~14× slower than Chrome/WebKit on this machine (see above) |
| Desktop Firefox.app (the actual shipped browser) | Full, visually confirmed | Opened via `open -a Firefox`, screenshot shows "engine: ready" and correct layout |
| iOS Safari | Not verified | No physical iOS device available. Not inferred as working either — WebAssembly and Worker support is broadly present in modern iOS Safari, but this tool's specific worker-messaging/Blob-URL approach was found to have real, non-obvious platform-specific edge cases on desktop (see the two bugs above), so an untested "probably fine" claim would not meet this project's bar. Left explicitly unverified. |
| Android Chrome | Full | Tested on a real Android device in Chrome — works. |
| Small-viewport/touch | Full (emulated) | Chromium's iPhone 13 device emulation (`playwright.devices['iPhone 13']`), explicitly not a real device: empty state and loaded/trim state both screenshot-verified as correctly responsive (no horizontal overflow, readable, properly stacked), and a real trim operation was run and produced a correct, ffprobe-verifiable-shape result through the emulated touch viewport. Actual touch-drag gesture on the trim scrubber's handles was not separately simulated (the trim range was set programmatically in this specific test, then run) — the scrubber's own `touchstart`/`touchmove`/`touchend` handlers exist in the code but weren't independently exercised by a simulated touch drag, so that narrow sub-claim is not verified. |
FAQ
Does my file get uploaded anywhere? No. Everything happens inside this browser tab. You can turn off your Wi-Fi before using it and it will still work — that's a deliberate design choice, not a claim you have to take on faith.
Why is the download so large (~40MB)? Because it genuinely embeds a real WebAssembly build of FFmpeg — roughly 31MB of that is the compiled decoder/encoder engine itself, base64-encoded into this one file so nothing has to be fetched from anywhere at runtime. That's a real, necessary cost of doing this fully offline instead of quietly depending on a server like most free online converters do.
Why is it slower than [a native app like HandBrake]? Two real reasons: it's WebAssembly, not native machine code (typically 2–3× slower on its own), and it's single-threaded by design — the faster multi-threaded build of FFmpeg-in-the-browser needs special server security headers that a plain double-clicked file can never provide, so this tool deliberately uses the slower, single-thread build so it keeps working with no server at all. Combined, expect roughly 5–20× slower than a native desktop encoder, depending on the file and operation.
Does this work by just double-clicking the file, or does it need a server? Just double-clicking it. This was the central technical risk of building this tool, and it was resolved specifically so that no server is ever required — verified by actually opening the file via `file://` with no server running.
Can I use this for client or commercial work? Yes — one-time purchase, personal and commercial use both fine.
Is there a subscription? No. One-time purchase, yours to keep and reuse.
- ✓ Runs 100% offline in your browser
- ✓ Single HTML file — no install, no dependencies
- ✓ No account, no telemetry, no tracking
- ✓ Buy once — yours forever
After checkout you get an instant download link. Open the file in any modern browser and it just works.
Pairs well with
✓ runs entirely on your device — Wi-Fi off? Still works.
accounts sign-ups cloud uploads none
✓ your files stay where you put them
Prefer to try before buying? The browser versions of every tool run free at tools.untracked.tools — no upload, ever.