How to remove the intro from a video
- Step 1Find where the intro ends — Scrub the video and note, in seconds, the moment the real content starts after the bumper/logo/sponsor intro. Write that timestamp down — you'll set Start a touch past it.
- Step 2Drop the video — Drag the file into the lossless trimmer (one per run). FFmpeg.wasm probes its duration so you can confirm the End readout.
- Step 3Set Start (s) just past the intro — Enter your in-point. Because stream-copy snaps Start back to the nearest keyframe at/before your value, set it slightly into the first real shot — not exactly on the intro's last frame — so the snap can't reintroduce a sliver of the bumper.
- Step 4Leave End (s) at 0 to keep the rest — End of 0 means 'trim to the end of the file', so the entire video after your Start is kept. (Set an explicit End only if you also want to drop an outro.)
- Step 5Run the trim — The tool runs
-ss {start} -to {duration} -i input -c copy -avoid_negative_ts make_zero. The intro is dropped, the remainder is copied untouched, and timestamps rebase to start at 0. - Step 6Check the first frame — Open
name-out.extand confirm it now opens on real content with no leftover bumper frames. If a sliver of intro survived, the keyframe snap pulled it back — push Start a little later and re-run (it's instant).
Intro-removal recipe
The only two settings, tuned for cutting an opening off the front while keeping everything after it.
| Goal | Start (s) | End (s) |
|---|---|---|
| Remove intro, keep rest | Just past where the intro ends | 0 (= keep to end of file) |
| Remove intro AND outro | Just past the intro | Where the outro starts |
| Keep intro, cut only the tail | 0 | Where you want it to stop |
| Pull a middle section | After the intro, before the part you want | End of the part you want |
The keyframe-snap gotcha for intro removal
Stream-copy snaps Start back to a keyframe. If keyframes are sparse, set Start later than the exact intro end.
| Situation | What happens | Fix |
|---|---|---|
| Start set exactly at intro end | Snap may pull Start back into the intro — a sliver of bumper survives | Set Start a second or two into the first real shot |
| Dense keyframes (every ~1s) | Snap is small; cut is close to your value | Usually fine as-is |
| Sparse keyframes (long GOP) | Snap can be several seconds early | Push Start later, or re-encode for an exact cut |
| Need a frame-exact intro cut | Stream-copy can't do it | Use the transcoder (re-encodes) |
Cookbook
Real intro-removal setups and the command each runs. The keeper portion is always copied, never re-encoded.
Drop a 6-second sponsor bumper
The sponsor card runs 0-6s; real content starts at ~6s. Set Start a touch past it and keep the rest.
Inputs: Start (s) = 6.5 End (s) = 0
Duration probe → 724.0s
Command run:
ffmpeg -ss 6.5 -to 724 -i episode.mp4 \
-c copy -avoid_negative_ts make_zero episode-out.mp4
Result: opens on real content, rest untouched.Sparse keyframes — push Start later
First pass at Start=6.5 still showed a flash of logo because the nearest keyframe was at 4.0s. Push Start past the next keyframe.
Pass 1: Start 6.5 → snaps to keyframe 4.0s → logo flash remains Pass 2: Start 9.0 → snaps to keyframe 8.0s → clean open (check the result; re-run is instant with -c copy)
Remove both intro and outro
Cut a 4-second intro and a 10-second end card by setting both Start and End.
Source duration: 600s (outro card starts at 590s)
Inputs: Start (s) = 4.5 End (s) = 590
Command: ffmpeg -ss 4.5 -to 590 -i vid.mov \
-c copy -avoid_negative_ts make_zero vid-out.movKeep the container for re-upload
A YouTube re-upload wants the same MP4 container. The tool never changes it, so the de-intro'd file is upload-ready.
Drop: upload_ready.mp4 → Output: upload_ready-out.mp4 Same codec, same quality after the new in-point.
Frame-exact intro cut needs a re-encode
When the bumper must end on an exact frame and keyframes are sparse, stream-copy can't oblige — switch to the transcoder.
This tool: snaps to keyframe (good enough for most intros) Exact-frame need: use video-transcoder (re-encodes, slower, one generation of loss, but lands on the precise frame)
Edge cases and what actually happens
A sliver of the intro survives the cut
By designStream-copy snaps Start back to the nearest keyframe at/before your value. If you set Start at the exact end of the intro and the nearest keyframe is earlier, a fragment of the bumper is pulled back in. Set Start a second or two into the first real shot, or push it past the next keyframe, and re-run — each run is instant.
Sparse keyframes (long GOP)
ExpectedSome encoders place keyframes many seconds apart. The snap can then drag Start noticeably earlier than you intended, which matters most for short intros. Push your Start later (past the next keyframe), or use the transcoder for a frame-exact cut at the cost of a re-encode.
Want a frame-perfect intro cut
Wrong toolThis tool can't land between keyframes. For a cut on an exact frame (e.g. the precise frame the logo clears), you need a re-encode. The universal transcoder re-compresses and can cut anywhere, trading one generation of quality and real encode time for precision.
End left at 0
ExpectedEnd of 0 keeps everything after Start to the end of the file — exactly what you want for plain intro removal. The tool probes the duration and uses it as the out-point automatically. Set an explicit End only if you also want to drop an outro.
End not greater than Start
RejectedIf you set an explicit End that's at or below the effective Start, the run is refused with End time must be after start time. Make sure End sits after your (possibly snapped) Start.
Intro has different codec params than the body
RareOccasionally a bumper was spliced in with different encode settings. Stream-copy copies whatever bytes follow the keyframe; if the splice point isn't a clean keyframe boundary the body still plays correctly, but for a truly clean join consider re-encoding via the transcoder.
File over your tier limit
BlockedPer-file caps are Free 1 GB, Pro 10 GB, Pro-Media/Developer 100 GB (one file per run, no duration cap). A source over your tier's byte limit is blocked before processing.
First frame of the kept portion looks rough
Expected-avoid_negative_ts make_zero rebases timestamps so the kept portion starts at 0, and the keyframe snap guarantees the first frame is a full I-frame. Any momentary roughness clears within a frame on standards-compliant players — it's cosmetic, not data loss.
Frequently asked questions
How do I remove just the intro and keep everything else?
Set Start (s) to just past where the intro ends and leave End (s) at 0. End of 0 means 'trim to the end of the file', so the whole video after your Start is kept. The tool copies that remainder with -c copy — no re-encode, so the kept part stays at original quality.
Why is a bit of the intro still in my output?
Stream-copy must start on a keyframe, so the engine snaps your Start back to the nearest keyframe at or before your value. If you set Start exactly at the intro's end, the snap can pull a sliver of bumper back in. Set Start a second or two into the first real shot, or push it past the next keyframe, then re-run — it's instant.
Can I cut the intro on an exact frame?
Not with stream-copy — it can only begin on a keyframe. For a frame-exact intro cut, re-encode with the universal transcoder, which can place the cut on any frame at the cost of one generation of quality and real encode time. For most intros, the keyframe snap (set a touch late) is good enough.
Does removing the intro re-encode the rest of the video?
No. The kept portion is copied with -c copy — byte-for-byte the original. Only the container is rewritten and timestamps rebased to start at 0. That's why even a long video exports in seconds when you only chop the opening.
Can I remove both an intro and an outro?
Yes. Set Start past the intro and set an explicit End where the outro begins. Everything between is kept with stream-copy. Both ends are subject to the keyframe snap on the Start side; the End is exact to your value.
Will the audio still line up after I cut the intro?
Yes. -c copy copies the audio track with the video, and -avoid_negative_ts make_zero rebases timestamps so audio and video both start at 0 from the new first frame. The kept portion stays in sync.
What formats can I de-intro?
MP4, MOV, MKV, WebM, AVI, M4V, and TS. The output container matches the input, so the de-intro'd file slots straight back into your edit or re-upload flow. Unknown extensions are treated as MP4, which can fail to seek — rename to the real extension first.
How precise do my keyframes need to be for a clean cut?
It depends on the source's GOP length. Dense keyframes (every ~1 second) give a cut very close to your typed Start; long-GOP sources can snap several seconds early. Check the result; if the intro survived, push Start later, or re-encode for an exact cut.
Is the file uploaded while I remove the intro?
No. The whole operation runs in your browser via FFmpeg.wasm — the file never leaves your machine. Only the FFmpeg engine downloads once. Unreleased episodes and client cuts stay private.
Can I remove intros from a whole batch of episodes at once?
The tool processes one file per run, but each run is seconds because nothing re-encodes — so de-introing several episodes is quick if the intro length is consistent. Re-drop each file and set the same Start. There's no multi-file batch mode on this tool.
What if the intro and the body are different resolutions?
Stream-copy just copies the bytes after your in-point, so the body plays at its own resolution regardless of what the intro was. If the splice point is messy, or you want a uniformly re-encoded result, run the trimmed file through the transcoder.
After removing the intro, can I add my own or merge clips?
Yes — use the video merger to prepend a new intro or join the de-intro'd body with other clips. When the clips share codec/resolution/framerate it merges with stream-copy (lossless); mixed-codec inputs are re-encoded.
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.