Batch Make Videos Unique with FFmpeg

Generating unique FFmpeg variations shouldn't be manual work

You have a video. You need 10 unique copies for multi-account posting. FFmpeg can batch this with a single script — run once, and each output gets its own crop, brightness, noise, and audio pitch values so duplicate detection treats them as distinct content.

Doing this by hand means running FFmpeg 10 times with parameters you've typed out each time. That's tedious and error-prone. A script does it in seconds and guarantees diversity across outputs.

This post covers three approaches: shell scripts (local FFmpeg), Python (API), and n8n workflows (no code). If you're new to making videos unique for TikTok, start with making each copy unique for TikTok first — it covers which parameters actually matter for bypassing detection and by how much.

Approach 1: Shell script for local FFmpeg batch processing

If you have FFmpeg installed locally, this bash script generates N variations in one command:

#!/bin/bash
# make-unique.sh - Generate N unique video variations
# Usage: ./make-unique.sh source.mp4 10

SOURCE=$1
COUNT=${2:-5}
BASENAME=$(basename "$SOURCE" .mp4)

# Validate inputs
if [ -z "$SOURCE" ] || [ ! -f "$SOURCE" ]; then
  echo "Error: source file not found: $SOURCE"
  exit 1
fi

for i in $(seq 1 $COUNT); do
  CROP=$((2 + RANDOM % 8))
  BRIGHT=$(echo "scale=3; ($RANDOM % 40 - 20) / 1000" | bc)
  NOISE=$((3 + RANDOM % 5))
  PITCH=$(echo "scale=4; 1.0 + ($RANDOM % 20 - 10) / 2000" | bc)
  CRF=$((21 + RANDOM % 5))
  HUE=$((RANDOM % 6 - 3))

  OUTPUT="${BASENAME}_v${i}.mp4"

  echo "Generating variation $i/$COUNT: crop=$CROP bright=$BRIGHT noise=$NOISE pitch=$PITCH crf=$CRF hue=$HUE"

  ffmpeg -y -i "$SOURCE" \
    -vf "crop=iw-${CROP}:ih-${CROP}:${CROP}/2:${CROP}/2,eq=brightness=${BRIGHT},noise=alls=${NOISE}:allf=t,hue=h=${HUE}" \
    -af "asetrate=44100*${PITCH},aresample=44100" \
    -c:v libx264 -crf $CRF \
    -map_metadata -1 \
    "$OUTPUT" 2>/dev/null

  # Check FFmpeg exit code
  if [ $? -ne 0 ]; then
    echo "  ERROR: FFmpeg failed on variation $i. Check your source file."
    rm -f "$OUTPUT"
    continue
  fi

  echo "  → $OUTPUT ($(du -h "$OUTPUT" | cut -f1))"
done

echo "Done. Generated $(ls ${BASENAME}_v*.mp4 2>/dev/null | wc -l) variations."

Run it:

chmod +x make-unique.sh
./make-unique.sh my-video.mp4 10

Output:

Generating variation 1/10: crop=6 bright=0.012 noise=5 pitch=1.0035 crf=23 hue=-1
  → my-video_v1.mp4 (4.2M)
Generating variation 2/10: crop=4 bright=-0.008 noise=7 pitch=0.9960 crf=22 hue=2
  → my-video_v2.mp4 (4.5M)
...
Done. Generated 10 variations.

Running locally is fast and costs nothing. The tradeoff: your machine blocks while encoding and this approach won't scale past a dozen videos or so. For anything past 20 variations, or if you need to run batches on a schedule, the API approach is cleaner.

The same batch loop works for other FFmpeg operations. If you need to convert a folder of MP4s to GIF, swap the FFmpeg command inside the loop — the structure is the same.

Error handling and output verification

The script above includes $? exit code checking. Without it, a failed FFmpeg run silently produces an incomplete file and the loop moves on. With it, you get a clear error message and the broken file gets removed.

The most common causes of FFmpeg failure in batch scripts:

• Source file is corrupted — run ffprobe your-file.mp4 first to verify it's valid

• bc not installed — on macOS: brew install bc; on Ubuntu: apt install bc

• Disk space runs out mid-batch — the script will fail partway through; check df -h before large runs

• Filename has spaces — wrap $SOURCE in double quotes everywhere: "$SOURCE", not $SOURCE

After the script finishes, verify each output:

for f in my-video_v*.mp4; do
  duration=$(ffprobe -v error -show_entries format=duration \
    -of default=noprint_wrappers=1:nokey=1 "$f" 2>/dev/null)
  size=$(du -h "$f" | cut -f1)
  echo "$f: ${duration}s, $size"
done

If a file shows duration 0 or is missing entirely, that variation failed and needs to be regenerated. Duration should match your source within 0.1 seconds for all outputs.

Approach 2: Python with the FFmpeg API

Offload encoding to the RenderIO API instead of your local machine. Your CPU stays free. Jobs run in isolated containers and complete in parallel — 10 variations take the same wall-clock time as encoding one.

import requests
import time
import random
import sys

API_KEY = "ffsk_your_api_key"
BASE_URL = "https://renderio.dev/api/v1"
HEADERS = {"Content-Type": "application/json", "X-API-KEY": API_KEY}

def generate_params(count):
    """Generate unique parameter sets for N variations."""
    params = []
    for i in range(count):
        params.append({
            "crop": random.randint(2, 10),
            "bright": round(random.uniform(-0.02, 0.02), 3),
            "noise": random.randint(3, 7),
            "pitch": round(random.uniform(0.994, 1.006), 4),
            "crf": random.randint(21, 25),
            "hue": random.randint(-3, 3),
            "sat": round(random.uniform(0.98, 1.02), 3),
        })
    return params

def build_command(p):
    """Build FFmpeg command string from parameters."""
    vf = (
        f'crop=iw-{p["crop"]}:ih-{p["crop"]}:{p["crop"]//2}:{p["crop"]//2},'
        f'eq=brightness={p["bright"]:.3f}:saturation={p["sat"]:.3f},'
        f'noise=alls={p["noise"]}:allf=t,'
        f'hue=h={p["hue"]}'
    )
    af = f'asetrate=44100*{p["pitch"]:.4f},aresample=44100'
    return f'-i {{in_video}} -vf "{vf}" -af "{af}" -c:v libx264 -crf {p["crf"]} -map_metadata -1 {{out_video}}'

def submit_job(source_url, output_name, params):
    """Submit one variation to the API."""
    cmd = build_command(params)
    res = requests.post(f"{BASE_URL}/run-ffmpeg-command", headers=HEADERS, json={
        "ffmpeg_command": cmd,
        "input_files": {"in_video": source_url},
        "output_files": {"out_video": output_name}
    })
    res.raise_for_status()
    return res.json()["command_id"]

def wait_for_jobs(command_ids):
    """Poll until all jobs complete."""
    results = {}
    pending = set(range(len(command_ids)))

    while pending:
        for i in list(pending):
            status = requests.get(
                f"{BASE_URL}/commands/{command_ids[i]}",
                headers=HEADERS
            ).json()

            if status["status"] == "completed":
                results[i] = status["output_files"]["out_video"]
                pending.discard(i)
                print(f"  Variation {i+1}: DONE → {results[i]}")
            elif status["status"] == "failed":
                results[i] = None
                pending.discard(i)
                print(f"  Variation {i+1}: FAILED → {status.get('error')}")

        if pending:
            time.sleep(3)

    return results

def main():
    source_url = sys.argv[1] if len(sys.argv) > 1 else "https://example.com/source.mp4"
    count = int(sys.argv[2]) if len(sys.argv) > 2 else 5

    print(f"Generating {count} unique variations...")
    all_params = generate_params(count)

    command_ids = []
    for i, params in enumerate(all_params):
        cmd_id = submit_job(source_url, f"variation_{i+1}.mp4", params)
        command_ids.append(cmd_id)
        print(f"  Submitted variation {i+1}: {cmd_id}")

    print(f"\nAll {count} jobs submitted. Waiting for completion...")
    results = wait_for_jobs(command_ids)

    success = sum(1 for v in results.values() if v is not None)
    print(f"\nComplete: {success}/{count} variations generated successfully")

    for i in sorted(results.keys()):
        if results[i]:
            print(f"  variation_{i+1}.mp4: {results[i]}")

if __name__ == "__main__":
    main()

Run it:

python batch-unique.py "https://your-storage.com/source.mp4" 10

Output:

Generating 10 unique variations...
  Submitted variation 1: cmd_a1b2c3
  Submitted variation 2: cmd_d4e5f6
  ...
All 10 jobs submitted. Waiting for completion...
  Variation 3: DONE → https://media.renderio.dev/variation_3.mp4
  Variation 1: DONE → https://media.renderio.dev/variation_1.mp4
  ...
Complete: 10/10 variations generated successfully

For more detail on the Python client pattern — authentication, polling, webhook callbacks — the Python API guide covers the full setup.

Approach 3: n8n for no-code FFmpeg batch processing

For non-developers or teams managing automation visually, build this as an n8n workflow. Here's the full node configuration:

Node 1: Webhook Trigger

Set the trigger to receive a POST request with:

{ "videoUrl": "https://...", "count": 10 }

Node 2: Code node (generate parameters)

const count = $input.first().json.count || 5;
const videoUrl = $input.first().json.videoUrl;
const variations = [];

for (let i = 0; i < count; i++) {
  variations.push({
    json: {
      videoUrl,
      index: i + 1,
      crop: 2 + Math.floor(Math.random() * 8),
      bright: (Math.random() * 0.04 - 0.02).toFixed(3),
      noise: 3 + Math.floor(Math.random() * 5),
      pitch: (0.994 + Math.random() * 0.012).toFixed(4),
      crf: 21 + Math.floor(Math.random() * 5),
      hue: Math.floor(Math.random() * 7) - 3
    }
  });
}

return variations;

The code node outputs one item per variation. Each item carries its own parameter set.

Node 3: Split in Batches (size: 5)

Keeps API requests within rate limits. If you're on the Growth plan (1,000 commands/month), batching 5 at a time gives enough headroom for retries without hitting limits.

Node 4: HTTP Request (submit to RenderIO)

• Method: POST

• URL: https://renderio.dev/api/v1/run-ffmpeg-command

• Header: X-API-KEY = your key

• Body (JSON):

{
  "ffmpeg_command": "-i {{in_video}} -vf \"crop=iw-{{ $json.crop }}:ih-{{ $json.crop }}:{{ $json.crop }}/2:{{ $json.crop }}/2,eq=brightness={{ $json.bright }},noise=alls={{ $json.noise }}:allf=t,hue=h={{ $json.hue }}\" -af \"asetrate=44100*{{ $json.pitch }},aresample=44100\" -c:v libx264 -crf {{ $json.crf }} -map_metadata -1 {{out_video}}",
  "input_files": { "in_video": "{{ $json.videoUrl }}" },
  "output_files": { "out_video": "variation_{{ $json.index }}.mp4" }
}

Nodes 5-7: Poll and collect

Add a Wait node (2-3 seconds), then an HTTP Request to poll /commands/{command_id}, then a Switch node to route completed vs still-processing jobs. Loop the still-processing items back to the Wait node.

Parameter randomization: random vs grid-based

Fully random

Each parameter is independently random within a range. Simple to implement.

params = {
    "crop": random.randint(2, 10),
    "bright": round(random.uniform(-0.02, 0.02), 3),
    "noise": random.randint(3, 7),
}

The problem with pure random: with narrow ranges and a small number of variations, you can get near-identical combinations by chance. If crop=4 and bright=0.01 appears in both variation 1 and variation 7, those two files will be very similar at the fingerprint level.

Grid-based (guaranteed maximum diversity)

Distribute parameters evenly across the range. Every variation is maximally different from every other, and you won't get duplicates regardless of how many you generate.

def grid_params(count):
    crops = [2, 4, 6, 8, 10]
    brights = [-0.02, -0.01, 0, 0.01, 0.02]
    noises = [3, 4, 5, 6, 7]

    params = []
    for i in range(count):
        params.append({
            "crop": crops[i % len(crops)],
            "bright": brights[i % len(brights)],
            "noise": noises[i % len(noises)],
            "crf": 21 + (i % 5),
        })
    return params

With grid-based params, variations 1 and 6 share the same crop value (both use crops[0] since i % 5 cycles back at 5), but brightness, noise, and CRF are all at different points in their ranges. The visual and audio fingerprint of each output is meaningfully distinct.

For 50+ variations, grid-based is the right call. For fewer than 10, random works fine since collision probability is low.

Seeded random (reproducible)

Same seed produces the same parameters every time. Useful when you need to regenerate the same set of variations without storing every parameter set explicitly.

random.seed(42)  # Same seed = same variations every time
params = generate_params(10)

Verifying FFmpeg batch output quality

After batch generation, check that each file is actually different and intact:

# File sizes (different CRF + noise values produce different file sizes)
ls -lah my-video_v*.mp4

# MD5 hashes (all must differ — matching hashes mean identical parameter sets)
md5sum my-video_v*.mp4 | sort

# Duration check (all should match source within 0.1 seconds)
for f in my-video_v*.mp4; do
  ffprobe -v error -show_entries format=duration \
    -of default=noprint_wrappers=1:nokey=1 "$f"
done

If two MD5 hashes match, those two files are identical. It means the random parameter generation produced the same combination twice — switch to grid-based or widen your parameter ranges.

Duration should match the source for all variations. A shorter duration means FFmpeg cut out early, which usually means the command failed partway through.

Troubleshooting common FFmpeg batch issues

"bc: command not found" on the shell script

The shell script uses bc for floating-point math. Install it: apt install bc (Ubuntu/Debian) or brew install bc (macOS). If you'd rather not install it, replace the bc calls with pre-calculated integer ranges and accept slightly less precision in the brightness and pitch values.

Outputs look visually identical

Check whether your parameter ranges are too narrow. A crop of 2-4 pixels with brightness 0.001-0.003 might not be enough to defeat perceptual hashing. The making each copy unique guide documents the minimum change thresholds that actually affect each detection layer.

Python script gets a 429 rate limit error

Add a delay between submissions when running large batches:

for i, params in enumerate(all_params):
    cmd_id = submit_job(source_url, f"variation_{i+1}.mp4", params)
    command_ids.append(cmd_id)
    if i % 10 == 9:  # Brief pause every 10 submissions
        time.sleep(1)

n8n HTTP Request node fails with 401

The RenderIO API takes the key directly in the X-API-KEY header without a Bearer prefix. Make sure the header value is just the key itself, not Bearer ffsk_....

FFmpeg silently produces a 0-byte file

This usually means the filter chain has a syntax error that only surfaces at runtime. Test the exact command manually with a real file before putting it in a loop. The error message that 2>/dev/null was suppressing is the one you need.

Scaling considerations

All variations process in parallel on the API. The main bottleneck at high volume is rate limiting. Batch your submissions to stay within limits.

Get started

Shell scripts are fine for one-off batches on your own machine. Python with the API is more reliable at scale — jobs run in parallel and your CPU stays free. n8n is the right call if you want a reusable pipeline without writing Python.

The Growth plan at $29/mo covers 1,000 commands. Scale to Business ($99/mo, 20,000 commands) as volume grows. For TikTok-specific automation, the TikTok content automation pipeline in n8n builds on these techniques. Dropshippers can check the dropshipping video automation guide for a supplier-to-TikTok pipeline.

FAQ

Does FFmpeg batch processing work on Windows?

The shell script is Bash-only, so it needs WSL (Windows Subsystem for Linux) on Windows. The Python script and n8n workflow work on any OS since they don't run FFmpeg locally — they call the API. If you're on Windows, the Python or n8n approach is the path of least resistance.

How many unique FFmpeg variations can I generate from one video?

With the six parameters in this guide (crop, brightness, noise, pitch, CRF, hue), the parameter space has over 55,000 distinct combinations. In practice you'll rarely need more than a few hundred — and by that point you should be using the enterprise pipeline covered in the unique video variations at scale guide.

What's the difference between the shell script and API approach?

The shell script runs FFmpeg on your local machine — your CPU blocks while encoding. The API approach sends commands to RenderIO's cloud infrastructure. Your machine submits a JSON request, and the actual encoding happens remotely in parallel containers. Ten variations take the same wall-clock time as one.

How do I know if my variations are actually unique enough for TikTok?

Run a pHash comparison between any two outputs. If the Hamming distance exceeds 10 on a 64-bit hash, perceptual fingerprinting won't match them. The making each copy unique guide covers how to test this properly before posting.

Can I generate variations while keeping the same video length?

Yes. None of the parameters in this guide change video duration. Crop removes edge pixels (not frames), brightness/noise/hue are visual filters, pitch shifts audio frequency, and CRF affects compression quality. Output duration matches the source exactly.