How to cut mp4 and mov clips without uploading
- Step 1Load the page on a trusted machine — Open the lossless trimmer. The FFmpeg.wasm engine downloads once into the page. From here the actual trim runs locally — your file is never sent anywhere.
- Step 2Drop your confidential MP4 or MOV — Drag the file in (one file per run). It stays in browser memory; it is not uploaded. The tool probes its duration locally to populate the duration readout.
- Step 3Set Start (s) — Enter the in-point in seconds. With stream-copy the engine snaps it to the nearest keyframe at or before your value so the first frame decodes cleanly. Leave at 0 to keep the opening.
- Step 4Set End (s) — Enter the out-point in seconds, capped at the source duration. Leave it at 0 to trim through to the end of the file. End must be greater than Start.
- Step 5Run the local trim — The tool issues
-ss {start} -to {end} -i input -c copy -avoid_negative_ts make_zeroagainst the in-memory file. No frame is re-encoded and no byte is transmitted. - Step 6Save and confirm it never left — Download the
name-out.extclip to your local disk. If you want proof of the privacy claim, open your browser dev-tools Network tab during the run — you'll see the FFmpeg.wasm assets load, and zero requests carrying your video.
Where the data goes
What touches the network versus what stays local. This is the whole point of an in-browser trimmer.
| Step | Local (in your browser) | Sent to a server |
|---|---|---|
| FFmpeg.wasm engine | Loaded once into the page | Downloaded from CDN (no file content) |
| Your video file | Held in browser memory, trimmed in place | Nothing — never uploaded |
| Trim processing | Runs on your CPU via FFmpeg.wasm | Nothing |
| Output clip | Written to your local disk | Nothing |
| Usage stat | — | Anonymous 'file processed' count only (no content) |
Controls and what each touches
The lossless trimmer exposes exactly two inputs; both operate locally.
| Control | Effect | Default |
|---|---|---|
| Start (s) | In-point in seconds; snaps to nearest keyframe at/before the value | 0 |
| End (s) | Out-point in seconds; 0 means trim to end of file | 0 (= full duration) |
| Codec mode | Always -c copy — no re-encode, nothing to inspect or upload | Fixed |
| Output container | Matches the input extension exactly | name-out.<input ext> |
Cookbook
Privacy-sensitive trims and the exact local command each one runs. No request in any of these carries your footage.
Trim an NDA-bound interview, offline
A journalist trims a confidential source interview down to the publishable window. The file is huge and the source is sensitive — uploading it anywhere is out of the question.
Input: source_interview.mov (4K, ~7 GB)
Inputs: Start (s) = 64 End (s) = 902
Local command:
ffmpeg -ss 64 -to 902 -i source_interview.mov \
-c copy -avoid_negative_ts make_zero source_interview-out.mov
Network tab during run: 0 requests carrying the video.Clip an unreleased trailer for internal review
A marketing team pulls a 20-second teaser out of an embargoed cut to circulate internally — without it ever hitting the public internet or a third-party transcoder.
Input: TRAILER_v7_EMBARGO.mp4 Inputs: Start (s) = 12 End (s) = 32 Output: TRAILER_v7_EMBARGO-out.mp4 (bit-identical clip) No upload, no remote temp file, no shareable server link.
Cut MOV footage on an air-gapped laptop
Once the page (and FFmpeg.wasm) has loaded, the trim runs with no network. Useful in secure facilities where the laptop is taken offline before sensitive footage is opened.
1. Load page on network → FFmpeg.wasm caches 2. Disconnect network 3. Drop A001_C003.mov, Start 0, End 45 → run 4. A001_C003-out.mov saved locally, fully offline
Output keeps the exact source container
Privacy work often feeds an edit suite next. The tool never changes the container, so an MOV stays an MOV and ingest stays predictable.
Drop: client_raw.mkv → Output: client_raw-out.mkv Drop: client_raw.mov → Output: client_raw-out.mov Same codec, same bytes inside the cut range.
Verify nothing was uploaded
The simplest audit: watch the Network tab. The only requests are the wasm engine assets; your video never appears.
DevTools → Network → run trim Observed requests: ffmpeg-core.wasm (engine, no file content) ffmpeg-core.js (engine) source video → NONE output clip → NONE (written via download)
Edge cases and what actually happens
Page loaded but no FFmpeg.wasm yet
ExpectedThe engine downloads on first use. If your network blocked the CDN, the trim can't start. Once loaded it's cached, so subsequent trims (even offline) work. This one-time engine fetch carries no file content.
Start lands between keyframes
By designStream-copy must begin on a keyframe, so your Start snaps back to the nearest keyframe at or before your value — the clip can begin 1-5 seconds early. This is the cost of zero re-encode (and zero upload). For a frame-exact private cut, the universal transcoder re-encodes locally but takes real encode time.
End set to 0
ExpectedAn End of 0 means trim to the end of the file. The tool probes the source duration locally and substitutes it, so you can cut only the head of a confidential clip without picking an out-point.
End not greater than Start
RejectedIf End is less than or equal to Start the run is refused with End time must be after start time. Nothing is produced and nothing is sent. Raise End above Start.
Closing the tab mid-run
Data discardedBecause the file lives in browser memory, closing the tab discards it entirely — there is no server-side copy to clean up and no remote temp file. Re-open and re-drop to start over.
File over your tier's byte limit
BlockedPer-file ceilings are Free 1 GB, Pro 10 GB, Pro-Media and Developer 100 GB (single file, no duration cap). A file above your tier's limit is blocked locally before any processing — the limit check happens in the browser, so the file still never uploads.
Corrupt or truncated source
Trim failedIf FFmpeg can't seek a damaged container the run ends with Trim failed: and the log tail — all observed locally, nothing transmitted. Confirm the file copied completely, or remux via the transcoder first.
Wrong file extension
Falls back to MP4The container is read from the extension; anything outside mp4/mov/mkv/webm/avi/m4v/ts is treated as MP4 and may fail to seek. Rename to the real extension before trimming.
Frequently asked questions
Is my video actually never uploaded?
Correct. The trim runs in your browser via FFmpeg.wasm. The file is held in browser memory and processed on your CPU. The only network traffic is the one-time download of the FFmpeg.wasm engine — no request ever carries your video bytes. You can confirm this in your browser's Network tab during a run.
Can I use this on an air-gapped or offline machine?
Yes, once the page and FFmpeg.wasm engine have loaded. After that initial cache, the trim itself needs no network — you can disconnect and keep cutting. This makes it suitable for secure facilities where sensitive footage is only opened on a laptop that's been taken offline.
What's the catch compared to a server-side cutter?
Two things: the FFmpeg.wasm engine loads once (a few seconds the first time), and stream-copy snaps the start to the nearest keyframe rather than landing on an exact frame. In exchange you get zero upload, zero quality loss, and seconds-fast exports. For most confidential trims that's the right trade.
Does it really not re-encode?
No re-encode. It runs -c copy, copying the source's compressed frames straight into a new container. The cut range is bit-identical to the source — there's literally no transcode step that could leak or degrade the footage.
Which formats can I cut privately?
MP4, MOV, MKV, WebM, AVI, M4V, and TS. The output container matches the input exactly, so an MOV interview stays an MOV. Unknown extensions are treated as MP4, which can fail to seek — rename to the correct extension first.
Is there any server-side record of what I trimmed?
No content is recorded. The only thing saved server-side is an anonymous counter ('one file processed') for signed-in dashboard stats — it holds no filename, no frames, no metadata. There is no remote temp file and no shareable link, because nothing was uploaded.
How large a confidential file can I handle?
Per-file limits are Free 1 GB, Pro 10 GB, and Pro-Media/Developer 100 GB. There's no duration cap — a 90-minute interview that fits under your byte limit trims fine. Stream-copy is bounded by file size, not running time.
Will the audio and any captions survive the cut?
Yes. -c copy copies audio (and embedded subtitle/chapter streams) alongside video without re-encoding, preserving the original AAC/Opus track quality. -avoid_negative_ts make_zero keeps everything in sync from frame zero.
Why does my private clip start a bit before my typed start?
Stream-copy can only start on a keyframe. The engine snaps your Start back to the nearest keyframe at or before your value, so the clip can begin 1-5 seconds early. It's the inherent trade-off for not re-encoding. Re-encode locally with the transcoder if you need a frame-exact in-point.
Can I trim several confidential clips in one go?
The lossless trimmer takes one file per run, but each run is seconds of work because nothing is re-encoded — so re-running with new Start/End values is quick. To split one private source into equal segments locally, use the video splitter, which also stream-copies and returns a ZIP.
What should I do after trimming to remove identifying metadata?
Run the clip through the metadata scrubber, which strips GPS, camera, and date tags — also locally and losslessly. To blur or pixelate faces before sharing sensitive footage, the face blur and video redactor tools run in-browser too.
Does closing the tab leave anything behind?
No. The file only ever existed in browser memory, so closing the tab discards it completely. There's no server copy to delete and no temporary upload to expire — the privacy guarantee holds because the data never left the page.
Privacy first
Every JAD Video tool runs entirely in your browser via WebCodecs and FFmpeg (WebAssembly). Your video files never leave your device — verified by zero outbound network requests during processing.