How to split a long screen recording into short clips
- Step 1Decide clip length for your tutorial steps — Short tutorial clips usually run 1–5 minutes per step. Decide a target length; the splitter divides by count, so you'll convert that target into a part count next.
- Step 2Convert the target into a part count —
parts = round(total minutes ÷ clip minutes). A 50-minute session into ~5-minute clips is50 ÷ 5 = 10parts. Enter 10. There's no 'clip every N minutes' mode — you give the count. - Step 3Drop the recording and set Number of parts — Accepts MP4, MOV, MKV, WEBM, AVI, M4V, TS — covering OBS (MKV/MP4), QuickTime (MOV), and most screen recorders. Enter the count (2–20).
- Step 4Run the lossless split — FFmpeg.wasm extracts each clip with
-ss START -i recording -t SEGLEN -c copy -avoid_negative_ts make_zero. No re-encode means UI text and code stay crisp in every clip. - Step 5Download and label the clips — Extract
name-parts.zipand rename clips by step ('01-install', '02-configure'). Each plays independently — embed or share a single step without the whole session. - Step 6Trim clips that must start exactly on a step — Equal time won't hit the click where the next step begins, and long-GOP screencasts may snap a couple of seconds off. For an exact start, trim that clip with lossless-trimmer; to auto-find step changes, try scene-detector.
Part count for session length and clip target
Equal split divides total runtime by part count. Pick the count whose clip length suits your tutorial steps.
| Session length | ~2 min clips | ~5 min clips | ~8 min clips |
|---|---|---|---|
| 20 min | 10 parts | 4 parts | 2–3 parts |
| 40 min | 20 parts | 8 parts | 5 parts |
| 60 min | 20 parts (max) | 12 parts | 8 parts |
| 90 min | 20 parts (max) | 18 parts | 11 parts |
Why screen recordings split cleanly
Stream-copy behaviour mapped to the things that make screencasts different.
| Screencast trait | How the split handles it |
|---|---|
| Crisp UI text / code | Stream-copy = no re-encode, so text stays pixel-sharp |
| Variable frame rate | Frame timing preserved exactly; durations reflect real timeline |
| Long keyframe interval | Boundaries snap further from the even mark (see edge cases) |
| On-screen secrets (keys, drafts) | In-browser processing — nothing uploads |
Splitter behaviour for screencasts
Real tool facts relevant to tutorial creators.
| Property | Value |
|---|---|
| Part range | 2–20 |
| Quality | Lossless (-c copy) |
| Boundary | Nearest keyframe (worse with long GOPs) |
| Output | ZIP of ordered clips, same container |
| VFR | Preserved, not re-timed |
Cookbook
Turning a long screencast into ordered tutorial clips. Use even splits for bulk, trims for exact steps.
50-minute session into 10 clips of ~5 minutes
The standard screencast case: one working session into step-sized clips.
Input: setup-session.mkv (50:00, OBS capture) Math: 50 / 5 = 10 Option: Number of parts = 10 Output: setup-session-parts.zip setup-session-part-1.mkv ... -part-10.mkv (~5:00 each) Rename: 01-install, 02-configure, ...
Keep UI text and code sharp
Re-encoding a screencast blurs small fonts. Stream-copy avoids it.
Input: ide-walkthrough.mp4 (12px editor font) Option: Number of parts = 6 -c copy -> no re-encode -> code stays legible in every clip. Container stays MP4.
Clip that starts exactly on a click
Equal time won't land on the 'Step 3' click; long screencast GOPs make the snap worse. Trim instead.
Step 3 begins at 18:42 (a button click). Equal split + long GOP could snap to 18:30. Use lossless-trimmer: in 18:42 -> clean step start. (Route: /video-tools/lossless-trimmer)
Auto-find step boundaries
Big UI changes (new screen, app switch) register as scene changes you can cut on.
Run scene-detector -> list of cut timestamps where the screen changed materially. Trim at those marks with lossless-trimmer for step-aligned clips. (Routes: /video-tools/scene-detector, /video-tools/lossless-trimmer)
Protect on-screen secrets
Screencasts often catch tokens, emails, or unreleased UI. In-browser splitting keeps them off any host.
Input: dashboard-demo.mp4 (API key briefly visible) Option: Number of parts = 8 Processing: FFmpeg.wasm, no upload. To hide the key region in the published clip, redact it first, then split. (Route: /video-tools/video-redactor)
Edge cases and what actually happens
Clip doesn't start on the step boundary
By designEqual-time splitting cuts near even marks on keyframes, not where you clicked to the next step. For a clip that must begin exactly on a step, trim with lossless-trimmer; to locate step changes automatically, run scene-detector.
Long keyframe interval throws the boundary off
ExpectedScreen recorders often use long GOPs (keyframes many seconds apart) because static screens compress well. With -c copy the cut snaps to the nearest prior keyframe, so a boundary can land several seconds before the even mark. Trim the affected clip for precision, or re-encode the source to a shorter GOP first if exact even clips matter.
On-screen secrets in the recording
Handle privacyThe split is private (in-browser), but the footage still shows whatever was captured — API keys, emails, drafts. To hide a region in the published clip, redact it first with video-redactor, then split the redacted file.
Variable frame rate recording
PreservedScreencasts are frequently VFR (frames only when the screen changes). Stream-copy preserves the timing exactly, so clip durations reflect the real timeline rather than a fixed-fps assumption. Boundaries still follow keyframes.
Very short clips collapse
ExpectedSplitting a short session into many parts with a long GOP can produce clips shorter than the keyframe spacing, which collapse to a single keyframe. Use fewer parts for short or sparsely-keyframed recordings.
Need clips at exact even durations
Not guaranteedStream-copy can't produce frame-exact even clips because cuts land on keyframes. If exact, identical clip lengths are required, you'd need a re-encode at fixed boundaries — outside this tool's lossless design; trim each clip individually instead.
Output container isn't web-friendly
Different toolOBS MKV clips play locally but aren't ideal for instant web embedding. For docs sites and tutorials, run each clip through web-optimizer for +faststart and a streamable encode, or convert with video-transcoder.
Recording exceeds your tier's file cap
RejectedA long high-resolution capture can exceed 1 GB on Free. Pro (10 GB) or higher is needed. The cap is on file bytes, not on how long the session ran.
Source duration can't be read
ErrorIf OBS crashed and left an unfinalised file, its duration metadata may be missing and the tool raises 'Could not determine video duration.' Remux the recording (FFmpeg can often repair an unfinalised MKV) so it reports a valid duration, then split.
Frequently asked questions
How do I split a long screen recording into clips?
Decide a clip length (1–5 minutes per step is common), convert it to a part count (total minutes ÷ clip minutes), and split. The tool divides the recording into that many equal lossless clips, which you rename and embed by step.
Will splitting blur my UI text or code?
No. The split uses stream-copy (-c copy) with no re-encode, so crisp UI text, small fonts, and thin lines stay pixel-sharp in every clip. Re-encoding is what softens screen captures, and this tool doesn't re-encode.
Can it cut exactly where I clicked to the next step?
No — it's an equal-time split, and cuts snap to keyframes, which is worse on long-GOP screencasts. For a clip that must begin on an exact click, trim with lossless-trimmer; to find step changes automatically, use scene-detector.
Does it handle variable frame rate recordings?
Yes. Screen recordings are often VFR, and stream-copy preserves the frame timing exactly rather than re-timing it. Clip durations reflect the real captured timeline; boundaries still land on keyframes.
Why did a clip start a few seconds before I expected?
Screen recorders use long keyframe intervals because static screens compress well. Stream-copy can only start a clip on a keyframe, so the boundary snaps to the nearest prior one — which can be several seconds back. Trim that clip for precision.
Is my screen recording uploaded anywhere?
No. The split runs entirely in your browser via FFmpeg.wasm, so a recording showing your desktop, tokens, or an unreleased product never reaches a server. It stays on your machine until you publish the clips.
How do I hide an API key that's visible in the recording?
The splitter doesn't redact, but you can blur or block a region first with video-redactor, then split the redacted file. Both run in your browser, so the original never leaves your machine.
How many clips can I make?
Between 2 and 20. For a long session needing more than 20 clips, split into 20 then re-split a part, though step-aligned trims usually beat a very fine equal split for tutorials.
What format are the clips?
The same container as the recording — an OBS MKV yields MKV clips, a QuickTime MOV yields MOV clips. For web embedding, run each clip through web-optimizer or convert with video-transcoder.
Can I get exactly equal-length clips?
They target equal length, but cuts snap to keyframes, so durations vary — more so with long screencast GOPs. Frame-exact identical clips would require a re-encode at fixed boundaries, which is outside this tool's lossless design.
How large a recording can I split?
Free allows one file up to 1 GB; Pro up to 10 GB; Pro + Media / Developer up to 100 GB. A long high-resolution screen capture may exceed 1 GB and need Pro. The limit is on file size, not duration.
My OBS file won't load — what's wrong?
If OBS crashed, the recording may be unfinalised and missing duration metadata, so the tool can't compute clip lengths and reports an error. Remux it (FFmpeg can usually repair an unfinalised MKV) to restore a valid duration, then split.
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.