How to Split Video into Segments with FFmpeg (CLI + API)

Originally published at ffmpeg-micro.com.

You need to chop a long video into equal-length clips. Maybe you're building a social media repurposing pipeline, batch-processing uploads for a CMS, or splitting recordings into chapters. FFmpeg's segment muxer handles this, but getting it right means fighting with keyframe alignment, timestamp resets, and infrastructure you don't want to manage.

This guide covers the exact FFmpeg commands for splitting video, the flags that matter, and how to skip the server setup entirely with an API.

Quick answer

Split a video into 10-second segments with no re-encoding:

ffmpeg -i input.mp4 -c copy -f segment -segment_time 10 -reset_timestamps 1 segment_%03d.mp4

This uses the segment muxer to cut at the nearest keyframe boundary. Each output file gets its own timestamps starting at zero.

How the FFmpeg segment muxer works

The segment muxer (-f segment) tells FFmpeg to write output to multiple files instead of one. It splits based on a time interval you set with -segment_time.

ffmpeg -i input.mp4 \
  -c copy \
  -f segment \
  -segment_time 30 \
  -reset_timestamps 1 \
  output_%03d.mp4

Key flags:

-f segment activates the segment muxer
-segment_time 30 sets the target duration for each segment in seconds
-reset_timestamps 1 resets timestamps to zero for each segment (without this, players show wrong seek positions)
-c copy copies streams without re-encoding (fast, but cuts only at keyframes)
output_%03d.mp4 is the numbered output pattern (000, 001, 002, ...)

The %03d pattern in the output filename is required. FFmpeg increments the number for each new segment.

Getting a segment manifest

If your pipeline needs to know what segments were created and their exact timestamps, add -segment_list:

ffmpeg -i input.mp4 \
  -c copy \
  -f segment \
  -segment_time 30 \
  -reset_timestamps 1 \
  -segment_list segments.csv \
  -segment_list_type csv \
  segment_%03d.mp4

The CSV output looks like this:

segment_000.mp4,0.000000,30.030000
segment_001.mp4,30.030000,60.060000
segment_002.mp4,60.060000,85.418750

Each row has the filename, start time in seconds, and end time in seconds. You can also use -segment_list_type flat for just filenames or -segment_list_type ffconcat for FFmpeg concat demuxer format.

Timestamp-based filenames with strftime

For automation pipelines where you're processing videos on a schedule, timestamp-based filenames prevent collisions:

ffmpeg -i input.mp4 \
  -c copy \
  -f segment \
  -segment_time 30 \
  -reset_timestamps 1 \
  -strftime 1 \
  "clip_%Y%m%d_%H%M%S.mp4"

This produces files like clip_20260523_143000.mp4. Useful when you're processing multiple source videos into the same output directory.

The keyframe problem

When you use -c copy (stream copy, no re-encoding), FFmpeg can only cut at keyframe boundaries. If your video has keyframes every 2 seconds and you request 5-second segments, your actual segments might be 4 or 6 seconds long.

Two ways to handle this:

Accept keyframe-aligned cuts (fast, slightly imprecise):

ffmpeg -i input.mp4 -c copy -f segment -segment_time 5 -reset_timestamps 1 output_%03d.mp4

Force exact timing (requires re-encoding, 10-50x slower):

ffmpeg -i input.mp4 \
  -c:v libx264 -crf 23 \
  -force_key_frames "expr:gte(t,n_forced*5)" \
  -f segment \
  -segment_time 5 \
  -reset_timestamps 1 \
  output_%03d.mp4

The second approach re-encodes the video and inserts keyframes at exact 5-second intervals. Accurate, but dramatically slower depending on your hardware and encoding settings.

For most batch processing and content repurposing workflows, keyframe-aligned cuts are good enough.

Splitting video with the FFmpeg Micro API

Running FFmpeg on your own server means managing binaries, scaling for concurrent jobs, and handling timeouts on long videos. The FFmpeg Micro API handles the infrastructure so you can focus on your pipeline logic.

The API uses -ss (seek) and -t (duration) per transcode job, which gives you precise control over exactly what you extract from each video.

Extract a 30-second segment starting at 1 minute:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{"url": "https://storage.example.com/video.mp4"}],
    "outputFormat": "mp4",
    "options": [
      {"option": "-ss", "argument": "60"},
      {"option": "-t", "argument": "30"},
      {"option": "-c", "argument": "copy"}
    ]
  }'

The response includes a job ID you can poll:

{
  "id": "b5f5a9c0-9e33-4e77-8a5b-6a0c2cd9c0b3",
  "status": "queued",
  "output_format": "mp4"
}

Check status and download the result:

curl https://api.ffmpeg-micro.com/v1/transcodes/JOB_ID \
  -H "Authorization: Bearer YOUR_API_KEY"

curl https://api.ffmpeg-micro.com/v1/transcodes/JOB_ID/download \
  -H "Authorization: Bearer YOUR_API_KEY"

Split a 5-minute video into 30-second segments programmatically:

import requests

API_KEY = "YOUR_API_KEY"
BASE = "https://api.ffmpeg-micro.com/v1"
VIDEO_URL = "https://storage.example.com/video.mp4"
SEGMENT_SECONDS = 30
TOTAL_SECONDS = 300

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

jobs = []
for start in range(0, TOTAL_SECONDS, SEGMENT_SECONDS):
    resp = requests.post(f"{BASE}/transcodes", headers=headers, json={
        "inputs": [{"url": VIDEO_URL}],
        "outputFormat": "mp4",
        "options": [
            {"option": "-ss", "argument": str(start)},
            {"option": "-t", "argument": str(SEGMENT_SECONDS)},
            {"option": "-c", "argument": "copy"}
        ]
    })
    job = resp.json()
    jobs.append(job)
    print(f"Segment {start}s-{start + SEGMENT_SECONDS}s: {job['id']}")

All 10 jobs run in parallel on cloud infrastructure. No server, no queue management, no timeout handling on your end.

Get a free API key and try splitting your first video.

Common pitfalls when splitting video

Forgetting -reset_timestamps 1. Without this flag, each segment keeps the timestamps from the original video. Players show the wrong position on the seek bar, and some players won't play the segments at all.

Audio sync drift with -c copy. Stream copy can sometimes drift audio out of sync at cut points. If you hear pops or sync issues, switch to -c:a aac to re-encode just the audio track while keeping video as copy.

Output pattern without %d. If you forget the number pattern in the output filename, FFmpeg overwrites the same file for every segment. Always include %03d or similar.

Segment time vs. actual duration. With -c copy, segments won't be exactly the duration you requested. They'll be close, but keyframe alignment means they might vary by 1-2 seconds. If you need frame-accurate cuts, you have to re-encode.

Large video timeouts. Running the segment muxer locally on a 2-hour video is fine. Running it on a server with a 30-second HTTP timeout kills the job mid-split. If you're processing long videos in a web pipeline, use an async API or background worker.

FAQ

How do I split a video into equal parts with FFmpeg?

Use the segment muxer: ffmpeg -i input.mp4 -c copy -f segment -segment_time 60 -reset_timestamps 1 part_%03d.mp4. Replace 60 with your desired segment length in seconds. Segments will be approximately equal, with variation depending on keyframe positions.

Can I split video without re-encoding?

Yes. Use -c copy with the segment muxer for near-instant splitting. The tradeoff is that cuts happen at keyframe boundaries, so segment durations won't be frame-accurate. For most batch processing and content repurposing workflows, keyframe-aligned cuts are close enough.

What's the difference between the segment muxer and using -ss with -t?

The segment muxer (-f segment) automatically splits into multiple files in a single FFmpeg pass. The -ss/-t approach extracts one specific clip per command. The segment muxer is faster for creating many segments from one video locally. The -ss/-t approach works better with APIs and cloud pipelines where each segment runs as an independent job.

Does the FFmpeg segment muxer work with audio files?

Yes. Same syntax with audio containers: ffmpeg -i podcast.mp3 -c copy -f segment -segment_time 600 chunk_%03d.mp3. This splits a podcast into 10-minute chunks without re-encoding.

How do I split video into segments with an API?

FFmpeg Micro lets you submit transcode jobs via HTTP with -ss and -t options to extract specific segments. Each job runs on cloud infrastructure with automatic scaling. Sign up for a free API key and POST to /v1/transcodes with your input URL, output format, and seek/duration options.

Last verified: May 2026 with FFmpeg 7.x and FFmpeg Micro API v1

推荐订阅源

DEV Community