How to extract scene-cut timestamps to guide your edit
- Step 1Drop the footage you want to mark up — Drag a clip or a stringout (
.mp4,.mov,.mkv,.webm,.avi,.m4v,.ts) onto the tool. FFmpeg.wasm runs locally; your rushes stay on your machine. If you cut from camera originals, detecting on a transcoded proxy of the same content gives identical timestamps and scans faster. - Step 2Set the threshold for your footage — Use
0.3for most scripted/interview rushes. For locked-off single-cam dialogue,0.5keeps the marker count to true scene breaks. For a montage stringout with crossfades you must catch, lower toward0.1(expect more markers to clean up). - Step 3Run the scan — JAD logs each over-threshold frame's
pts_timeand writes them to<yourfile>-scenes.json. Every frame is decoded, so a long stringout takes a few minutes — there is no fast-seek for cut scoring. - Step 4Convert seconds to your project timecode — The
cutsare in seconds (e.g.91.2). Multiply by your project frame rate to get a frame number, or convert toHH:MM:SS:FFtimecode. For a 24 fps project,91.2 s≈ frame 2189 ≈00:01:31:05. Do this conversion once for the whole list. - Step 5Bring the markers into your NLE — Premiere: paste timecodes as sequence markers (or build a marker CSV in Premiere's marker panel format). DaVinci Resolve: add markers at the timecodes, or assemble an EDL where each cut becomes an event. Final Cut: convert to chapter markers. The detector gives the timestamps; the marker-format mapping is yours.
- Step 6Refine and re-scan if needed — If markers landed on camera shake or panning, raise the threshold and re-scan; if a real cut was missed, lower it. Because the result is deterministic, diff the new
cutsagainst the old to confirm only the markers you wanted changed — then redo the import.
Mapping cuts into common NLEs
The detector outputs seconds; here is how that lands in each editor. The format conversion is a step you perform — the tool does not export NLE files directly.
| NLE | How cuts are usually used | Conversion needed |
|---|---|---|
| Premiere Pro | Sequence markers, or in/out point pre-set per segment | Seconds → HH:MM:SS:FF at project fps; paste into marker panel |
| DaVinci Resolve | Timeline markers, or EDL events per cut | Seconds → timecode; build markers or an EDL by hand/script |
| Final Cut Pro | Chapter/clip markers | Seconds → timecode; add at each marker point |
| Avid Media Composer | Locators / EDL | Seconds → timecode; convert to locator list or EDL |
| Any editor | A shot list / in-out reference doc | Seconds → readable MM:SS for a paper edit |
Threshold by footage type (editor's view)
Practical starting points for marking up rushes. Tune per clip.
| Footage | Threshold | Marker outcome |
|---|---|---|
| Multi-cam interview rushes | 0.3 | One marker per angle switch — a ready-made cut map |
| Locked-off dialogue scene | 0.5 | Only true scene breaks; ignores actor movement |
| Montage stringout w/ dissolves | 0.1–0.2 | Catches soft transitions; clean up extra markers after |
| Handheld run-and-gun | 0.5–0.6 | Suppresses shake false-positives |
Tier limits (video family)
Source-file size and batch caps for the detector.
| Tier | Max file size | Batch files |
|---|---|---|
| Free | 1 GB | 1 |
| Pro | 10 GB | 5 |
| Pro-media | 100 GB | 50 |
| Developer | 100 GB | Unlimited |
Cookbook
Editor-focused recipes for getting the JSON cuts into a real timeline. Timestamps abbreviated.
Convert one cut to a 24 fps timecode marker
The JSON gives seconds; your NLE wants timecode. Here is the arithmetic for a single cut so you can script the whole list.
cut = 91.2 s, project = 24 fps frame = round(91.2 * 24) = 2189 timecode = 00:01:31:05 (mm:ss:ff) Drop a sequence marker at 00:01:31:05 in Premiere. Repeat the formula across the whole cuts[] array.
Build a paper-edit shot list from a stringout
Before touching the NLE, turn the cuts into a readable shot list so the edit plan is mapped out. Each cut becomes a segment boundary.
Input: selects-stringout.mov, threshold 0.3 cuts: [0.0-ish, 8.34, 27.1, 54.88, 91.2] Shot list: 00:00–00:08 shot A 00:08–00:27 shot B 00:27–00:54 shot C 00:54–01:31 shot D Paste into your edit doc; trim selects from here.
Detect on a proxy, cut on the camera original
Premiere/Resolve editors often cut proxies. Detect on the proxy; the seconds apply 1:1 to the online media because pts_time is timeline-relative, not codec-relative.
Proxy: A001_proxy.mp4 ← scan this (fast) Online: A001.mov (ProRes) ← cut against these markers Threshold 0.3 → cuts[] → same timecodes work on both. No re-detect needed when you relink to the originals.
Filter shake false-positives before importing
Handheld rushes mark on shake at 0.3. Rather than delete markers in the NLE, raise the threshold and re-scan to get a clean list, then import once.
Threshold 0.3: 31 markers (many on camera shake) Threshold 0.55: 7 markers (real scene breaks) Import the 0.55 list. Re-scanning is free and read-only, so iterate the threshold until the marker map is clean.
Hand boundaries to the splitter for selects
If you want each shot as its own media file rather than markers, send the cuts to the splitter — detection finds boundaries, the splitter cuts them.
scene-detector → selects-stringout-scenes.json cuts: [8.34, 27.1, 54.88, 91.2] video-splitter → one file per shot Then merge the keepers in the merger if you want a single assembly. The detector itself only lists cuts.
Edge cases and what actually happens
No direct Premiere/Resolve/FCP import file
By designThe detector outputs raw seconds in JSON, not an XML, EDL, or marker file for any specific NLE. Every editor expects a different marker format, so the tool gives you the universal numbers and you map them to your project timecode and marker workflow. This keeps the output editor-agnostic.
Markers land on camera shake or whip pans
ExpectedOn handheld rushes, shake and fast pans spike the frame-difference score and create markers inside a single continuous shot. Raise the threshold toward 0.5–0.6 and re-scan rather than deleting markers in the NLE. There is no min-scene-length option to auto-merge close markers inside the tool.
Creative dissolves missed at the default threshold
ExpectedAn L-cut into a dissolve or a slow cross-fade changes gradually and slips under 0.3. Lower toward 0.1–0.2 to mark them, accepting extra markers on motion. The tool finds hard cuts well; it is not a transition-classifier.
Frame-accurate timecode requires your project fps
Your conversioncuts are seconds with sub-second precision; mapping to a frame-accurate HH:MM:SS:FF marker requires multiplying by your project frame rate. The detector does not know your timeline fps, so the seconds→frames conversion is something you (or a small script) do per import.
VFR footage marker accuracy
PreservedBecause timestamps come from pts_time, variable-frame-rate camera footage gets true presentation-time markers rather than markers assumed to sit on a fixed grid. This matters for phone footage and screen recordings that are inherently VFR.
Output is JSON only, not split clips
By designDetection lists cut timestamps; it never cuts the footage. To turn boundaries into selects/media files, hand the cuts to video-splitter or pull single segments with lossless-trimmer.
Large stringout slow to scan
ExpectedA long selects stringout is decoded frame by frame (-f null -) with no fast-seek, so scanning takes minutes. Detect on a proxy of the same edit to speed it up — the timecodes are identical, so markers still land correctly on the online media.
Threshold clamped to 0.05–0.9
ClampedEntering a value outside the range snaps it to the bound. 0 would mark every frame (useless for editing); 1.0 would mark nothing. The applied threshold is written into the JSON so you can record which value produced a given marker list.
File over the tier cap
RejectedA stringout larger than your tier cap (Free 1 GB, Pro 10 GB, Pro-media/Developer 100 GB) is rejected before scanning. Detect on a smaller proxy, or split the stringout first and scan each part.
FFmpeg core cannot load
ErrorIf the FFmpeg.wasm core cannot be fetched (offline, or the CDN blocked on a studio network), the run throws 'FFmpeg core failed to load.' Self-hosting the core assets resolves it for locked-down post-production environments.
Frequently asked questions
Does this export a Premiere or Resolve marker file directly?
No. It outputs raw cut timestamps in seconds as JSON. You convert those to your project's timecode and import them as markers (or build an EDL) in your NLE. The output is intentionally editor-agnostic because every NLE expects a different marker format.
How do I convert the seconds to timecode?
Multiply each second value by your project frame rate to get a frame number, then format as HH:MM:SS:FF. Example at 24 fps: 91.2 s → frame 2189 → 00:01:31:05. A small script over the cuts array handles the whole list at once.
Will the markers be frame-accurate?
They are as accurate as pts_time allows — sub-second precision, taken from each frame's presentation time, which is correct even on VFR footage. The frame-accurate timecode comes from your fps conversion; the detector supplies precise seconds.
Can I detect on a proxy and cut the originals?
Yes. pts_time is timeline-relative, not codec-specific, so cuts found on a proxy apply directly to the camera originals when you relink. Detecting on proxies is also much faster for long rushes.
Why are there markers in the middle of one continuous shot?
Camera shake, whip pans, or fast action spike the frame-difference score and trigger false cuts. Raise the threshold toward 0.5–0.6 and re-scan. There is no min-scene-length filter, so the cleanest fix is tuning the threshold, not post-editing the list.
Are my rushes uploaded?
No. Detection runs entirely in your browser via FFmpeg.wasm. Unreleased project footage and camera originals never leave your machine — only the FFmpeg core is fetched, and you can self-host that on a studio network.
Does scanning change my camera originals?
No. Detection is strictly read-only — frames are decoded to score them, but no new video is written. Your originals and masters are untouched; the only output is the JSON cut list.
Can it split the footage into selects for me?
No, it only lists the boundaries. Send the cuts to video-splitter to produce one file per shot, or use lossless-trimmer to pull individual segments between two cuts.
What threshold should an editor start with?
0.3 for general rushes, 0.5 for locked-off dialogue (fewer false markers), and 0.1–0.2 for montage stringouts where you must catch dissolves. Iterate — re-scanning is free and read-only.
How precise are the timestamps?
Seconds with sub-second decimal precision, e.g. 54.88. They come straight from FFmpeg's pts_time, so they reflect the true frame presentation time rather than a rounded value.
Which formats can I drop in?
MP4, MOV, MKV, WebM, AVI, M4V and TS. ProRes in a .mov works. Other containers (e.g. legacy formats) should be remuxed to one of these first, or detection may fail to decode.
Can I diff two threshold runs?
Yes — detection is deterministic, so the same file at the same threshold always returns the same cuts. Run two thresholds and diff the arrays to see exactly which markers appeared or disappeared before you commit to an import.
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.