How to trim large 4k masters with no quality loss
- Step 1Confirm the master fits your tier — Per-file limits: Free 1 GB, Pro 10 GB, Pro-Media and Developer 100 GB. There's no duration cap, only a byte cap — a long 4K master is fine if it's under your tier's file-size limit.
- Step 2Drop the master — Drag in your 4K/8K MP4, MOV, MKV, WebM, AVI, M4V, or TS file (one file per run). FFmpeg.wasm probes it locally and shows the source duration.
- Step 3Set Start (s) — Enter the in-point. High-bitrate masters can have keyframes several seconds apart, so the start snaps to the nearest keyframe at/before your value. Pick a Start a touch before the action you want to be safe.
- Step 4Set End (s) — Enter the out-point in seconds (capped at the source duration), or leave it at 0 to trim through to the end. End must exceed Start.
- Step 5Run the lossless trim — The tool runs
-ss {start} -to {end} -i input -c copy -avoid_negative_ts make_zero. No frame is re-encoded; the export is bounded by reading and writing the file. - Step 6Verify pixels and metadata — Open the
name-out.extclip in MediaInfo and confirm codec, bitrate, and HDR tags match the source exactly — that's your proof the trim was lossless. To then break the result into equal parts, feed it to the video splitter.
Why 4K trims fast with stream-copy
Re-encoding scales with pixels and frames; stream-copy scales with file size only. That's the whole win on 4K/8K.
| Master | Stream-copy trim (this tool) | Re-encode trim (transcoder) |
|---|---|---|
| 4K H.265, 12 GB | Seconds — container rewrite | Several minutes — every frame re-encoded |
| 8K, 40 GB (needs 100 GB tier) | Tens of seconds (byte I/O bound) | Many minutes, high CPU |
| ProRes 422 HQ .mov, 60 GB | Container rewrite, lossless | Re-compress (loses ProRes fidelity unless re-encoding to ProRes) |
| Quality of cut range | Bit-identical to source | One generation of loss |
Trim one clip vs split into segments
Two different jobs. The trimmer extracts one range; the splitter chops a master into N equal lossless parts.
| Need | Use | Output |
|---|---|---|
| Extract a single range from a master | Lossless trimmer (this tool) | One clip, name-out.ext |
| Cut a master into N equal segments | video splitter | ZIP of name-part-1..N.ext (2-20 parts, -c copy) |
| Join several clips into one master | video merger | One file (stream-copy if codecs match) |
| Change codec/resolution while cutting | universal transcoder | Re-encoded file |
Cookbook
Large-master trims and the FFmpeg command each one runs. None re-encode a single frame.
Pull a 90-second segment from a 4K master
Extract one delivery segment from a 12 GB 4K H.265 master. Seconds of work, bit-identical pixels.
Input: MASTER_4K_HEVC.mp4 (~12 GB)
Inputs: Start (s) = 600 End (s) = 690
Command run:
ffmpeg -ss 600 -to 690 -i MASTER_4K_HEVC.mp4 \
-c copy -avoid_negative_ts make_zero MASTER_4K_HEVC-out.mp4
First frame: nearest keyframe <= 600s (high-bitrate GOP).Trim the head off an 8K archive clip
Drop the 8K master, leave End at 0 to keep everything after the slate, and let the tool probe the full duration.
Input: ARCHIVE_8K.mov (~38 GB, needs 100 GB tier)
Inputs: Start (s) = 14 End (s) = 0
Duration probe → 1804.0s
Command: ffmpeg -ss 14 -to 1804 -i ARCHIVE_8K.mov \
-c copy -avoid_negative_ts make_zero ARCHIVE_8K-out.movTrim once, then split into chapters
This tool extracts one clip; to break a master into equal parts for archival, chain the splitter afterwards.
Step 1 (this tool): trim MASTER.mkv 0→3600 → MASTER-out.mkv Step 2 (video-splitter): split MASTER-out.mkv into 6 parts → MASTER-out-parts.zip (6 × ~10-min lossless segments) Both steps are -c copy: no recompression anywhere.
Keep ProRes master as ProRes
A ProRes .mov trims to .mov with the bytes copied — no need to choose a codec, and no risk of recompressing the editing-grade master.
Input: GRADE_ProRes422HQ.mov Inputs: Start (s) = 5.0 End (s) = 245.0 Output: GRADE_ProRes422HQ-out.mov same ProRes profile, same bit depth, copied — not re-rendered.
Master over the tier limit is blocked
A 40 GB master needs the 100 GB tier. On Free (1 GB) or Pro (10 GB) it's refused before processing.
Input: 40 GB master on Pro tier (10 GB cap) Result: blocked with upgrade prompt before any FFmpeg work. Fix: use a Pro-Media / Developer tier (100 GB per file).
Edge cases and what actually happens
Keyframes far apart on a high-bitrate master
By design4K/8K masters at high bitrate sometimes use long GOPs, so keyframes can be several seconds apart. With -c copy your Start snaps to the nearest keyframe at/before your value, which on these files can mean a noticeably earlier in-point. Set Start a little before the moment you want. For an exact in-point you must re-encode via the transcoder.
Master exceeds tier byte limit
BlockedPer-file caps are Free 1 GB, Pro 10 GB, Pro-Media and Developer 100 GB. A master above your tier's limit is blocked before processing. There is no duration cap — only file size — so a long but smaller-bitrate file may pass where a short ultra-high-bitrate one doesn't.
Expecting multiple output segments
One clip onlyThis tool returns a single trimmed clip per run, not several segments. If you wanted a master chopped into equal parts, use the video splitter, which stream-copies into 2-20 parts and returns a ZIP.
ProRes / high-bit-depth master
PreservedStream-copy copies the encoded bytes, so a 10-bit or 12-bit ProRes/HEVC master keeps its exact bit depth, chroma subsampling, and colour metadata. There's no re-render step to drop precision. Confirm in MediaInfo if your deliverable spec is strict.
End left at 0
ExpectedEnd (s) of 0 means trim to the end of the master. The tool probes the source duration and substitutes it, so you can trim only the head of a long archive clip without typing an out-point.
End not greater than Start
RejectedThe run is refused with End time must be after start time. if End is at or below Start. Nothing is produced. Raise End above Start; remember Start may have snapped to an earlier keyframe.
Browser memory pressure on huge files
Possible failureFFmpeg.wasm works in browser memory. Trimming a very large master alongside many other open tabs can pressure RAM. Close other tabs and avoid trimming multiple huge files in parallel. The tool processes one file per run, which helps keep the working set bounded.
Corrupt or partial master download
Trim failedLarge masters sometimes arrive truncated. If FFmpeg can't seek the container, the run ends with Trim failed: and the log tail. Confirm the file size matches the source, re-download if needed, or remux through the transcoder to rebuild the index.
Frequently asked questions
Does trimming a 4K master re-encode it?
No. The tool runs -c copy, copying the master's compressed frames into a new container without re-encoding. The cut range is bit-identical to the source — every 4K/8K pixel is preserved. That's also why it finishes in seconds: the work is rewriting the container, not re-compressing frames.
Why is a 20 GB 4K file faster to trim than I expect?
Because stream-copy time tracks file size and disk I/O, not resolution or frame count. There's no encode pass, so 4K and 8K trim almost as fast as 1080p relative to their byte size. A 20 GB master typically completes in seconds to tens of seconds.
Can I split a master into several equal parts here?
Not with this tool — it returns one trimmed clip per run. For equal segments use the video splitter, which also uses -c copy (lossless, keyframe-aligned), accepts 2-20 parts, and returns a ZIP of segments. Trim first if you need to drop a head/tail, then split the result.
What's the biggest master I can trim?
Per-file ceilings are Free 1 GB, Pro 10 GB, and both Pro-Media and Developer 100 GB. There's no duration limit — only file size matters. A long 4K master that fits under your tier's byte cap is fine; an ultra-high-bitrate one may hit the cap sooner.
Will HDR and ProRes fidelity survive?
Yes. Because nothing is re-encoded, HDR10/HLG/Dolby Vision metadata, 10/12-bit depth, chroma subsampling, and ProRes profile all pass through untouched. There is no re-render to lose precision. Verify with MediaInfo against your delivery spec.
Why does the clip start before my typed in-point on a 4K master?
High-bitrate masters often use long GOPs, so keyframes can be several seconds apart. Stream-copy snaps your Start to the nearest keyframe at or before your value, so the clip can begin noticeably earlier. Set Start a little before the action. For a frame-exact in-point, re-encode via the transcoder.
Does the output stay in the same format as my master?
Yes. The output container always matches the input — an .mov master gives a .mov, an .mkv gives .mkv. The codec, bitrate, and metadata are copied unchanged, so edit-suite ingest behaves exactly as it did with the source.
Is the master uploaded anywhere?
No. The trim runs in your browser via FFmpeg.wasm — the master stays on your machine. Only the FFmpeg engine downloads once. This matters for big masters where uploading tens of gigabytes would be impractical and risky anyway.
Could a huge file run out of memory?
It's possible. FFmpeg.wasm operates in browser memory, so a very large master plus many open tabs can pressure RAM. Close other tabs, trim one file at a time (which this tool enforces), and prefer a desktop browser with plenty of memory for 8K work.
How do I prove the trim was truly lossless?
Open the output in MediaInfo (or ffprobe) and compare codec, bitrate, profile, and HDR tags against the source. With stream-copy these match exactly inside the cut range — the encoded bytes are the same, so there's nothing to differ.
Can I merge several trimmed segments back into one master?
Yes — use the video merger. When the segments share codec/resolution/framerate (which they will if they came from the same master) it joins them with stream-copy (concat demuxer), also lossless. Mixed-codec inputs get re-encoded.
What if I need to change resolution or codec while cutting?
Then you need a re-encode, which this tool doesn't do. Use the universal transcoder to choose codec/container and re-compress, or a target-size compressor if you're aiming for a specific file size. The lossless trimmer's job is to extract a range without touching the pixels.
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.