Before You Batch-Cut 100 Videos, Run This FFprobe Preflight

Claire Hughes — Mon, 02 Nov 2026 07:04:38 +0000

Cutting one video is easy. Cutting a folder full of mixed files is where unexpected edge cases show up.

Imagine a folder with 100 clips: some are vertical, some are horizontal, one is shorter than the requested cut duration, and another has no audio track. Starting the batch without checking the inputs can leave you sorting through confusing outputs later.

Here is a small read-only preflight you can run before a batch job. It does not edit, upload, or split any video.

First, see what FFprobe reports

FFprobe is shipped with FFmpeg. Try this command on one file:

ffprobe -v error -show_entries format=duration:stream=codec_type,codec_name,width,height -of json "input.mp4"

The JSON lets you check three useful things before processing:

Duration: Is a source shorter than the segment length you want?
Video stream and dimensions: Does the container actually contain a video stream, and what is its resolution?
Audio streams: Is there an audio track? A silent video might be intentional, so this is a signal to review, not an automatic error.

A Python preflight for a whole folder

Save this as preflight.py. It reads metadata only and prints one line per file.

from pathlib import Path
import json
import subprocess
import sys

EXTS = {".mp4", ".mov", ".mkv", ".webm"}
folder = Path(sys.argv[1]) if len(sys.argv) > 1 else Path("videos")
clip_seconds = float(sys.argv[2]) if len(sys.argv) > 2 else 20.0

if not folder.is_dir():
    raise SystemExit(f"Folder not found: {folder}")

for video in sorted(folder.iterdir()):
    if not video.is_file() or video.suffix.lower() not in EXTS:
        continue

    command = [
        "ffprobe", "-v", "error", "-show_entries",
        "format=duration:stream=codec_type,codec_name,width,height",
        "-of", "json", str(video),
    ]
    try:
        result = subprocess.run(command, capture_output=True, text=True)
    except FileNotFoundError:
        raise SystemExit("Install FFmpeg/FFprobe and add it to PATH")

    if result.returncode != 0:
        print(f"{video.name}: could not inspect file")
        continue

    try:
        info = json.loads(result.stdout)
    except json.JSONDecodeError:
        print(f"{video.name}: invalid metadata")
        continue

    streams = info.get("streams", [])
    v = next((s for s in streams if s.get("codec_type") == "video"), None)
    has_audio = any(s.get("codec_type") == "audio" for s in streams)
    try:
        duration = float(info.get("format", {}).get("duration"))
    except (TypeError, ValueError):
        duration = None

    if v is None:
        status = "NO VIDEO STREAM"
    elif duration is None:
        status = "UNKNOWN DURATION"
    elif duration < clip_seconds:
        status = "SHORTER THAN TARGET CLIP"
    else:
        status = "CHECK SAMPLE OUTPUT"

    dimensions = f"{v.get('width', '?')}x{v.get('height', '?')}" if v else "?"
    print(f"{video.name} | {duration or '?'}s | {dimensions} | audio={has_audio} | {status}")

Run it in PowerShell or a terminal after installing FFmpeg and Python:

python preflight.py "D:\\Videos" 20

That last number is your intended clip length in seconds. A two-second test file, for example, will be flagged as shorter than a 20-second target.

What this does not prove

Metadata checks do not guarantee that every frame decodes correctly, audio stays synchronized, or the final segment looks right. For that, test a small batch and inspect an early, middle, and final output clip. Also keep a clear way to trace each output back to the source.

A successful progress bar is not the same as a validated result.

One question for other developers

If a job creates 300 clips, which would you prioritize first: faster processing, a contact sheet of thumbnails, or clearer output filenames? I'd be interested in how you review large batches without opening every file.

Context: this standalone example is inspired by workflow questions around ChanPilo, a commercial batch video-processing project. It is not a claim that this example script is included in the current product. This post was prepared with GPT assistance; the FFprobe example was checked on a small synthetic video. No affiliate links.

How I Simplified Batch Video Cutting for Content Creators

Claire Hughes — Sun, 01 Nov 2026 08:58:27 +0000

I'm part of the team behind ChanPilo, a commercial Windows tool for cutting videos in batches. While working on its workflow, one recurring question has been: how do you make repetitive video preparation less tedious without turning a small utility into a full editor?

This post is about the workflow and the trade-offs, not a product review.

The repetitive work adds up

Imagine a creator with a folder of source footage and a need to produce shorter clips. With a one-file-at-a-time workflow, they repeatedly open a file, choose cutting settings, start processing, locate the output, and move on to the next file.

One or two files are manageable. With a large batch, the repeated setup becomes a bigger part of the job than the actual decision-making.

A simpler batch workflow

The approach we focus on is straightforward:

Choose the source videos together. Import a collection rather than reopening a tool for each file.
Set the cutting parameters deliberately. Decide how the videos should be split before starting the batch.
Run the processing workflow. Let the tool perform the repeated cutting steps.
Review the output clips. Check whether the results match the intended use before uploading or editing further.

This is the core workflow we are building ChanPilo around. It runs locally on Windows and is aimed at creators handling many video files.

What matters more than a crowded feature list

A focused batch utility should make a few questions easy to answer:

Which files am I about to process?
What cutting settings are in effect?
Where will the results go?
How can I tell which jobs finished and which need attention?
Can I examine a small test batch before committing to a large one?

Those questions are useful evaluation criteria for any batch video tool, regardless of how its internals are implemented.

A practical testing checklist

Before using a batch cutter on important footage, I recommend a short test:

Keep the original source files untouched.
Start with several videos of different lengths.
Check a few output clips for duration and playback.
Confirm that output files are organized in a way you can understand.
Try one unusual or problematic source file and see how the workflow reports it.

This catches mismatched expectations early, when they are inexpensive to correct.

A batch cutter is not a full video editor

A narrow tool can save repetitive clicks, but it should not pretend to replace timeline editing, precise creative decisions, color work, or storytelling. A realistic workflow is to use batch cutting for preparation, then use an editor for clips that need detailed creative work.

I'm interested in how other creators handle this boundary. Which step wastes the most time for you: selecting many files, configuring repeated cuts, reviewing outputs, or something else?

Disclosure: I am involved with ChanPilo, the commercial tool mentioned above. AI assistance was used to draft this article; the ChanPilo team will review it before publication.

DEV Community: Claire Hughes