How to trim a video without re-encoding it
- Step 1Open the lossless trimmer and drop one video — The lossless trimmer takes a single file at a time (it is not a batch tool). Drag in your MP4, MOV, MKV, WebM, AVI, M4V, or TS source. FFmpeg.wasm loads in the page and probes the file to read its duration.
- Step 2Read the source duration — Below the inputs the panel prints
Source duration: NN.NNs. Use it to sanity-check your end timestamp — the End (s) field is capped at the source duration so you can't ask for more than exists. - Step 3Set Start (s) — Type the in-point in seconds (decimals allowed, e.g.
12.5). With stream-copy the engine snaps this down to the nearest keyframe at or before your value, so the first output frame is always decodable. Leave it at0to keep the head of the clip. - Step 4Set End (s) — Type the out-point in seconds. If you leave End (s) at
0, the tool probes the source and uses the full duration as the end, so you can trim only the head without picking an out-point. End must be greater than start or the run is rejected. - Step 5Run the trim — The tool issues
-ss {start} -to {end} -i input -c copy -avoid_negative_ts make_zero.-avoid_negative_ts make_zerorebases timestamps so the clip starts at 0 and plays cleanly. No re-encode happens — progress is dominated by reading and writing the file, not crunching frames. - Step 6Download and verify — Save the
name-out.extclip. Open it and confirm the first visible frame matches where you expected; if it starts slightly earlier than your typed start, that's the keyframe snap. To confirm zero quality loss, compare bitrate/codec in MediaInfo — they will match the source exactly.
Lossless trimmer controls
The complete option surface. There are exactly two inputs — this tool deliberately exposes nothing else, because stream-copy has nothing else to configure.
| Control | What it does | Default / behaviour |
|---|---|---|
| Start (s) | In-point in seconds (decimals allowed). Passed to FFmpeg as -ss before -i, so seeking is fast and snaps to the nearest keyframe at/before the value | 0 — keeps the head of the clip |
| End (s) | Out-point in seconds, passed as -to. Capped at the source duration | 0 — interpreted as 'to end of file' (the tool probes duration and substitutes it) |
| Source duration | Read-only readout from the FFmpeg probe so you can pick valid timestamps | Printed once the file is analysed |
| Codec mode | Always -c copy (stream-copy). There is no re-encode / frame-accurate toggle on this tool | Fixed — for frame-exact cuts use a re-encoding sibling (see FAQ) |
Stream-copy vs re-encode trim
Why -c copy is fast and lossless, and the single thing it can't do (land between keyframes).
| Property | Stream-copy (this tool) | Re-encode trim (a transcoder) |
|---|---|---|
| Quality | Bit-identical to source inside the cut range | Re-compressed — one generation of loss |
| Speed on 10 GB 4K | Seconds (container rewrite only) | Minutes (every frame re-encoded) |
| Cut precision | Start snaps to nearest keyframe at/before your value (typically within 1-5 s) | Frame-accurate to the exact timestamp |
| Output codec | Identical to source | Whatever you choose |
| CPU / battery | Minimal | High (sustained encode) |
Cookbook
Real start/end inputs and the FFmpeg command the tool runs for each. Timestamps are in seconds; -c copy means no frame is re-compressed.
Trim only the head — leave End at 0
You want everything after the 8-second mark and don't care about an out-point. Leave End (s) at 0 and the tool probes the duration and uses it as the end automatically.
Inputs: Start (s) = 8 End (s) = 0
Source duration probe → 642.0s
Command run:
ffmpeg -ss 8 -to 642 -i master.mp4 \
-c copy -avoid_negative_ts make_zero master-out.mp4
Result: master-out.mp4, head removed, ~5s export, no re-encode.Cut a 30-second middle section
Pull a 30-second window out of a long recording. Start snaps back to the nearest keyframe, so the first frame may begin a second or two before 120.0 — expected with stream-copy.
Inputs: Start (s) = 120 End (s) = 150
Command run:
ffmpeg -ss 120 -to 150 -i talk.mkv \
-c copy -avoid_negative_ts make_zero talk-out.mkv
First output frame: nearest keyframe <= 120s (e.g. 118.4s).MOV master keeps its container
A ProRes or H.264 .mov drops in and out as .mov — the tool never changes the container, so editing-suite ingest stays happy.
Input file: interview_A001.mov (4K, ~9 GB) Inputs: Start (s) = 3.5 End (s) = 64.0 Output: interview_A001-out.mov same codec, same bit depth, same colour metadata — copied bytes.
End-time guardrail rejects an invalid range
If End is not greater than Start, the run is refused before any work happens, so you never produce a zero-length file.
Inputs: Start (s) = 90 End (s) = 90 Result: run rejected — Error: "End time must be after start time." Fix: set End (s) above Start (s).
Fast back-to-back trims from one source
Need several clips from one master? The tool processes one clip per run, but each run is so cheap (no encode) that re-running with new Start/End values for each clip is still seconds of work apiece.
Run 1: Start 0 End 45 → highlight_1-out.mp4 Run 2: Start 300 End 332 → highlight_2-out.mp4 Run 3: Start 980 End 1024 → highlight_3-out.mp4 Each run: -c copy, ~seconds. For one upload that auto-splits into N equal parts as a ZIP, use the video-splitter instead.
Edge cases and what actually happens
Start lands between keyframes
By designWith -c copy the decoder needs a keyframe to start from, so the engine snaps your Start back to the nearest keyframe at or before your value. The clip may begin 1-5 seconds earlier than the timestamp you typed. This is inherent to stream-copy, not a bug. If you need the cut on an exact frame, you must re-encode — use the universal transcoder, which re-compresses and can land between keyframes.
End set to 0 or left blank
ExpectedAn End (s) of 0 (or any non-positive value) is treated as 'to the end of the file': the tool probes the source duration and substitutes it. This lets you trim only the head without picking an out-point. The export then runs from your Start to the true end of the source.
End not greater than Start
RejectedIf the effective End is less than or equal to Start, the tool throws End time must be after start time. and produces nothing. Raise End above Start. Note that because Start may snap back to a keyframe, a very narrow window (e.g. Start 10.0, End 10.2) can still produce a slightly longer clip than the 0.2s you asked for.
FFmpeg returns a non-zero exit
Trim failedIf the container is corrupt, truncated, or has an index FFmpeg can't seek, the run ends with Trim failed: followed by the tail of the FFmpeg log. Try remuxing the file first (transcode to a clean MP4) or check that the download finished completely before trimming.
Unrecognised file extension
Falls back to MP4The container is inferred from the file extension. Anything outside mp4/mov/mkv/webm/avi/m4v/ts is treated as MP4, which can mismatch the real container and cause a Trim failed. Rename the file to its correct extension before trimming.
HDR / Dolby Vision master
PreservedBecause no frame is re-encoded, all codec-level colour metadata — HDR10, HLG, and Dolby Vision in compatible containers — passes through untouched. Colour space, transfer characteristics, and mastering-display luminance survive exactly. Verify the tags in MediaInfo if your delivery spec is strict.
File larger than your tier allows
BlockedVideo tier ceilings are Free 1 GB, Pro 10 GB, Pro-Media and Developer 100 GB per file (one file at a time on this tool; there is no duration cap, only file size). A file over your tier's byte limit is blocked with an upgrade prompt before processing.
First frame shows briefly as grey/blocky
Expected-avoid_negative_ts make_zero rebases timestamps to start at 0. On rare sources a player may show one transitional frame at the join. Because the keyframe snap guarantees the first frame is a full I-frame, this is cosmetic and clears within a frame or two on standards-compliant players.
Frequently asked questions
Does this re-encode the video at all?
No. The tool runs FFmpeg with -c copy, which copies the already-compressed frames into a new container without sending them through an encoder. The trimmed range is bit-identical to the source. That's why a 10 GB file exports in seconds — the work is rewriting the container, not re-compressing video.
Why does my clip start a little before the timestamp I typed?
Stream-copy can only begin on a keyframe (I-frame), because later frames depend on it to decode. The engine snaps your Start back to the nearest keyframe at or before your value. Keyframes are typically 1-5 seconds apart, so the clip can begin slightly earlier than your typed start. This is the inherent trade-off for zero re-encode time.
Is there a frame-accurate or re-encode mode on this tool?
No. This tool is stream-copy only — its only controls are Start (s) and End (s). For a cut that lands on an exact frame, you need a re-encode at the cut point. Use the universal transcoder, which re-compresses and can place the cut between keyframes (at the cost of one generation of quality and real encode time).
What formats can I trim?
MP4, MOV, MKV, WebM, AVI, M4V, and TS. The output container always matches the input — an .mkv in gives an .mkv out. Files with an unrecognised extension are treated as MP4, which can fail if that's not the real container, so rename to the correct extension first.
Can I trim multiple files at once?
Not in one run — the lossless trimmer takes a single file. Because each run is so cheap (no encode), re-running with new Start/End values per clip is still seconds apiece. If you want one source automatically chopped into N equal parts, use the video splitter, which also stream-copies and returns a ZIP.
How big a file can I trim?
Per-file ceilings are Free 1 GB, Pro 10 GB, and both Pro-Media and Developer 100 GB. There is no duration limit — only file size matters, because stream-copy is bounded by bytes, not minutes. A 90-minute 4K master that fits under your tier's byte cap trims as fast as a 30-second clip relative to its size.
Will the audio track stay in sync and at original quality?
Yes. -c copy copies the audio stream alongside video without re-encoding, so the original AAC/Opus/MP3 track is preserved exactly. -avoid_negative_ts make_zero rebases timestamps so video and audio both start at 0, keeping them in sync from the first frame.
Does trimming keep HDR and colour metadata?
Yes. Since nothing is re-encoded, codec-level metadata including HDR10, HLG, and Dolby Vision (in compatible containers), colour space, and mastering-display values pass through untouched. Confirm with MediaInfo if your delivery spec requires specific HDR tags.
What does the End (s) = 0 default mean?
It means 'trim to the end of the file.' If you leave End at 0 (or any non-positive value), the tool probes the source duration and uses it as the out-point, so you can drop a file, set a Start, and run without picking an end timestamp.
Is anything uploaded to a server?
No. Trimming runs entirely in your browser via FFmpeg.wasm. The video bytes never leave your machine — only an anonymous 'one file processed' counter is recorded for signed-in dashboard stats, and that holds no file content. This is why confidential masters and embargoed cuts are safe here.
The export failed with 'Trim failed' — what now?
That surfaces FFmpeg's own error tail. Usual causes: a truncated or still-downloading file, a corrupt index FFmpeg can't seek, or a wrong file extension. Make sure the download completed, confirm the extension matches the real container, and if the source is damaged, run it through the transcoder once to produce a clean MP4, then trim that.
What if I also need to strip metadata while trimming?
The trimmer preserves metadata by design (it copies the container). To remove GPS, camera, and date tags, run the clip through the metadata scrubber afterwards — it's also lossless (stream-copy) and only rewrites the container's tags. For merging several trimmed clips back together, use the video merger.
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.