Forem: RenderIO

Kling AI Video Post-Processing with FFmpeg

RenderIO — Tue, 14 Apr 2026 07:41:28 +0000

How to fix Kling AI video artifacts with FFmpeg post-processing

Kling AI's raw output needs FFmpeg post-processing before it's ready to publish. The motion and camera work are genuinely good — tracking shots, slow pans, spatial consistency — but the raw file comes with texture flickering, color drift, aggressive compression, and AI metadata embedded in the container. These are fixable with a single FFmpeg command in about 5 seconds.

If you're working with other AI generators too, the general AI video post-processing guide covers Runway, Pika, and Sora with their own tuning profiles. And for making AI video look organic on social platforms, the natural look guide goes deeper on color grading and motion.

What Kling gets right (and why post-processing is still worth it)

Kling's strength is camera movement. It handles tracking shots, slow pans, and dolly-style motion better than most generators as of early 2026. The motion feels deliberate rather than random. Characters maintain spatial consistency during movement, which is still something Pika struggles with.

The tradeoff is that Kling's diffusion model introduces more temporal noise than Runway or Sora. Each frame looks fine in isolation, but played in sequence, surfaces shimmer. That's fixable with the right temporal filters. You're essentially smoothing the inconsistencies while keeping the strong motion intact.

Kling's strong points — camera movement, spatial consistency — are worth keeping. Post-processing protects them.

Kling-specific output characteristics

Texture flickering

This is the most visible artifact. Kling's diffusion process produces more temporal inconsistency than competitors. Walls, water, fabric: flat or semi-flat surfaces shift texture between frames. It looks like the surface is "breathing."

The cause is per-frame noise in the diffusion sampling. Each frame gets a slightly different texture pattern for the same surface. When played at 24-30fps, these differences read as flickering.

In practical terms: a wall in a Runway clip stays visually static. The same wall in a Kling clip subtly pulses. It's less noticeable with fast camera movement (the motion masks it), but very obvious in locked-off or slow-motion shots.

Color temperature drift

Over a 5-10 second clip, Kling's color balance shifts. A neutral-lit scene might start at roughly 5600K and end closer to 5100K, a visible shift from neutral to slightly warm or cool. You see it most in skin tones and neutral gray backgrounds.

This happens because Kling's temporal consistency model doesn't fully constrain color across the generation window. The diffusion process optimizes per-frame quality more aggressively than cross-frame consistency. Runway and Sora have tighter temporal constraints, which is partly why their motion feels less dynamic. They trade movement freedom for consistency.

Resolution and compression

Kling outputs at 720p or 1080p depending on your subscription tier. Even the 1080p output uses aggressive compression. The encoded bitrate is typically 4-6 Mbps, which causes visible blocking in dark areas, gradients, and fine textures. For comparison, a well-encoded 1080p file for social media should be 8-12 Mbps.

The 720p output needs upscaling for any platform that expects 1080p (TikTok, Reels, YouTube Shorts). Simple bilinear upscaling makes the compression artifacts worse. You need a sharper algorithm plus some edge enhancement.

Metadata

Kling embeds generation metadata: model version, prompt fragments, generation parameters, and often Chinese-language strings from the platform. Social platforms and content detection systems can flag files based on this metadata. Stripping it is the first step in any pipeline. The metadata stripping guide covers all the edge cases, including the difference between container and stream-level metadata.

Post-processing pipeline

Step 1: Strip metadata

Remove everything Kling embeds, and prevent FFmpeg from adding its own encoder tag:

ffmpeg -i kling-output.mp4 \
  -map_metadata -1 \
  -fflags +bitexact \
  -c copy \
  clean.mp4

The -fflags +bitexact flag stops FFmpeg from writing encoder: Lavf... into the output. Without it, the file still carries a metadata fingerprint.

Step 2: Fix texture flickering

Kling needs stronger temporal smoothing than other generators:

ffmpeg -i clean.mp4 \
  -vf "nlmeans=s=8:p=5:r=15,tmix=frames=5:weights='1 1 2 1 1'" \
  -c:v libx264 -crf 18 -c:a copy \
  denoised.mp4

Why these specific values:

nlmeans=s=8: spatial denoising strength. Most generators need 4-6. Kling needs 8 because its per-frame texture noise is higher. Going above 10 starts smearing real detail.
p=5: patch size. Larger patches catch more of Kling's broad texture shifts.
r=15: search radius. Wider search finds better matches in Kling's noisier frames.
tmix=frames=5:weights='1 1 2 1 1': blends 5 frames with a center-weighted kernel. The center frame (weight 2) dominates, and neighboring frames smooth temporal flicker. Most generators work fine with frames=3. Kling's wider temporal variance needs 5.

For clips with fast camera movement, you can drop to s=6 and frames=3 since the motion already masks the flicker. For locked-off shots (no camera movement), go up to s=10 and frames=7.

Step 3: Stabilize color temperature

ffmpeg -i denoised.mp4 \
  -vf "colorbalance=rs=0.02:gs=0:bs=-0.02:rm=0.01:gm=0:bm=-0.01,eq=saturation=1.05" \
  -c:v libx264 -crf 18 -c:a copy \
  color-fixed.mp4

This applies a slight warm bias to counteract Kling's tendency to drift cool. The saturation=1.05 compensates for the slight desaturation that Kling's compression introduces.

For clips with visible color drift across the duration, use the deflicker filter instead:

ffmpeg -i denoised.mp4 \
  -vf "deflicker=size=10:mode=am" \
  -c:v libx264 -crf 18 -c:a copy \
  stable-color.mp4

deflicker analyzes luminance across a window of frames and normalizes it. size=10 means it looks at 10 frames in each direction. mode=am uses arithmetic mean, which handles gradual drifts better than the geometric mean mode.

Step 4: Upscale (if starting from 720p)

ffmpeg -i color-fixed.mp4 \
  -vf "scale=1920:1080:flags=lanczos,unsharp=3:3:0.8" \
  -c:v libx264 -crf 18 -c:a copy \
  upscaled.mp4

Lanczos produces the sharpest upscale of FFmpeg's built-in algorithms. The unsharp=3:3:0.8 filter adds back edge detail that upscaling softens (3x3 luma matrix with 0.8 strength). Going above 1.0 on the strength introduces visible halos around edges.

If the source is 1080p already, skip the scale and just apply the unsharp to recover detail lost by Kling's compression. For more on compression settings, see the video compression guide.

Step 5: Format for target platform

For TikTok (9:16):

ffmpeg -i upscaled.mp4 \
  -filter_complex "[0:v]scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920,boxblur=25[bg];[0:v]scale=1080:1920:force_original_aspect_ratio=decrease[fg];[bg][fg]overlay=(W-w)/2:(H-h)/2[v]" \
  -map "[v]" -map 0:a? \
  -af "loudnorm=I=-14:TP=-2:LRA=7" \
  -c:v libx264 -crf 22 -c:a aac -b:a 128k \
  -movflags +faststart \
  tiktok.mp4

This creates a blurred-background letterbox effect if the aspect ratio doesn't match 9:16. The loudnorm filter normalizes audio to TikTok's preferred loudness level. For transcoding between formats in general, the FFmpeg transcode guide covers codec selection and container compatibility.

Combined single-command pipeline

All steps in one FFmpeg command:

ffmpeg -i kling-output.mp4 \
  -map_metadata -1 \
  -fflags +bitexact \
  -vf "nlmeans=s=8:p=5:r=15,tmix=frames=5:weights='1 1 2 1 1',colorbalance=rs=0.02:gs=0:bs=-0.02,eq=saturation=1.05,scale=1920:1080:flags=lanczos,unsharp=3:3:0.8" \
  -af "loudnorm=I=-14:TP=-2:LRA=7" \
  -c:v libx264 -crf 18 -preset medium \
  -c:a aac -b:a 128k \
  -movflags +faststart \
  processed.mp4

This runs all filters in sequence on each frame. Processing time is roughly 1-3x the clip duration on a modern CPU. The nlmeans filter is the slowest part because it's doing spatial denoising on every frame.

RenderIO API integration

Send the combined pipeline as a single API call:

curl -X POST https://renderio.dev/api/v1/run-ffmpeg-command \
  -H "X-API-KEY: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "ffmpeg_command": "-i {{in_video}} -map_metadata -1 -fflags +bitexact -vf \"nlmeans=s=8:p=5:r=15,tmix=frames=5:weights=1_1_2_1_1,colorbalance=rs=0.02:gs=0:bs=-0.02,eq=saturation=1.05,scale=1920:1080:flags=lanczos,unsharp=3:3:0.8\" -af \"loudnorm=I=-14:TP=-2:LRA=7\" -c:v libx264 -crf 18 -preset medium -c:a aac -b:a 128k -movflags +faststart {{out_video}}",
    "input_files": { "in_video": "https://example.com/kling-output.mp4" },
    "output_files": { "out_video": "processed-kling.mp4" }
  }'

Batch processing workflow

async function processKlingBatch(videoUrls) {
  const KLING_PIPELINE = `-i {{in_video}} -map_metadata -1 -fflags +bitexact -vf "nlmeans=s=8:p=5:r=15,tmix=frames=5:weights=1_1_2_1_1,colorbalance=rs=0.02:gs=0:bs=-0.02,eq=saturation=1.05,scale=1920:1080:flags=lanczos,unsharp=3:3:0.8" -af "loudnorm=I=-14:TP=-2:LRA=7" -c:v libx264 -crf 18 -c:a aac -b:a 128k -movflags +faststart {{out_video}}`;

  const jobs = videoUrls.map((url, i) =>
    fetch("https://renderio.dev/api/v1/run-ffmpeg-command", {
      method: "POST",
      headers: {
        "X-API-KEY": process.env.RENDERIO_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        ffmpeg_command: KLING_PIPELINE,
        input_files: { in_video: url },
        output_files: { out_video: `kling-processed-${i}.mp4` },
      }),
    }).then(r => r.json())
  );

  return Promise.all(jobs);
}

const urls = klingExports.map(e => e.downloadUrl);
const results = await processKlingBatch(urls);

Kling vs. other generators: filter tuning

(Values based on our internal testing with 720p/1080p Kling exports across 50+ clips; other generator values are averages across comparable test clips.)

Parameter	Kling	Runway Gen-3	Pika	Sora
nlmeans strength	8-10	4-6	5-7	3-5
tmix frames	5	3	3	3
Color correction	Warm bias needed	Minimal	Slight warm	Minimal
Upscale needed	Often (720p base)	Rarely	Sometimes	Rarely
Deflicker needed	Often	Rarely	Sometimes	Rarely

Kling needs the most post-processing of the major generators. Runway and Sora come out cleaner but with less dynamic motion. Pika sits in the middle.

Here's how to tune for each generator's specific failure modes:

Kling: Start with nlmeans=s=8 and tmix=frames=5. For locked-off shots with no camera movement, push to s=10 and frames=7 — the texture breathing is most visible when nothing is moving. Apply the warm colorbalance bias (rs=0.02:bs=-0.02) on every clip; Kling drifts consistently cool over time.

Runway Gen-3: Much cleaner baseline. Use nlmeans=s=4 and tmix=frames=3. You can skip color correction entirely on most clips. The main issue with Runway is slight temporal softness rather than texture noise — unsharp=3:3:0.5 after the scale step recovers detail without oversharpening.

Pika: Falls between Kling and Runway for noise. Start with nlmeans=s=5 and tmix=frames=3. Pika's main artifact is horizontal banding on gradients; deflicker=size=5:mode=am handles it better than nlmeans alone. Check the sky in any clip with sky in frame — that's where Pika's banding shows up first.

Sora: The cleanest output of the four. nlmeans=s=3 is usually enough, sometimes s=0 (skip denoising entirely). Sora's tradeoff is motion stiffness rather than noise, which post-processing can't fix — it's a model characteristic. Focus on the metadata strip and format conversion steps.

For a complete walkthrough of processing Runway output specifically, see the Runway to TikTok format guide.

Automation with webhooks

Set up a webhook to trigger post-processing automatically when Kling exports finish:

app.post("/webhook/renderio", (req, res) => {
  const { command_id, status, output_files } = req.body;
  if (status === "SUCCESS") {
    uploadToTikTok(output_files["processed-kling.mp4"]);
  }
  res.sendStatus(200);
});

RenderIO retries failed webhook deliveries with exponential backoff. If your server is down, the dead letter queue holds the notification for later.

FAQ

Does Kling output need post-processing for every use case?

Not always. If you're posting a quick test or internal review, the raw output is fine. But for anything public (TikTok, Reels, YouTube Shorts, ads), the flickering and color drift will be visible, especially on larger screens. The metadata alone is worth stripping even for casual use.

Can I use GPU acceleration for the post-processing pipeline?

The bottleneck is nlmeans, which doesn't have a CUDA equivalent in FFmpeg. The other filters (tmix, colorbalance, scale) are fast on CPU. If you're processing many clips in parallel, an FFmpeg API handles the scaling without you managing hardware. For GPU encoding specifically, see the CUDA and NVENC guide.

How much quality does the re-encoding step lose?

At CRF 18, the quality loss from re-encoding is minimal. You'd need a side-by-side comparison at pixel level to notice. Kling's own output compression is much more destructive than a CRF 18 x264 re-encode. You're actually improving perceived quality by denoising and sharpening, even though you're adding a re-encode step.

What if my Kling output is already 1080p? Should I skip the upscale?

Skip the scale filter but keep the unsharp=3:3:0.8. Even at 1080p, Kling's aggressive compression softens fine detail. The unsharp filter recovers edge definition without the upscale step.

Can I apply this pipeline to other AI video generators?

Yes, with different filter strengths. Runway needs weaker denoising (s=4-6, frames=3) and usually no color correction. Sora needs the least processing. The tuning table above has starting points for each generator. The AI video post-processing for TikTok guide covers multi-generator pipelines.

FFmpeg Resize Video: Scale, Crop & Pad (CLI + API)

RenderIO — Tue, 14 Apr 2026 07:41:03 +0000

Resize a video in one command

ffmpeg -i input.mp4 -vf "scale=1280:720" output.mp4

That's the simplest way to resize video with FFmpeg, taking input.mp4 and outputting it at 1280x720 pixels. If your source is 1920x1080, the aspect ratio matches and everything looks fine. If your source is 4:3 or vertical, the output gets stretched. Usually not what you want.

This guide covers how to resize without distortion, how to crop and pad for different platforms, which scaling algorithm to pick, and how to batch-process hundreds of files. There's also an API approach at the end for when you don't want FFmpeg on your server at all.

New to FFmpeg? The command line tutorial covers installation and basic syntax. Already comfortable? The FFmpeg cheat sheet has 50 commands organized by task, including several resize recipes. For a focused reference on the scale filter itself, algorithm selection, and common errors, see the FFmpeg scale video guide.

The scale filter, properly explained

The scale filter is where all FFmpeg resize operations start. The syntax is scale=width:height, but the interesting part is what happens when you don't specify both.

Fixed dimensions (force exact size):

ffmpeg -i input.mp4 -vf "scale=1920:1080" output.mp4

This forces the output to exactly 1920x1080 regardless of the input aspect ratio. A 4:3 source will look horizontally stretched. A 9:16 vertical video will look squished. Only use exact dimensions when you know the source ratio matches.

Auto-calculate one dimension:

ffmpeg -i input.mp4 -vf "scale=1280:-2" output.mp4

Setting width to 1280 and height to -2 tells FFmpeg to figure out the height itself while keeping the aspect ratio. The -2 also ensures the result is divisible by 2. That last part matters because H.264 and H.265 both require even dimensions. Use -2 instead of -1 to avoid cryptic encoder errors like:

[libx264 @ 0x...] height not divisible by 2 (1280x719)

You can flip it around:

ffmpeg -i input.mp4 -vf "scale=-2:720" output.mp4

This locks the height at 720 and auto-calculates the width. Useful when your priority is vertical resolution (720p, 1080p) regardless of aspect ratio.

Scale by percentage:

ffmpeg -i input.mp4 -vf "scale=iw*0.5:ih*0.5" output.mp4

iw and ih are FFmpeg variables for input width and input height. This shrinks the video to 50% of its original size. Handy for generating preview thumbnails or reducing a 4K file for quick review.

Cap the size without upscaling:

ffmpeg -i input.mp4 -vf "scale='min(1920,iw)':'min(1080,ih)':force_original_aspect_ratio=decrease" output.mp4

This is the one I use most. It scales down videos larger than 1920x1080 but leaves smaller videos alone. No upscaling, no distortion. The force_original_aspect_ratio=decrease parameter ensures the output fits within 1920x1080 while keeping the original proportions.

Scale with pixel format conversion:

ffmpeg -i input.mp4 -vf "scale=1280:-2,format=yuv420p" output.mp4

Adding format=yuv420p after the scale filter ensures the output uses the most compatible pixel format. Some sources (screen recordings, ProRes footage) use yuv444p or yuv422p, which won't play in many browsers or on mobile devices. Chaining format=yuv420p after your scale avoids playback issues.

FFmpeg crop video: cut out what you don't need

Cropping removes pixels from the edges. The filter syntax is crop=width:height:x:y, where x and y are the top-left corner of the crop rectangle. When you omit x and y, FFmpeg centers the crop automatically.

Center crop to square (Instagram-style):

ffmpeg -i input.mp4 -vf "crop=ih:ih" output.mp4

This uses the input height as both dimensions, cutting equally from the left and right. Works for turning landscape footage into square posts.

Crop a specific region:

ffmpeg -i input.mp4 -vf "crop=640:480:100:50" output.mp4

Grabs a 640x480 rectangle starting 100 pixels from the left and 50 from the top.

Crop then scale (the combo you actually need):

ffmpeg -i input.mp4 -vf "crop=ih*16/9:ih,scale=1920:1080" output.mp4

First crops to 16:9 aspect ratio (useful if you have a wider source), then scales to 1920x1080. Filters chain left to right, separated by commas. The crop happens on the original pixels, and the scale operates on the cropped result.

Remove black bars automatically:

ffmpeg -i input.mp4 -vf "cropdetect" -f null -

Run this first. FFmpeg analyzes the video and prints crop parameters to the terminal. You'll see lines like:

[Parsed_cropdetect_0 @ 0x...] x1:0 x2:1919 y1:140 y2:939 w:1920 h:800 ...
crop=1920:800:0:140

Copy those values into your actual crop command:

ffmpeg -i input.mp4 -vf "crop=1920:800:0:140" output.mp4

One thing to watch: cropdetect analyzes frame by frame, and the detected crop area can fluctuate if the black bars aren't perfectly uniform (common with older DVD rips). Run it for a few seconds and pick the most consistent values from the output.

Pad and letterbox: add space instead of removing it

Sometimes you need to fit a video into a frame without cropping anything. Padding adds black bars (or any color) around the video.

Letterbox a 4:3 video into 16:9:

ffmpeg -i input.mp4 -vf "scale=1920:-2,pad=1920:1080:(ow-iw)/2:(oh-ih)/2:black" output.mp4

This scales the video to 1920 pixels wide (keeping aspect ratio), then pads it to exactly 1920x1080 with centered black bars. The expressions (ow-iw)/2 and (oh-ih)/2 center the video within the padded frame.

Pillarbox a vertical video into landscape:

ffmpeg -i vertical.mp4 -vf "scale=-2:1080,pad=1920:1080:(ow-iw)/2:0:black" output.mp4

Scales the height to 1080, then adds black bars on the left and right to fill a 1920x1080 frame. You see this on YouTube whenever someone uploads a phone recording.

You can change the bar color:

# White bars
ffmpeg -i input.mp4 -vf "scale=-2:1080,pad=1920:1080:(ow-iw)/2:(oh-ih)/2:white" output.mp4

# Blurred background (more complex, but looks professional)
ffmpeg -i input.mp4 -filter_complex \
  "[0:v]scale=1920:1080,boxblur=20:20[bg];[0:v]scale=-2:1080[fg];[bg][fg]overlay=(W-w)/2:(H-h)/2" \
  output.mp4

The blurred background approach scales the original video to fill the frame (blurry), then overlays the sharp version on top. TikTok compilations use this trick constantly.

Platform presets: copy-paste commands for social media

Every platform wants something different. Here are the commands I keep in a script file:

YouTube 1080p (16:9):

ffmpeg -i input.mp4 -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2" \
  -c:v libx264 -crf 18 -preset slow -c:a aac -b:a 192k -movflags +faststart output_yt.mp4

CRF 18 because YouTube re-encodes everything anyway. Give it the best source you can. The -movflags +faststart moves the moov atom to the beginning of the file, which means the video can start playing before the entire file downloads. The compression guide explains CRF tuning in more detail.

TikTok / Instagram Reels (9:16, 1080x1920):

ffmpeg -i input.mp4 -vf "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2" \
  -c:v libx264 -crf 20 -c:a aac -b:a 128k output_tiktok.mp4

If your source is landscape, this letterboxes it vertically. For a better result with landscape source footage, crop to the center first:

ffmpeg -i landscape.mp4 -vf "crop=ih*9/16:ih,scale=1080:1920" \
  -c:v libx264 -crf 20 -c:a aac output_tiktok.mp4

TikTok's upload limit is 10 minutes and 4GB as of early 2026. They re-encode aggressively on their end, so there's no benefit in going below CRF 18 or uploading at 4K. 1080x1920 at CRF 20 gives a good size-to-quality tradeoff for TikTok's re-encoding pipeline.

Instagram Square (1:1, 1080x1080):

ffmpeg -i input.mp4 -vf "crop=min(iw\,ih):min(iw\,ih),scale=1080:1080" \
  -c:v libx264 -crf 20 -c:a aac output_ig.mp4

Crops to a square from the center, then scales to 1080x1080.

Twitter/X (16:9, 1280x720):

ffmpeg -i input.mp4 -vf "scale=1280:720:force_original_aspect_ratio=decrease,pad=1280:720:(ow-iw)/2:(oh-ih)/2" \
  -c:v libx264 -crf 23 -c:a aac -b:a 128k output_twitter.mp4

Twitter compresses aggressively on their end. No point going above 720p.

LinkedIn (16:9, 1920x1080, max 10 min):

ffmpeg -i input.mp4 -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2" \
  -c:v libx264 -crf 22 -preset medium -c:a aac -b:a 128k -t 600 -movflags +faststart output_linkedin.mp4

LinkedIn caps video at 10 minutes, so -t 600 trims to that limit. If you need more precise trimming, combine with -ss for start-point control.

Scaling algorithms: when default isn't good enough

FFmpeg defaults to bilinear scaling. It's fast and fine for downscaling. For upscaling or when quality matters, you have options.

# Lanczos (sharpest, best for downscaling)
ffmpeg -i input.mp4 -vf "scale=1920:1080:flags=lanczos" output.mp4

# Bicubic (good balance, slight sharpening)
ffmpeg -i input.mp4 -vf "scale=1920:1080:flags=bicubic" output.mp4

# Bilinear (default, fastest)
ffmpeg -i input.mp4 -vf "scale=1920:1080:flags=bilinear" output.mp4

# Spline (smooth, good for upscaling)
ffmpeg -i input.mp4 -vf "scale=1920:1080:flags=spline" output.mp4

Here's the practical difference: lanczos preserves more fine detail when shrinking video. Text, edges, and textures stay sharper. Bilinear tends to soften everything slightly. For most content the difference is subtle, but it's visible on text-heavy screencasts or footage with fine patterns. Spline produces the smoothest interpolation when scaling up, which means fewer visible artifacts on upscaled footage, though it won't add real detail.

Use lanczos when downscaling (1080p to 720p, 4K to 1080p). Use spline when upscaling (720p to 1080p). Bilinear is fine for quick previews where sharpness doesn't matter.

The speed difference is negligible. Lanczos adds maybe 2-3% to encode time compared to bilinear. Not worth worrying about unless you're processing thousands of files. If encoding speed is your bottleneck, GPU acceleration with NVENC will make a bigger difference than any filter flag.

Rotate and flip: fix orientation problems

Phone videos sometimes have wrong rotation metadata. Or you need to flip footage for a mirror effect.

# Rotate 90 degrees clockwise
ffmpeg -i input.mp4 -vf "transpose=1" output.mp4

# Rotate 90 degrees counter-clockwise
ffmpeg -i input.mp4 -vf "transpose=2" output.mp4

# Rotate 180 degrees
ffmpeg -i input.mp4 -vf "transpose=1,transpose=1" output.mp4

# Flip horizontally (mirror)
ffmpeg -i input.mp4 -vf "hflip" output.mp4

# Flip vertically
ffmpeg -i input.mp4 -vf "vflip" output.mp4

The transpose values: 0 = 90° counter-clockwise + vertical flip, 1 = 90° clockwise, 2 = 90° counter-clockwise, 3 = 90° clockwise + vertical flip. I never remember these either, which is why I keep the cheat sheet open.

Fix metadata rotation without re-encoding:

ffmpeg -i input.mp4 -c copy -metadata:s:v rotate=0 output.mp4

Some players read the rotation metadata and apply it automatically. This strips the rotation flag without touching the video data. Use this when the video plays sideways in some apps but looks correct in others.

Combine rotation with resize:

ffmpeg -i portrait.mp4 -vf "transpose=1,scale=1920:1080" output.mp4

Rotates first, then scales. Order matters in the filter chain. If you're also adding a watermark, put the overlay filter last: transpose=1,scale=1920:1080,overlay=....

Batch resize: process an entire folder

Single file commands are fine until you have 200 files to resize. Here's a shell script that handles an entire directory:

#!/bin/bash
INPUT_DIR="./raw"
OUTPUT_DIR="./resized"
mkdir -p "$OUTPUT_DIR"

for f in "$INPUT_DIR"/*.mp4; do
  filename=$(basename "$f")
  ffmpeg -i "$f" -vf "scale=1280:-2:flags=lanczos" \
    -c:v libx264 -crf 23 -c:a aac -b:a 128k \
    "$OUTPUT_DIR/$filename" -y
done
echo "Done. Processed $(ls "$OUTPUT_DIR" | wc -l) files."

Multi-resolution batch (generate multiple sizes at once):

#!/bin/bash
for f in ./input/*.mp4; do
  name=$(basename "$f" .mp4)
  ffmpeg -i "$f" \
    -vf "scale=1920:-2:flags=lanczos" -c:v libx264 -crf 22 "./output/${name}_1080p.mp4" \
    -vf "scale=1280:-2:flags=lanczos" -c:v libx264 -crf 23 "./output/${name}_720p.mp4" \
    -vf "scale=854:-2:flags=lanczos" -c:v libx264 -crf 25 "./output/${name}_480p.mp4"
done

This generates 1080p, 720p, and 480p versions in one pass per file. Useful for creating multiple quality tiers for an adaptive video player.

Parallel processing with xargs:

find ./raw -name "*.mp4" | xargs -P 4 -I {} bash -c \
  'ffmpeg -i "{}" -vf "scale=1280:-2:flags=lanczos" -c:v libx264 -crf 23 "./resized/$(basename {})" -y'

The -P 4 flag runs 4 FFmpeg processes simultaneously. Adjust based on your CPU cores. On an 8-core machine, -P 4 is a safe bet that leaves headroom for the OS. Going higher risks thrashing.

For heavier workloads, the RenderIO API can process files in parallel across multiple machines without tying up yours. More on that below.

FFmpeg resize video via API

Running FFmpeg locally works until you're processing video in production. Then you deal with scaling workers, security patches, and the fact that a 4K resize can pin a CPU core for minutes. The hosted vs self-hosted tradeoffs break down the cost math at different volumes.

With RenderIO, you send the same FFmpeg command over HTTP:

curl -X POST https://renderio.dev/api/v1/run-ffmpeg-command \
  -H "Content-Type: application/json" \
  -H "X-API-KEY: ffsk_your_api_key" \
  -d '{
    "input_files": {
      "in_video": "https://example.com/source.mp4"
    },
    "output_files": {
      "out_video": "resized.mp4"
    },
    "ffmpeg_command": "ffmpeg -i {{in_video}} -vf \"scale=1280:-2:flags=lanczos\" -c:v libx264 -crf 23 -c:a aac {{out_video}}"
  }'

The API returns a command_id. Poll GET /api/v1/commands/:commandId until the status is SUCCESS, then grab the output URL from the response:

# Check status
curl https://renderio.dev/api/v1/commands/cmd_abc123 \
  -H "X-API-KEY: ffsk_your_api_key"

# Response when complete:
# {
#   "command_id": "cmd_abc123",
#   "status": "SUCCESS",
#   "output_files": {
#     "out_video": {
#       "storage_url": "https://media.renderio.dev/files/...",
#       "filename": "resized.mp4",
#       "size_mbytes": 1.24
#     }
#   }
# }

The FFmpeg syntax is identical to what you'd run locally. No new API to learn. The same crop, pad, and rotate commands from this guide all work, just wrapped in JSON. Get an API key and try it with one of the commands above. For language-specific examples, see the Python and Node.js API guides.

If you're building automation workflows, the n8n resize video guide and Zapier resize video for TikTok guide walk through connecting RenderIO to those platforms step by step.

Common pitfalls (and how to avoid them)

Odd dimensions crash the encoder. H.264 and H.265 require width and height divisible by 2. Some codecs need divisibility by 4 or even 16. Always use -2 instead of -1 in scale expressions, or add a safety-net filter:

-vf "scale=1280:-2,pad=ceil(iw/2)*2:ceil(ih/2)*2"

Upscaling doesn't add detail. Scaling a 480p video to 1080p doesn't improve quality. You're just interpolating between existing pixels. FFmpeg won't warn you about this. If you must upscale, use flags=spline and accept that the output will look softer than native 1080p. Check the source resolution first with ffprobe.

Aspect ratio distortion is silent. FFmpeg won't warn you when you stretch a 4:3 video into 16:9. It does exactly what you ask. Always use -2 for auto-calculation or force_original_aspect_ratio=decrease with pad to avoid squished output.

Filter order matters. In -vf "crop=640:480,scale=1280:720", the crop happens first on the original resolution, then the scale operates on the cropped 640x480 result. Swap them and you get a completely different output. Think of the filter chain as a pipeline, left to right.

Missing -c:v on resize means re-encoding. Any filter operation triggers a decode/re-encode cycle. You cannot use -c copy with scale, crop, or pad filters. If you're also trimming or compressing, chain everything into one command to avoid encoding the video twice.

CRF matters more after resize. Resizing changes the bitrate requirements. A video resized from 4K to 720p needs far fewer bits per frame. If you copy your CRF value from a 4K workflow, you might be overspending on file size. CRF 23 is a safe default for 1080p. Push to 25-28 for 720p web delivery. The compression guide goes deeper on tuning CRF per resolution.

Container format compatibility. After resizing, make sure your output container supports the codec you're using. MP4 with H.264 works everywhere. MKV is more flexible but won't play natively in browsers. The formats reference has a compatibility table for every major codec-container combination.

FAQ

How do I resize a video without losing quality?

You can't avoid some quality loss when resizing, because any scale or crop filter forces FFmpeg to decode and re-encode the video. The goal is to minimize it. Use flags=lanczos for the sharpest scaling, set CRF to 18 or lower for near-lossless quality, and use -preset slow to give the encoder more time to optimize. If you're only changing the container or metadata (not the pixel dimensions), you can use -c copy to avoid re-encoding entirely.

What's the difference between scale and crop in FFmpeg?

scale changes the dimensions of the entire frame. Every pixel gets resized. crop cuts a rectangle out of the frame and discards the rest. Use scale when you want to keep the full picture at a different size. Use crop when you want to remove unwanted edges or change the aspect ratio by trimming content.

Why does FFmpeg give me "width/height not divisible by 2"?

H.264 and H.265 encode video in macroblocks that require even pixel dimensions. If your scale expression produces an odd number (like 1281x719), the encoder throws this error. Fix it by using -2 instead of -1 in your scale filter: scale=1280:-2 instead of scale=1280:-1. The -2 rounds to the nearest even number automatically.

Can I resize video with FFmpeg without re-encoding?

No. Resizing requires decoding each frame, applying the scale filter, and re-encoding the result. There's no way around this because the pixel data itself changes. The only FFmpeg operations that avoid re-encoding are container changes, stream copying, and metadata edits. If encoding speed is a concern, consider hardware-accelerated encoding or offloading to an FFmpeg API.

How do I resize a batch of videos to the same resolution?

Use a bash for loop: for f in *.mp4; do ffmpeg -i "$f" -vf "scale=1280:-2" "resized_$f"; done. For parallel processing, pipe through xargs -P 4. For large-scale batch jobs (hundreds or thousands of files), the RenderIO API handles concurrency and storage so you don't have to manage worker processes.

What resolution should I use for TikTok, Instagram, or YouTube?

TikTok and Instagram Reels: 1080x1920 (9:16 vertical). Instagram feed square: 1080x1080. YouTube: 1920x1080 (16:9). Twitter/X: 1280x720. The platform presets section above has ready-to-copy commands for each one, including proper aspect ratio handling and codec settings.

Quick reference

Here's everything from this guide condensed:

# Resize to exact dimensions
ffmpeg -i in.mp4 -vf "scale=1280:720" out.mp4

# Resize with auto-height (keep aspect ratio)
ffmpeg -i in.mp4 -vf "scale=1280:-2" out.mp4

# Downscale only (no upscaling)
ffmpeg -i in.mp4 -vf "scale='min(1920,iw)':'min(1080,ih)':force_original_aspect_ratio=decrease" out.mp4

# Center crop to square
ffmpeg -i in.mp4 -vf "crop=ih:ih" out.mp4

# Letterbox into 16:9
ffmpeg -i in.mp4 -vf "scale=-2:1080,pad=1920:1080:(ow-iw)/2:(oh-ih)/2" out.mp4

# TikTok vertical from landscape
ffmpeg -i in.mp4 -vf "crop=ih*9/16:ih,scale=1080:1920" out.mp4

# Rotate 90° clockwise
ffmpeg -i in.mp4 -vf "transpose=1" out.mp4

# Batch resize folder
for f in *.mp4; do ffmpeg -i "$f" -vf "scale=1280:-2:flags=lanczos" -c:v libx264 -crf 23 "resized_$f"; done

Want the full list of common FFmpeg operations? The cheat sheet has 50 commands. Need to change codecs while resizing? The transcoding guide covers H.264, H.265, AV1, and VP9 conversions. Working with container formats? The formats reference explains which codecs fit inside which containers.

Batch Process AI Videos for Social Media Platforms

RenderIO — Tue, 14 Apr 2026 07:40:05 +0000

Why you can't upload the same video everywhere

You generated a great AI video. Now you need it on TikTok, Instagram Reels, YouTube Shorts, LinkedIn, and Twitter. Each platform wants different dimensions, aspect ratios, file sizes, and audio levels. If you're also looking to compress video with FFmpeg before uploading, that guide covers CRF values tuned per platform.

Manually exporting five versions in Premiere takes 15-20 minutes per video. If you're producing 10 videos per day, that's 3 hours of repetitive export work. Nobody should spend their day doing that.

FFmpeg handles all five conversions. RenderIO runs them in parallel so all five finish in the time it takes to process one.

Platform specifications for batch processing AI video

Here are the exact specs each platform expects (verified March 2026):

Platform	Resolution	Aspect Ratio	Max Duration	Max File Size	Audio
TikTok	1080x1920	9:16	10 min	287 MB	-14 LUFS
Instagram Reels	1080x1920	9:16	3 min	250 MB	-14 LUFS
YouTube Shorts	1080x1920	9:16	3 min	256 MB	-14 LUFS
LinkedIn	1920x1080	16:9	10 min	5 GB	-16 LUFS
Twitter/X	1280x720	16:9	2:20 min	512 MB	-16 LUFS

The differences look subtle but they matter. Wrong aspect ratio means black bars or cropped faces. Wrong audio levels mean your video sounds too loud or too quiet next to native content. And TikTok actually rejects files over 287 MB, not 300 MB like some guides claim.

Note on LinkedIn: it also accepts 9:16 vertical video now, but 16:9 still performs better in the feed because LinkedIn's desktop audience is larger than mobile. If your content is primarily mobile-targeted, you could skip the landscape conversion.

FFmpeg commands for each platform

Starting from a 1920x1080 AI-generated video.

TikTok (9:16, 1080x1920)

ffmpeg -i input.mp4 \
  -map_metadata -1 \
  -filter_complex "[0:v]scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920,boxblur=25[bg];[0:v]scale=1080:1920:force_original_aspect_ratio=decrease,noise=alls=16:allf=t[fg];[bg][fg]overlay=(W-w)/2:(H-h)/2[v]" \
  -map "[v]" -map 0:a? \
  -af "loudnorm=I=-14:TP=-2:LRA=7" \
  -c:v libx264 -crf 22 -c:a aac -b:a 128k \
  -movflags +faststart \
  tiktok.mp4

The boxblur background avoids ugly black bars. The blurred version of your video fills the frame behind the properly scaled foreground. The noise filter adds grain so it doesn't look sterile.

Instagram Reels (9:16, 1080x1920, 3 min max)

Reels technically allows up to 3 minutes, but the algorithm pushes shorter content harder. Keeping it under 90 seconds gives you better reach in Explore.

ffmpeg -i input.mp4 \
  -map_metadata -1 -t 90 \
  -filter_complex "[0:v]scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920,boxblur=25[bg];[0:v]scale=1080:1920:force_original_aspect_ratio=decrease[fg];[bg][fg]overlay=(W-w)/2:(H-h)/2[v]" \
  -map "[v]" -map 0:a? \
  -af "loudnorm=I=-14:TP=-2:LRA=7" \
  -c:v libx264 -crf 22 -c:a aac -b:a 128k \
  -movflags +faststart \
  reels.mp4

The -t 90 flag truncates at 90 seconds, which keeps you in the algorithm's sweet spot. If your video is under 90 seconds, it has no effect.

YouTube Shorts (9:16, 1080x1920, 3 min max)

YouTube extended Shorts to 3 minutes in October 2024. The command below trims to 60 seconds since shorter Shorts get more impressions, but you can bump -t 60 to -t 180 if your content needs the extra time.

ffmpeg -i input.mp4 \
  -map_metadata -1 -t 60 \
  -filter_complex "[0:v]scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920,boxblur=25[bg];[0:v]scale=1080:1920:force_original_aspect_ratio=decrease[fg];[bg][fg]overlay=(W-w)/2:(H-h)/2[v]" \
  -map "[v]" -map 0:a? \
  -af "loudnorm=I=-14:TP=-2:LRA=7" \
  -c:v libx264 -crf 20 -c:a aac -b:a 128k \
  -movflags +faststart \
  shorts.mp4

Lower CRF (20 vs 22) because YouTube re-encodes aggressively. Starting with higher quality gives a better result after YouTube's compression pass.

LinkedIn (16:9, 1920x1080)

ffmpeg -i input.mp4 \
  -map_metadata -1 \
  -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2:black" \
  -af "loudnorm=I=-16:TP=-2:LRA=11" \
  -c:v libx264 -crf 20 -c:a aac -b:a 192k \
  -movflags +faststart \
  linkedin.mp4

LinkedIn targets -16 LUFS (quieter than TikTok/Reels). Higher audio bitrate because LinkedIn's player doesn't re-encode as aggressively.

Twitter/X (16:9, 1280x720, 2:20 max)

ffmpeg -i input.mp4 \
  -map_metadata -1 -t 140 \
  -vf "scale=1280:720:force_original_aspect_ratio=decrease,pad=1280:720:(ow-iw)/2:(oh-ih)/2:black" \
  -af "loudnorm=I=-16:TP=-2:LRA=11" \
  -c:v libx264 -crf 23 -c:a aac -b:a 128k \
  -movflags +faststart \
  twitter.mp4

Twitter limits videos to 2 minutes 20 seconds (140 seconds). CRF 23 keeps file size down since Twitter's 512 MB limit is generous but their player favors smaller files for faster loading.

Batch all five with RenderIO API

Send five API calls in parallel. Each produces one platform version. For more on the API, see the complete FFmpeg API guide.

const INPUT_URL = "https://storage.example.com/ai-video.mp4";

const platforms = [
  {
    name: "tiktok",
    command: `-i {{in_video}} -map_metadata -1 -filter_complex "[0:v]scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920,boxblur=25[bg];[0:v]scale=1080:1920:force_original_aspect_ratio=decrease,noise=alls=16:allf=t[fg];[bg][fg]overlay=(W-w)/2:(H-h)/2[v]" -map "[v]" -map 0:a? -af "loudnorm=I=-14:TP=-2:LRA=7" -c:v libx264 -crf 22 -c:a aac -b:a 128k -movflags +faststart {{out_video}}`,
  },
  {
    name: "reels",
    command: `-i {{in_video}} -map_metadata -1 -t 90 -filter_complex "[0:v]scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920,boxblur=25[bg];[0:v]scale=1080:1920:force_original_aspect_ratio=decrease[fg];[bg][fg]overlay=(W-w)/2:(H-h)/2[v]" -map "[v]" -map 0:a? -af "loudnorm=I=-14:TP=-2:LRA=7" -c:v libx264 -crf 22 -c:a aac -b:a 128k -movflags +faststart {{out_video}}`,
  },
  {
    name: "shorts",
    command: `-i {{in_video}} -map_metadata -1 -t 60 -filter_complex "[0:v]scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920,boxblur=25[bg];[0:v]scale=1080:1920:force_original_aspect_ratio=decrease[fg];[bg][fg]overlay=(W-w)/2:(H-h)/2[v]" -map "[v]" -map 0:a? -af "loudnorm=I=-14:TP=-2:LRA=7" -c:v libx264 -crf 20 -c:a aac -b:a 128k -movflags +faststart {{out_video}}`,
  },
  {
    name: "linkedin",
    command: `-i {{in_video}} -map_metadata -1 -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2:black" -af "loudnorm=I=-16:TP=-2:LRA=11" -c:v libx264 -crf 20 -c:a aac -b:a 192k -movflags +faststart {{out_video}}`,
  },
  {
    name: "twitter",
    command: `-i {{in_video}} -map_metadata -1 -t 140 -vf "scale=1280:720:force_original_aspect_ratio=decrease,pad=1280:720:(ow-iw)/2:(oh-ih)/2:black" -af "loudnorm=I=-16:TP=-2:LRA=11" -c:v libx264 -crf 23 -c:a aac -b:a 128k -movflags +faststart {{out_video}}`,
  },
];

async function processForAllPlatforms(inputUrl) {
  const jobs = platforms.map(platform =>
    fetch("https://renderio.dev/api/v1/run-ffmpeg-command", {
      method: "POST",
      headers: {
        "X-API-KEY": process.env.RENDERIO_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        ffmpeg_command: platform.command,
        input_files: { in_video: inputUrl },
        output_files: { out_video: `${platform.name}.mp4` },
      }),
    }).then(r => r.json())
  );

  return Promise.all(jobs);
}

const results = await processForAllPlatforms(INPUT_URL);
// 5 jobs running in parallel on Cloudflare's edge

Five API calls. Five platform-optimized videos. All processing happens in parallel, so you wait for one, not five.

If you also need to generate speed variations — a 1.5x version for Stories previews or a 2x cut for YouTube Shorts teasers — you can add those as additional jobs in the same batch. The FFmpeg speed up video guide covers setpts and atempo with ready-to-use API examples.

Automate batch processing with n8n or Zapier

n8n workflow

Trigger: New file in Google Drive, S3, or webhook
Split: Fan out to 5 parallel branches
HTTP Request: Each branch calls RenderIO with platform-specific command
Wait: Poll for completion (or use webhook callback)
Upload: Send each output to the respective platform's upload API

Zapier workflow

Trigger: New file in Dropbox/Drive
Webhooks by Zapier: POST to RenderIO API (TikTok version)
Delay: Wait 30 seconds
Webhooks by Zapier: GET command status
Filter: Continue when status is "SUCCESS"
Repeat for each platform using Zapier paths

For detailed workflow setup, see the n8n video processing guide or the AI UGC video processing pipeline guide. Brands processing creator content should also check the UGC video processing guide for normalization and branding steps.

Choosing aspect ratio strategy

When converting 16:9 to 9:16, you have three options. The right choice depends on your content.

Crop from center works when the subject is centered (most AI talking-head videos). You lose the left and right edges but keep the subject sharp.

Blurred background preserves the full frame at a smaller size with a blurred version filling the background. Looks clean but the video appears smaller on screen.

Letterbox/pillarbox (black bars) is technically correct but looks terrible on mobile-first platforms. Avoid it for TikTok and Reels.

For landscape-to-portrait conversion specifically, the HeyGen to Reels guide covers cropping strategies for talking-head content.

Quality optimization tips

Don't over-compress for TikTok. TikTok re-encodes everything you upload. If you upload at CRF 28 (low quality), TikTok's re-encoding makes it look worse. Upload at CRF 20-22 and let TikTok's encoder work with better source material.

Use -movflags +faststart on every output. This moves the metadata to the beginning of the file, which means playback starts faster. Platforms and users both prefer it.

Match the frame rate. If your source is 24fps, don't upconvert to 30fps. It creates stuttery motion interpolation artifacts. Keep the original frame rate unless a platform specifically requires 30fps.

Test your audio. Play your output next to a popular native video on each platform. If yours sounds noticeably quieter or louder, your LUFS target is off. The -14 LUFS target for TikTok/Reels is a guideline — some creators target -12 for punchier audio.

Scaling to 10+ videos per day

At 10 videos per day, you're making 50 API calls daily (5 platforms x 10 videos). That's 1,500 per month.

Daily videos	Monthly API calls	Plan	Monthly cost
1-3	150-450	Starter	$9/mo
4-6	600-900	Growth	$29/mo
10-50	1,500-7,500	Business	$99/mo
100+	15,000+	Business + overage	$99/mo + usage

Each video processed on RenderIO costs about $0.005-$0.018 depending on your plan. Compare that to building and maintaining your own FFmpeg server, which runs $50-200/month in compute alone before engineering time. For a full cost comparison, see the FFmpeg API pricing comparison. You can also transcode video with FFmpeg locally for testing before scaling to the API.

Troubleshooting common issues

Black screen on TikTok upload. Usually means the video codec isn't H.264 or the pixel format isn't yuv420p. Add -pix_fmt yuv420p to your command.

Audio out of sync after conversion. Common with variable frame rate sources. Add -vsync cfr to force constant frame rate before other filters.

Instagram rejects the upload. Check file size (250 MB max for Reels) and duration (3 minutes max). Also confirm the video is at least 3 seconds long, since Reels rejects shorter clips.

FAQ

Can I batch process videos that aren't AI-generated?

Yes. The commands work with any MP4 input. Screen recordings, phone clips, webcam footage, anything. The pipeline doesn't care about the video source.

How long does batch processing take for one video?

About 15-45 seconds for all five platform versions to finish, depending on the video length. They process in parallel, so you're waiting for the slowest one, not all five sequentially.

What if a platform changes its specs?

Update the relevant command in your platforms array. The rest of the pipeline stays the same. We update this guide when platforms change their requirements.

Can I add a watermark or logo during batch processing?

Yes. Add an overlay filter to each command. For example: -i {{in_video}} -i {{in_logo}} -filter_complex "[1:v]scale=80:-1[logo];[0:v][logo]overlay=W-w-20:20[v]". The logo file is a second input in the API call.

What's the difference between this and using CapCut's batch export?

CapCut requires manual setup per video and runs on your machine. RenderIO processes via API, so it integrates into automated workflows (n8n, Zapier, custom scripts) and runs on Cloudflare's edge infrastructure. No local compute needed.

How to Make Duplicate TikTok Videos Unique at Scale

RenderIO — Tue, 14 Apr 2026 07:39:16 +0000

TikTok kills duplicate content

You post a video from Account A. It gets 100K views. You post the exact same video from Account B. It gets 200 views. TikTok's algorithm detected the duplicate and suppressed it.

This is the core problem for anyone running multiple TikTok accounts. Same content, multiple accounts, diminishing returns on each repost.

The solution isn't to create entirely new content for each account. It's to create variations that are technically unique while being visually identical to the viewer. These same techniques apply to product video variations and TikTok ad creatives where you need volume without manual editing.

How TikTok detects duplicates

TikTok uses multiple layers of detection (for the full technical breakdown of each layer, see how TikTok duplicate content detection works):

File hash comparison: The simplest check. Identical files have identical SHA-256 hashes. Any re-encoding defeats this.
Perceptual hashing: A visual fingerprint of the video content. Compares frame structure, color distribution, and motion patterns. More sophisticated than file hashing.
Audio fingerprinting: Analyzes the audio waveform to identify matching content. Similar to how Shazam identifies songs.
Metadata analysis: Checks creation timestamps, encoder software, and other metadata fields.

To get past all four layers, you need to modify the visual content, the audio, and the metadata. Here are 8 techniques.

Technique 1: Re-encode with different CRF

The simplest change. Different CRF values produce completely different files at the binary level.

# CRF 22 for Account A
ffmpeg -i input.mp4 -c:v libx264 -crf 22 -c:a aac output_a.mp4

# CRF 23 for Account B
ffmpeg -i input.mp4 -c:v libx264 -crf 23 -c:a aac output_b.mp4

This defeats file hash comparison but NOT perceptual hashing. The visual content is too similar.

API call:

curl -X POST https://renderio.dev/api/v1/run-ffmpeg-command \
  -H "Content-Type: application/json" \
  -H "X-API-KEY: your_api_key" \
  -d '{
    "ffmpeg_command": "-i {{in_video}} -c:v libx264 -crf 22 -c:a aac {{out_video}}",
    "input_files": { "in_video": "https://example.com/source.mp4" },
    "output_files": { "out_video": "variation_a.mp4" }
  }'

Technique 2: Micro-crop

Remove 2-8 pixels from each edge. Invisible to the viewer. Changes every frame's content.

ffmpeg -i input.mp4 -vf "crop=iw-4:ih-4:2:2" -c:v libx264 -crf 23 output.mp4

This removes 2 pixels from each side. The video is 4 pixels narrower and shorter. Unnoticeable on a phone screen. But every pixel coordinate shifts, defeating perceptual hashing.

Technique 3: Brightness/color shift

Shift brightness by 1-2%. Invisible to the eye. Changes pixel values across every frame.

ffmpeg -i input.mp4 -vf "eq=brightness=0.01:saturation=1.02" -c:v libx264 -crf 23 output.mp4

brightness=0.01 is a 1% increase. saturation=1.02 is a 2% saturation boost. Both are below the threshold of human perception.

Technique 4: Audio pitch shift

Shift the audio pitch by 0.5-1%. Inaudible. Defeats audio fingerprinting.

ffmpeg -i input.mp4 -af "asetrate=44100*1.005,aresample=44100" -c:v copy output.mp4

asetrate=44100*1.005 increases pitch by 0.5%. aresample=44100 resamples back to standard rate so the speed doesn't change.

Technique 5: Add subtle noise

Random noise changes every frame's pixel values. Even 3-5 units of noise is invisible but computationally significant.

ffmpeg -i input.mp4 -vf "noise=alls=5:allf=t" -c:v libx264 -crf 23 output.mp4

alls=5 adds noise with strength 5 to all planes. allf=t uses temporal noise (varies per frame).

Technique 6: Strip all metadata

Remove encoder info, timestamps, GPS data, and software tags.

ffmpeg -i input.mp4 -map_metadata -1 -c:v copy -c:a copy output.mp4

This alone doesn't defeat content-based detection, but it removes any tool-specific fingerprints.

Technique 7: Speed micro-adjustment

Change playback speed by 1-2%. Barely perceptible. Changes timing of every frame.

ffmpeg -i input.mp4 -filter_complex "[0:v]setpts=0.98*PTS[v];[0:a]atempo=1.02[a]" -map "[v]" -map "[a]" output.mp4

2% speed increase. A 60-second video becomes 58.8 seconds. The frame timestamps all shift.

Technique 8: Hue rotation

Shift the color hue by 2-3 degrees. Invisible to casual viewing. Changes color data across every frame.

ffmpeg -i input.mp4 -vf "hue=h=2" -c:v libx264 -crf 23 output.mp4

The combined approach

No single technique is enough for aggressive duplicate detection. Combine multiple techniques:

ffmpeg -i input.mp4 \
  -vf "crop=iw-4:ih-4:2:2,eq=brightness=0.01:saturation=1.02,noise=alls=5:allf=t,hue=h=2" \
  -af "asetrate=44100*1.005,aresample=44100" \
  -c:v libx264 -crf 23 \
  -map_metadata -1 \
  output.mp4

This applies crop + brightness + noise + hue shift to video, pitch shift to audio, and strips metadata. The result is indistinguishable from the original to a human viewer but completely unique to any detection algorithm.

Batch processing with the API

For multi-account posting, you need N variations of each video. Here's how to generate them:



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

source_video = "https://example.com/source.mp4"
num_accounts = 10

for i in range(num_accounts):
    crop = 2 + (i * 2)        # 2, 4, 6, 8, ... pixels
    brightness = 0.005 * (i - 5)  # -0.025 to +0.02
    pitch = 1.0 + (i * 0.002 - 0.01)  # 0.99 to 1.008
    crf = 21 + (i % 5)        # 21-25
    noise = 3 + (i % 4)       # 3-6
    hue = (i * 2) - 10        # -10 to +8 degrees

    command = (
        f'-i {{in_video}} '
        f'-vf "crop=iw-{crop}:ih-{crop}:{crop//2}:{crop//2},'
        f'eq=brightness={brightness:.3f}:saturation=1.01,'
        f'noise=alls={noise}:allf=t,'
        f'hue=h={hue}" '
        f'-af "asetrate=44100*{pitch:.4f},aresample=44100" '
        f'-c:v libx264 -crf {crf} -map_metadata -1 '
        f'{{out_video}}'
    )

    response = requests.post(f"{BASE_URL}/run-ffmpeg-command", headers=HEADERS, json={
        "ffmpeg_command": command,
        "input_files": {"in_video": source_video},
        "output_files": {"out_video": f"account_{i+1}.mp4"}
    })

    print(f"Account {i+1}: {response.json()['command_id']}")

10 API calls. 10 unique variations. Each one different enough to pass duplicate detection but visually identical to viewers.

Which techniques matter most

Ranked by impact on duplicate detection:

Micro-crop (changes frame content) - highest impact on perceptual hash
Audio pitch shift (defeats audio fingerprint) - critical for music/voice content
Re-encode with different CRF (changes file hash) - baseline requirement
Brightness/color shift (changes pixel values) - moderate impact
Noise (randomizes pixel data) - moderate impact
Metadata strip (removes tool fingerprints) - low but essential
Speed adjustment (changes timing) - moderate but noticeable if too aggressive
Hue shift (changes color space) - low to moderate impact

At minimum, use techniques 1, 2, 3, and 6 together. That covers file hash, perceptual hash, audio fingerprint, and metadata.

Automate with n8n or scripts

For daily operations, wire this into an n8n workflow or a cron job. Source video goes in, N unique variations come out. Post each to a different account. For the full multi-account workflow with parameter tables and staggered uploads, see avoid TikTok duplicate detection at scale.

The Starter plan at $9/mo includes 500 commands, enough to test batch variation generation with your real content. Scale to Growth ($29/mo) for production volume.

Extract Audio from Video in n8n

RenderIO — Sun, 12 Apr 2026 07:46:07 +0000

Pull audio from video without touching a terminal

You have video interviews to transcribe. Or podcast episodes recorded as video. Or a music library trapped in MP4 files. You need the audio track extracted.

FFmpeg does this in one command. n8n can trigger that command automatically whenever a new video appears. No manual steps. No terminal. No server.

The problem: n8n can't extract audio natively

n8n doesn't have an audio extraction node. The cloud version doesn't allow shell commands. Even self-hosted, running FFmpeg inside n8n blocks the worker and risks crashes on large files.

The solution: send the extraction command to RenderIO's API via n8n's HTTP Request node. RenderIO runs FFmpeg in an isolated container. Your n8n instance stays responsive.

Use the RenderIO n8n node

RenderIO has a partner-verified community node on the n8n marketplace. Install from Settings → Community Nodes → search "renderio". It provides a visual interface for FFmpeg commands, including audio extraction.

The node handles authentication and request formatting automatically. The extraction examples below use HTTP Request nodes for full flexibility, but the same FFmpeg commands work with the native node.

Basic extraction: MP4 to MP3

The simplest workflow: video URL in, MP3 URL out.

HTTP Request node configuration:

Method: POST
URL: https://renderio.dev/api/v1/run-ffmpeg-command
Authentication: Header Auth (X-API-KEY)
Body:

{
  "ffmpeg_command": "-i {{in_video}} -vn -acodec libmp3lame -q:a 2 {{out_audio}}",
  "input_files": {
    "in_video": "{{ $json.videoUrl }}"
  },
  "output_files": {
    "out_audio": "extracted.mp3"
  }
}

-vn disables video. -q:a 2 sets MP3 quality (0=best, 9=worst, 2 is high quality at ~190kbps).

Poll for completion, then use the output URL.

Extraction formats

MP3 (most compatible)

{
  "ffmpeg_command": "-i {{in_video}} -vn -acodec libmp3lame -q:a 2 {{out_audio}}",
  "input_files": { "in_video": "{{ $json.videoUrl }}" },
  "output_files": { "out_audio": "audio.mp3" }
}

Best for: sharing, podcast distribution, general use.

WAV (lossless)

{
  "ffmpeg_command": "-i {{in_video}} -vn -acodec pcm_s16le -ar 44100 {{out_audio}}",
  "input_files": { "in_video": "{{ $json.videoUrl }}" },
  "output_files": { "out_audio": "audio.wav" }
}

Best for: transcription services (they often prefer WAV), audio editing, archival.

AAC (Apple/streaming)

{
  "ffmpeg_command": "-i {{in_video}} -vn -acodec aac -b:a 192k {{out_audio}}",
  "input_files": { "in_video": "{{ $json.videoUrl }}" },
  "output_files": { "out_audio": "audio.m4a" }
}

Best for: Apple devices, streaming platforms, smaller files than MP3 at same quality.

FLAC (lossless compressed)

{
  "ffmpeg_command": "-i {{in_video}} -vn -acodec flac {{out_audio}}",
  "input_files": { "in_video": "{{ $json.videoUrl }}" },
  "output_files": { "out_audio": "audio.flac" }
}

Best for: archival when you want lossless but smaller than WAV (typically 50-60% of WAV size).

OGG/Opus (web)

{
  "ffmpeg_command": "-i {{in_video}} -vn -acodec libopus -b:a 128k {{out_audio}}",
  "input_files": { "in_video": "{{ $json.videoUrl }}" },
  "output_files": { "out_audio": "audio.ogg" }
}

Best for: web applications, voice recordings, VoIP.

Complete workflow: Extract and transcribe

Combine audio extraction with a transcription service:

Google Drive Trigger (new video)
  → HTTP Request: Extract audio (RenderIO)
  → Wait + Poll
  → HTTP Request: Download audio
  → HTTP Request: Send to Whisper API / AssemblyAI / Deepgram
  → Google Sheets: Write transcript
  → Slack: Notify team

Node 1: Google Drive Trigger
Watches a "Videos" folder for new uploads.

Node 2: Extract audio (HTTP Request)

{
  "ffmpeg_command": "-i {{in_video}} -vn -acodec pcm_s16le -ar 16000 -ac 1 {{out_audio}}",
  "input_files": { "in_video": "{{ $json.downloadUrl }}" },
  "output_files": { "out_audio": "for_transcription.wav" }
}

Note: -ar 16000 -ac 1 converts to 16kHz mono. This is the format most transcription APIs prefer. Smaller files, faster uploads, same transcription quality.

Node 3-5: Poll and get result

Standard polling loop.

Node 6: Send to transcription

{
  "method": "POST",
  "url": "https://api.openai.com/v1/audio/transcriptions",
  "headers": { "Authorization": "Bearer {{ $credentials.openAiApi.apiKey }}" },
  "body": {
    "model": "whisper-1",
    "file": "{{ $json.output_files.out_audio.storage_url }}"
  }
}

Batch extraction from a video library

Process an entire folder of videos:

Step 1: Get video list

Use a Code node or fetch from a spreadsheet:

const videos = [
  { url: "https://example.com/interview1.mp4", name: "interview1" },
  { url: "https://example.com/interview2.mp4", name: "interview2" },
  { url: "https://example.com/interview3.mp4", name: "interview3" },
];

return videos.map(v => ({ json: v }));

Step 2: Split in Batches (size: 5)

Step 3: Submit extraction for each

{
  "ffmpeg_command": "-i {{in_video}} -vn -acodec libmp3lame -q:a 2 {{out_audio}}",
  "input_files": { "in_video": "{{ $json.url }}" },
  "output_files": { "out_audio": "{{ $json.name }}.mp3" }
}

Step 4: Poll and collect URLs

Step 5: Write results to spreadsheet

Video	Audio URL	Status
interview1	https://media.renderio.dev/interview1.mp3	extracted
interview2	https://media.renderio.dev/interview2.mp3	extracted

Audio processing after extraction

Once you have the audio, you can process it further:

Normalize volume:

-i {{in_audio}} -af loudnorm=I=-16:TP=-1.5:LRA=11 {{out_audio}}

Trim silence from start/end:

-i {{in_audio}} -af silenceremove=start_periods=1:start_silence=0.5:start_threshold=-50dB,areverse,silenceremove=start_periods=1:start_silence=0.5:start_threshold=-50dB,areverse {{out_audio}}

Convert sample rate:

-i {{in_audio}} -ar 44100 {{out_audio}}

Chain these into your workflow as additional processing steps after extraction.

Error handling

Common extraction failures:

No audio track: Some screen recordings or animations have no audio. FFmpeg returns an error. Handle with an IF node that checks the error message for "does not contain any stream."

Corrupted audio: Add -err_detect ignore_err before -i to attempt extraction despite minor corruption.

Very long videos: Extraction is fast (typically 10-30 seconds regardless of video length) because it only copies/transcodes the audio stream, not the video.

Get started

The Starter plan at $9/mo includes 500 commands -- enough to set up and test your audio extraction workflow.

FFmpeg API with Node.js: Video Processing in 10 Lines

RenderIO — Thu, 09 Apr 2026 06:32:13 +0000

Video processing shouldn't require child_process

The typical Node.js approach to FFmpeg is child_process.spawn(). You shell out to a binary, parse stderr for progress, handle exit codes, and hope the binary exists on your deployment target.

// The old way
const { spawn } = require("child_process");
const ffmpeg = spawn("ffmpeg", ["-i", "input.mp4", "-c:v", "libx264", "output.mp4"]);
ffmpeg.stderr.on("data", (data) => console.log(data.toString()));
ffmpeg.on("close", (code) => console.log(`Exited with code ${code}`));

This works locally. It breaks in production when the FFmpeg binary isn't installed, isn't the right version, or doesn't support the codec you need. If you've compared self-hosted vs cloud FFmpeg, you know the tradeoffs.

Here's the alternative: fetch(). Ten lines, no binary dependency.

const response = await fetch("https://renderio.dev/api/v1/run-ffmpeg-command", {
  method: "POST",
  headers: { "Content-Type": "application/json", "X-API-KEY": "ffsk_your_key" },
  body: JSON.stringify({
    ffmpeg_command: "-i {input} -c:v libx264 -crf 22 -c:a aac {output}",
    input_files: { input: "https://example.com/video.mov" },
    output_files: { output: "converted.mp4" },
  }),
});
const { command_id } = await response.json();

It works everywhere Node.js runs — no binary to bundle, no codec compatibility issues.

Setup

Zero dependencies required. Node.js 18+ has built-in fetch. For older versions, use node-fetch.

const API_KEY = "ffsk_your_api_key";
const BASE_URL = "https://renderio.dev/api/v1";

async function runFFmpeg(command, inputFiles, outputFiles) {
  // Submit the command
  const submitRes = await fetch(`${BASE_URL}/run-ffmpeg-command`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-API-KEY": API_KEY,
    },
    body: JSON.stringify({
      ffmpeg_command: command,
      input_files: inputFiles,
      output_files: outputFiles,
    }),
  });

  if (!submitRes.ok) {
    const error = await submitRes.json();
    throw new Error(`Submit failed: ${JSON.stringify(error)}`);
  }

  const { command_id } = await submitRes.json();

  // Poll for result
  while (true) {
    const statusRes = await fetch(`${BASE_URL}/commands/${command_id}`, {
      headers: { "X-API-KEY": API_KEY },
    });
    const status = await statusRes.json();

    if (status.status === "SUCCESS") return status.output_files;
    if (status.status === "FAILED") throw new Error(`FFmpeg failed: ${status.error}`);

    await new Promise((r) => setTimeout(r, 2000));
  }
}

Every example below uses this runFFmpeg function.

Convert formats

MOV to MP4:

const result = await runFFmpeg(
  "-i {input} -c:v libx264 -preset fast -crf 22 -c:a aac -b:a 128k {output}",
  { input: "https://example.com/video.mov" },
  { output: "converted.mp4" }
);
console.log(`Download: ${result.output}`);

MP4 to WebM:

const result = await runFFmpeg(
  "-i {input} -c:v libvpx-vp9 -crf 30 -b:v 0 -c:a libopus {output}",
  { input: "https://example.com/video.mp4" },
  { output: "web.webm" }
);

Resize for social platforms

TikTok (1080x1920):

const result = await runFFmpeg(
  '-i {input} -vf "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2:black" -c:v libx264 -crf 23 -c:a aac {output}',
  { input: "https://example.com/video.mp4" },
  { output: "tiktok.mp4" }
);

YouTube Shorts (1080x1920, same dimensions):

const result = await runFFmpeg(
  '-i {input} -vf "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2" -c:v libx264 -crf 23 -c:a aac {output}',
  { input: "https://example.com/video.mp4" },
  { output: "shorts.mp4" }
);

720p for general web use:

const result = await runFFmpeg(
  "-i {input} -vf scale=-2:720 -c:v libx264 -crf 23 -c:a copy {output}",
  { input: "https://example.com/4k-video.mp4" },
  { output: "720p.mp4" }
);

Extract audio

To MP3:

const result = await runFFmpeg(
  "-i {input} -vn -acodec libmp3lame -q:a 2 {output}",
  { input: "https://example.com/video.mp4" },
  { output: "audio.mp3" }
);

Generate thumbnails

For advanced frame extraction — keyframes, scene detection, and batch processing — see the FFmpeg frame extraction guide.

Single frame at 5 seconds:

const result = await runFFmpeg(
  "-i {input} -ss 00:00:05 -vframes 1 -q:v 2 {output}",
  { input: "https://example.com/video.mp4" },
  { output: "thumb.jpg" }
);

Trim video

For keyframe-accurate trimming, batch operations, and the trim filter, see the dedicated trim guide.

30 seconds starting at 1:00:

const result = await runFFmpeg(
  "-i {input} -ss 00:01:00 -t 00:00:30 -c copy {output}",
  { input: "https://example.com/long-video.mp4" },
  { output: "clip.mp4" }
);

Add watermark

const result = await runFFmpeg(
  '-i {video} -i {logo} -filter_complex "overlay=W-w-10:H-h-10" {output}',
  {
    video: "https://example.com/video.mp4",
    logo: "https://example.com/watermark.png",
  },
  { output: "watermarked.mp4" }
);

This is a basic fixed-position overlay. For responsive scaling with scale2ref, semi-transparent logos, text overlays, and moving watermarks, the FFmpeg watermark guide covers it all.

Using webhooks instead of polling

Polling works for scripts and CLIs. For web applications, webhooks are better. Configure a webhook URL in your RenderIO dashboard, then submit without polling:

// Express.js webhook endpoint

const app = express();
app.use(express.json());

// Submit a job (fire and forget)
async function submitJob(inputUrl) {
  const res = await fetch(`${BASE_URL}/run-ffmpeg-command`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-API-KEY": API_KEY,
    },
    body: JSON.stringify({
      ffmpeg_command: "-i {input} -c:v libx264 -crf 22 {output}",
      input_files: { input: inputUrl },
      output_files: { output: "result.mp4" },
    }),
  });
  const { command_id } = await res.json();
  // Store command_id in your database, associated with the user/job
  return command_id;
}

// Receive webhook when processing completes
app.post("/webhooks/renderio", (req, res) => {
  const { command_id, status, output_files } = req.body;

  if (status === "SUCCESS") {
    // Update your database, notify the user, etc.
    console.log(`Job ${command_id} done: ${output_files.output}`);
  } else if (status === "FAILED") {
    console.error(`Job ${command_id} failed: ${req.body.error}`);
  }

  res.sendStatus(200);
});

Your server just reacts to events instead of burning cycles polling. For a full walkthrough of the submit-poll-download flow, see the REST API tutorial.

Batch processing

Process multiple videos concurrently with Promise.all:

const videos = [
  { url: "https://example.com/v1.mp4", name: "out1.mp4" },
  { url: "https://example.com/v2.mp4", name: "out2.mp4" },
  { url: "https://example.com/v3.mp4", name: "out3.mp4" },
];

const results = await Promise.allSettled(
  videos.map((v) =>
    runFFmpeg(
      "-i {input} -c:v libx264 -crf 23 -c:a aac {output}",
      { input: v.url },
      { output: v.name }
    )
  )
);

results.forEach((result, i) => {
  if (result.status === "fulfilled") {
    console.log(`${videos[i].name}: ${result.value.output}`);
  } else {
    console.error(`${videos[i].name}: ${result.reason.message}`);
  }
});

Promise.allSettled ensures one failure doesn't cancel the rest. Each video processes in its own container. If you're doing this at scale for social media, the batch video processing guide covers the full pipeline.

Express.js integration

A complete Express endpoint that accepts video uploads and returns processed versions:



const app = express();
app.use(express.json());

app.post("/process-video", async (req, res) => {
  const { videoUrl, operation } = req.body;

  const commands = {
    compress: "-i {input} -c:v libx264 -crf 28 -preset fast -c:a aac -b:a 96k {output}",
    thumbnail: "-i {input} -ss 00:00:03 -vframes 1 -q:v 2 {output}",
    audio: "-i {input} -vn -acodec libmp3lame -q:a 4 {output}",
    resize720: "-i {input} -vf scale=-2:720 -c:v libx264 -crf 23 {output}",
  };

  const command = commands[operation];
  if (!command) return res.status(400).json({ error: "Unknown operation" });

  const ext = operation === "thumbnail" ? "jpg" : operation === "audio" ? "mp3" : "mp4";

  try {
    const result = await runFFmpeg(
      command,
      { input: videoUrl },
      { output: `processed.${ext}` }
    );
    res.json({ url: result.output });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

Four operations behind a single endpoint — compress, thumbnail, extract audio, resize. You could add more by extending the commands object.

TypeScript types

If you're using TypeScript, here are the types for the API responses:

interface FFmpegSubmitResponse {
  command_id: string;
  status: "processing" | "queued";
}

interface FFmpegStatusResponse {
  command_id: string;
  status: "processing" | "completed" | "failed";
  output_files?: Record<string, string>;
  error?: string;
}

async function runFFmpeg(
  command: string,
  inputFiles: Record<string, string>,
  outputFiles: Record<string, string>
): Promise<Record<string, string>> {
  const submitRes = await fetch(`${BASE_URL}/run-ffmpeg-command`, {
    method: "POST",
    headers: { "Content-Type": "application/json", "X-API-KEY": API_KEY },
    body: JSON.stringify({
      ffmpeg_command: command,
      input_files: inputFiles,
      output_files: outputFiles,
    }),
  });

  if (!submitRes.ok) throw new Error(`Submit failed: ${submitRes.status}`);

  const { command_id } = (await submitRes.json()) as FFmpegSubmitResponse;

  while (true) {
    const statusRes = await fetch(`${BASE_URL}/commands/${command_id}`, {
      headers: { "X-API-KEY": API_KEY },
    });
    const status = (await statusRes.json()) as FFmpegStatusResponse;

    if (status.status === "SUCCESS") return status.output_files!;
    if (status.status === "FAILED") throw new Error(status.error ?? "Unknown");

    await new Promise((r) => setTimeout(r, 2000));
  }
}

FAQ

Does this work with Bun or Deno?

Yes. Both Bun and Deno support fetch natively, so the code works without changes. The only thing to adjust is how you load environment variables for the API key.

Can I use this with Next.js API routes?

Absolutely. The runFFmpeg function works in any server-side Node.js context. In Next.js, call it from an API route or a Server Action — just don't call it from client-side code since that would expose your API key.

How do I handle large files that take minutes to process?

Use webhooks instead of polling. Submit the job, store the command_id in your database, and let RenderIO POST the result to your webhook endpoint when it's done. The webhook section above shows the Express setup.

What's the maximum concurrent requests?

It depends on your plan. The API processes each job in an isolated container, so there's no shared resource bottleneck. For heavy batch workloads, you might want to limit your Promise.all concurrency to avoid hitting rate limits.

Can I use this with the Node.js FFmpeg cheat sheet commands?

Yes — every command from the FFmpeg cheat sheet works. Replace local file paths with URL placeholders ({input}, {output}) and pass them through runFFmpeg.

Get started

For a quick reference of common FFmpeg commands you can use with this setup, check the curl examples. The same commands work in both curl and Node.js.

The Starter plan at $9/mo includes 500 commands. Get your API key to start building.

Extract Audio from Video in Zapier

RenderIO — Wed, 08 Apr 2026 06:13:49 +0000

Video in. Audio out. Automatically.

You record a video interview. You need the audio as an MP3 for your podcast feed. You film a webinar. You need the audio for transcription. You get UGC video. You need to check the audio quality without downloading the whole file.

Each of these requires extracting audio from video. It's a 30-second FFmpeg operation that Zapier can't do natively.

With RenderIO, it becomes an automated step in any Zap. Video goes in, MP3 comes out.

The basic Zap

Step 1: Trigger

App: Google Drive
Event: New File in Folder
Folder: "Videos for Audio Extraction"

Alternative triggers:

Dropbox: New file
Email: New attachment
Webhook: Custom trigger
Typeform: New file upload

Step 2: Extract audio

App: Webhooks by Zapier
Event: POST
URL: https://renderio.dev/api/v1/run-ffmpeg-command

Headers:

X-API-KEY: your_api_key
Content-Type: application/json

Body:

{
  "ffmpeg_command": "-i {{in_video}} -vn -c:a libmp3lame -b:a 192k {{out_audio}}",
  "input_files": {
    "in_video": "{{step1_file_url}}"
  },
  "output_files": {
    "out_audio": "extracted-audio.mp3"
  }
}

The flags:

-vn: No video (strip the video stream entirely)
-c:a libmp3lame: Encode audio as MP3
-b:a 192k: 192 kbps bitrate (good quality for speech)

Step 3: Wait

App: Delay by Zapier
Duration: 20 seconds

Audio extraction is fast because FFmpeg doesn't need to decode/encode video. Even a 30-minute video extracts in under 10 seconds.

Step 4: Check status

App: Webhooks by Zapier
Event: GET
URL: https://renderio.dev/api/v1/commands/{{step2_command_id}}
Headers: X-API-KEY: your_api_key

Step 5: Save the MP3

App: Google Drive
Event: Upload File
File URL: {{step4_output_url}}
Folder: "Extracted Audio"
Filename: {{step1_filename}}.mp3

Audio format options

MP3 (most compatible)

{
  "ffmpeg_command": "-i {{in_video}} -vn -c:a libmp3lame -b:a 192k {{out_audio}}",
  "input_files": { "in_video": "{{file_url}}" },
  "output_files": { "out_audio": "audio.mp3" }
}

Best for: Podcast distribution, general sharing, email attachments.

WAV (lossless)

{
  "ffmpeg_command": "-i {{in_video}} -vn -c:a pcm_s16le {{out_audio}}",
  "input_files": { "in_video": "{{file_url}}" },
  "output_files": { "out_audio": "audio.wav" }
}

Best for: Audio editing, music production, when you need maximum quality.

AAC (smaller than MP3)

{
  "ffmpeg_command": "-i {{in_video}} -vn -c:a aac -b:a 128k {{out_audio}}",
  "input_files": { "in_video": "{{file_url}}" },
  "output_files": { "out_audio": "audio.m4a" }
}

Best for: Apple ecosystem, when file size matters.

FLAC (lossless, compressed)

{
  "ffmpeg_command": "-i {{in_video}} -vn -c:a flac {{out_audio}}",
  "input_files": { "in_video": "{{file_url}}" },
  "output_files": { "out_audio": "audio.flac" }
}

Best for: Archival, when you want lossless but smaller than WAV.

Audio processing options

Normalize volume

Ensure consistent loudness across extracted audio:

{
  "ffmpeg_command": "-i {{in_video}} -vn -af \"loudnorm=I=-16:TP=-2:LRA=11\" -c:a libmp3lame -b:a 192k {{out_audio}}",
  "input_files": { "in_video": "{{file_url}}" },
  "output_files": { "out_audio": "normalized.mp3" }
}

-16 LUFS is the podcast standard. This ensures your extracted audio plays at a consistent level regardless of the original recording volume.

Remove background noise

Basic noise reduction with FFmpeg:

{
  "ffmpeg_command": "-i {{in_video}} -vn -af \"highpass=f=80,lowpass=f=12000,afftdn=nf=-20\" -c:a libmp3lame -b:a 192k {{out_audio}}",
  "input_files": { "in_video": "{{file_url}}" },
  "output_files": { "out_audio": "clean.mp3" }
}

This applies:

High-pass filter at 80Hz (removes low rumble)
Low-pass filter at 12kHz (removes high-frequency hiss)
FFT-based noise reduction (reduces ambient noise)

Extract specific time range

Extract audio from a specific portion of the video:

{
  "ffmpeg_command": "-i {{in_video}} -ss 00:02:30 -t 00:10:00 -vn -c:a libmp3lame -b:a 192k {{out_audio}}",
  "input_files": { "in_video": "{{file_url}}" },
  "output_files": { "out_audio": "segment.mp3" }
}

-ss 00:02:30 starts at 2 minutes 30 seconds. -t 00:10:00 extracts 10 minutes.

Split into chapters

Extract multiple segments from one video:

First segment:

{
  "ffmpeg_command": "-i {{in_video}} -ss 0 -t 600 -vn -c:a libmp3lame -b:a 192k {{out_audio}}",
  "input_files": { "in_video": "{{file_url}}" },
  "output_files": { "out_audio": "chapter-1.mp3" }
}

Second segment:

{
  "ffmpeg_command": "-i {{in_video}} -ss 600 -t 600 -vn -c:a libmp3lame -b:a 192k {{out_audio}}",
  "input_files": { "in_video": "{{file_url}}" },
  "output_files": { "out_audio": "chapter-2.mp3" }
}

Use multiple Webhooks steps or a loop in Zapier to create all chapters.

Use case: Podcast repurposing

A common workflow for video podcasters:

Trigger: New video uploaded to Google Drive (after recording)
Extract full audio: MP3, 192kbps, normalized
Extract first 60 seconds: MP3, for social media teaser
Save full audio: Upload to podcast hosting (Buzzsprout, Anchor)
Save teaser: Upload to social media scheduler

{
  "ffmpeg_command": "-i {{in_video}} -vn -af \"loudnorm=I=-16:TP=-2:LRA=11\" -c:a libmp3lame -b:a 192k {{out_audio}}",
  "input_files": { "in_video": "{{file_url}}" },
  "output_files": { "out_audio": "full-episode.mp3" }
}

Teaser:

{
  "ffmpeg_command": "-i {{in_video}} -t 60 -vn -af \"loudnorm=I=-16:TP=-2:LRA=11,afade=t=out:st=55:d=5\" -c:a libmp3lame -b:a 192k {{out_audio}}",
  "input_files": { "in_video": "{{file_url}}" },
  "output_files": { "out_audio": "teaser.mp3" }
}

The teaser includes a 5-second fade-out at the 55-second mark.

Use case: Transcription prep

Before sending audio to a transcription service (Otter, Rev, Whisper):

{
  "ffmpeg_command": "-i {{in_video}} -vn -af \"highpass=f=80,lowpass=f=8000,loudnorm=I=-16\" -ar 16000 -ac 1 -c:a libmp3lame -b:a 64k {{out_audio}}",
  "input_files": { "in_video": "{{file_url}}" },
  "output_files": { "out_audio": "for-transcription.mp3" }
}

This optimizes for transcription:

Filters out non-speech frequencies (80Hz-8kHz)
Normalizes volume
Downsamples to 16kHz (sufficient for speech)
Mono channel (speech doesn't need stereo)
64kbps (small file size for upload)

The resulting file is 80-90% smaller than the original, which means faster uploads to transcription services and lower costs.

Use case: Audio quality check

Before reviewing hours of UGC video, check audio quality quickly:

{
  "ffmpeg_command": "-i {{in_video}} -t 30 -vn -c:a libmp3lame -b:a 128k {{out_audio}}",
  "input_files": { "in_video": "{{file_url}}" },
  "output_files": { "out_audio": "preview.mp3" }
}

Extract the first 30 seconds as a quick preview. Listen in Slack or email without downloading the full video.

Cost

Audio extraction is one of the lightest FFmpeg operations. Processing is nearly instant.

Volume	Monthly commands	Plan	Cost
10 videos/week	40	Starter	$9/mo
5 videos/day	500	Starter	$9/mo
20 videos/day	600	Growth	$29/mo

Video contains audio. FFmpeg extracts it. Zapier automates it. That's the whole story.

Best FFmpeg API Services in 2026: Complete Comparison

RenderIO — Wed, 08 Apr 2026 06:12:49 +0000

The FFmpeg API market in 2026

Running FFmpeg on someone else's infrastructure is a solved problem. The FFmpeg as a service model means multiple services now offer REST APIs that accept FFmpeg commands and return processed files.

But they're not all the same. Pricing models differ. Infrastructure varies. Feature sets diverge. The right choice depends on your specific use case, volume, and budget.

This is a comparison of every major FFmpeg API option available in 2026, including self-hosted alternatives. For a pricing-only breakdown, see the detailed pricing comparison. For a hands-on guide to making your first API call, start with the complete FFmpeg API guide.

The contenders

RenderIO - Edge-based FFmpeg API on Cloudflare
Rendi - One of the original FFmpeg API services
ffmpeg-api.com - Lightweight FFmpeg API
Self-hosted on AWS Lambda - DIY approach
Self-hosted on GCP Cloud Run - Container-based DIY
Self-hosted on bare metal - Full control approach

Feature matrix

Feature	RenderIO	Rendi	ffmpeg-api.com	Lambda (DIY)	Cloud Run (DIY)
Full FFmpeg	Yes	Yes	Yes	Partial*	Yes
Managed service	Yes	Yes	Yes	Semi	Semi
Entry price	$9/mo	Free ($0)	Varies	Pay-per-use	Pay-per-use
Egress fees	$0	$0	Varies	$0.09/GB	$0.12/GB
Edge computing	Yes (330+ cities)	No	No	Per-region	Per-region
Webhooks	Yes (retry + DLQ)	Basic	Varies	DIY	DIY
Max video length	Configurable	Plan-based	Varies	15 min timeout	Configurable
Scaling	Automatic	Automatic	Varies	Cold starts	Automatic
Setup time	5 minutes	5 minutes	5 minutes	2-8 hours	1-4 hours

*AWS Lambda has a 250MB deployment package limit, which restricts FFmpeg codec support. See the serverless FFmpeg deep dive for the full breakdown of Lambda's limitations.

RenderIO

Architecture

Runs on Cloudflare Workers with Sandbox Durable Objects. Each FFmpeg command executes in an isolated container on the nearest edge location. Results stored in R2 (zero egress).

Pricing

Plan	Price	Commands/mo	Max Duration	Storage	Overage
Starter	$9/mo	500	1 min	5 GB	$0.08/cmd
Growth	$29/mo	1,000	5 min	10 GB	$0.05/cmd
Business	$99/mo	20,000	20 min	200 GB	$0.02/cmd

Command-based pricing means file size doesn't affect cost. A 10MB video and a 2GB video both count as one command. Zero egress fees on all plans since output files are stored on Cloudflare R2.

API example

curl -X POST https://renderio.dev/api/v1/run-ffmpeg-command \
  -H "X-API-KEY: ffsk_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "ffmpeg_command": "-i {{in_video}} -vf \"scale=1920:1080\" -c:v libx264 -crf 20 {{out_video}}",
    "input_files": { "in_video": "https://example.com/input.mp4" },
    "output_files": { "out_video": "output.mp4" }
  }'

Best for

Teams processing up to 20,000 videos/month (and beyond with overage)
Global user bases (edge processing)
Workflows needing reliable webhooks
Predictable billing requirements

Considerations

Newer service (less community content)
Cloudflare ecosystem lock-in for storage

Rendi

Architecture

Runs on traditional cloud providers (AWS/GCP/Azure). Processing in specific regions. Established service with a track record.

Pricing

Free: $0/mo (4 vCPUs, 50GB processing, 1 min runtime)
Pro: $25/mo (4-256 vCPUs, 100GB+ processing, up to unlimited runtime)
Enterprise: Custom pricing
GB-based pricing model, no egress fees

Rendi has a free tier, which RenderIO does not. If you want to test an FFmpeg API without entering payment details, Rendi's free plan lets you process up to 50GB with a 1-minute runtime limit. The $5 credit card verification is refunded.

API example

curl -X POST https://api.rendi.dev/v1/process \
  -H "Authorization: Bearer rendi_key" \
  -d '{
    "command": "ffmpeg -i input.mp4 -vf scale=1920:1080 output.mp4",
    "inputs": { "input.mp4": "https://example.com/input.mp4" }
  }'

Best for

Teams already integrated with Rendi
Workflows processing many small files (GB-based pricing advantage)
Users who want a free tier to test with

Considerations

Free tier limited to 1 min runtime and 50GB processing
GB-based pricing can be unpredictable with large files
Pro plan starts at $25/mo vs RenderIO's $9/mo

ffmpeg-api.com

Architecture

Third-party FFmpeg API service. The website and documentation have changed multiple times, making it hard to give a stable overview. As of early 2026, it appears to offer a REST API that accepts FFmpeg commands, similar to RenderIO and Rendi.

Best for

Simple, one-off conversions where you want another option
Testing alongside other services to compare latency

Considerations

Pricing, feature set, and documentation have changed over time. Check ffmpeg-api.com directly for current plans before committing.
We couldn't confirm SLA or uptime guarantees. Test thoroughly before using in production.
Codec and filter support may be narrower than a full FFmpeg build. Verify that your specific commands work before building a pipeline around it.

Self-hosted: AWS Lambda

Architecture

Package FFmpeg as a Lambda layer. Trigger via API Gateway. Process video in Lambda function. Store results in S3.

Setup (simplified pseudocode)

# Lambda function (simplified - real implementation needs
# download/upload logic, error handling, and temp file management)



def handler(event, context):
    command = event['ffmpeg_command']
    # Download input from S3
    # Run FFmpeg
    subprocess.run(['ffmpeg'] + command.split())
    # Upload output to S3
    return {'statusCode': 200, 'body': output_url}

Pricing

Lambda: $0.0000167/GB-s
API Gateway: $3.50/million requests
S3 storage: $0.023/GB
S3 egress: $0.09/GB
Total for 10,000 videos/month: ~$15-50 depending on video size and duration

Best for

Teams with AWS expertise
Low-volume processing (under 100 videos/month)
Simple operations (convert, resize)

Considerations

250MB deployment limit: Can't include all FFmpeg codecs. No libx265, limited filter support.
15-minute timeout: Long videos or complex filter chains will fail.
Cold starts: First invocation after idle takes 5-10 seconds.
Complex packaging: FFmpeg binary must be compiled for Lambda's Amazon Linux environment.
No GPU: Strictly CPU encoding.

Self-hosted: GCP Cloud Run

Architecture

Docker container with FFmpeg. Triggered via HTTP request. Auto-scales to zero when idle.

Setup

FROM jrottenberg/ffmpeg:4.4-alpine
COPY server.js /app/
WORKDIR /app
RUN apk add --no-cache nodejs npm
RUN npm install express
CMD ["node", "server.js"]

Pricing

Cloud Run: $0.00002400/vCPU-second + $0.00000250/GiB-second
Cloud Storage: $0.020/GB
Egress: $0.12/GB
Total for 10,000 videos/month: ~$30-100+ depending on processing time

Best for

Teams with GCP expertise and existing infrastructure
Need for custom FFmpeg builds or specific codec versions
Long-running processes (no 15-minute timeout)

Considerations

You manage everything: Scaling, error handling, retries, monitoring
Cold starts: Container startup adds 2-5 seconds
Egress costs: $0.12/GB adds up quickly with video
Operational overhead: Logging, alerting, container updates, security patches

Self-hosted: Bare metal / VPS

Architecture

Install FFmpeg on a VPS (DigitalOcean, Hetzner, etc.). Run a web server that accepts commands and processes video.

Pricing

Hetzner CPX31 (4 vCPU, 8GB RAM): ~$15/month
DigitalOcean Droplet (4 vCPU, 8GB): ~$48/month

Best for

Maximum control over FFmpeg version and codecs
Consistent, predictable workloads
Teams with Linux sysadmin skills

Considerations

You manage everything: OS updates, security, monitoring, backups
No auto-scaling: Fixed capacity regardless of demand
Single point of failure: One server goes down, everything stops
GPU possible: Can use GPU-enabled instances for hardware encoding

Best FFmpeg API decision matrix

Requirement	Best option
Just works, no ops	RenderIO or Rendi
Cheapest at 100 videos/month	RenderIO Starter ($9/mo) or Lambda
Cheapest at 10,000 videos/month	RenderIO Business ($99/mo)
Global low latency	RenderIO (edge)
Maximum FFmpeg control	Self-hosted (bare metal)
Existing AWS infrastructure	Lambda (if simple) or Cloud Run
GPU encoding	Self-hosted (bare metal with GPU)
Reliable webhooks	RenderIO
Free tier to test with	Rendi
Minimum operational overhead	RenderIO or Rendi

Cost comparison at scale

10,000 videos/month, average 50MB each

Service	Monthly cost	Notes
RenderIO	$99	Business plan, 20K commands (10K well within plan)
Rendi	$25+	Pro plan base, but 10K x 50MB = 500GB processing may need Enterprise
Lambda	$15-50	Varies with processing time, plus egress
Cloud Run	$30-100	Varies with processing time, plus egress
Bare metal	$15-48	Fixed, but limited concurrent capacity

RenderIO has the most predictable billing at this scale since you pay per command with no egress fees. Rendi's GB-based pricing is cheaper at the base rate but gets harder to predict with varying file sizes.

100,000 videos/month

Service	Monthly cost
RenderIO	Custom pricing
Rendi	Custom pricing
Lambda	$150-500 (with egress)
Cloud Run	$300-1,000 (with egress)
Bare metal cluster	$200-500

At very high volume, self-hosted becomes more cost-effective but requires significant engineering investment in operations.

Recommendation

For most teams in 2026:

Start with RenderIO's Starter plan ($9/month, 500 commands) or Rendi's free tier to test the API pattern
Scale to Growth ($29/month) as volume increases
Move to Business ($99/month) for high-volume workloads up to 20,000 commands
Consider self-hosted only if you need custom codecs, GPU encoding, or process 100K+ videos monthly

Self-hosting requires someone to set up, maintain, and debug the infrastructure. That can mean anywhere from a few hours to 40+ hours of engineering time per month depending on complexity. Whether that tradeoff makes sense depends on your team size and volume.

For the step-by-step setup, read the FFmpeg REST API tutorial. If you prefer language-specific guides, there are Python and Node.js tutorials too. The FFmpeg cheat sheet has quick-reference commands for the most common operations.

FAQ

What is the best FFmpeg API for small projects?

For projects processing under 500 videos a month, RenderIO's Starter plan ($9/mo) or Rendi's free tier both work. Rendi gives you a free tier with a 1-minute runtime limit and 50GB processing cap. RenderIO starts at $9/mo but has no runtime or processing size limits beyond the command count.

How does an FFmpeg API compare to running FFmpeg locally?

An FFmpeg API accepts the same command string you'd run locally, but executes it on cloud infrastructure. You don't install FFmpeg, manage servers, or worry about CPU capacity. The tradeoff is cost (you pay per command or per GB) and latency (network round-trip to upload/download files). For one-off personal use, local FFmpeg is free. For applications, APIs are easier to scale and maintain.

Can I use an FFmpeg API for real-time video processing?

Not for live streaming. FFmpeg APIs are designed for batch processing: you submit a file, it gets processed, you get the result back. Processing typically takes 1-30 seconds depending on the operation and file size. For real-time video manipulation, you'd need a streaming-specific solution or run FFmpeg locally with pipe I/O.

What's the difference between command-based and GB-based FFmpeg API pricing?

Command-based pricing (like RenderIO) charges per FFmpeg command regardless of file size. A 5MB file and a 5GB file cost the same. GB-based pricing (like Rendi's processing model) charges based on the total data processed (input + output). Command-based is more predictable. GB-based can be cheaper for small files and more expensive for large ones.

Is self-hosting FFmpeg cheaper than using an API?

At low volume (under 1,000 videos/month), a managed API is almost always cheaper when you factor in engineering time for setup, maintenance, monitoring, and debugging. At very high volume (100K+ videos/month), self-hosting on dedicated hardware can be cheaper per-video, but you need someone maintaining the infrastructure. The break-even point depends on your team's hourly rate and the complexity of your FFmpeg operations.

Do FFmpeg APIs support GPU-accelerated encoding?

Most managed FFmpeg APIs (RenderIO, Rendi) run on CPU infrastructure. For GPU-accelerated encoding with NVENC or CUDA, you currently need to self-host on GPU-enabled instances. The GPU acceleration guide covers the hardware encoding options and when they're worth the extra infrastructure cost.

E-Commerce Video Processing API: Product Video Pipeline

RenderIO — Mon, 06 Apr 2026 11:19:36 +0000

E-commerce needs video at scale

Product pages with video convert better than static images. A 2023 Wyzowl survey found that 82% of consumers were convinced to buy a product after watching a video. Shopify merchants who added product video to their listings reported higher conversion rates, particularly in electronics and apparel. TikTok Shop requires video for every listing. Amazon encourages product video. Instagram Shopping is video-first.

The problem isn't creating one video. It's processing thousands. Every product needs videos resized for each platform, watermarks for different sales channels, compressed versions for fast loading, and multiple variations for A/B testing.

A video editor can handle 10-20 products per day. An API handles 10,000.

Why use a video processing API

Building video processing in-house means installing FFmpeg on your servers, managing CPU-intensive workloads that spike and idle, handling file storage and delivery, building queuing systems for batch operations, and scaling infrastructure as your catalog grows.

Or you can send an HTTP request and get a processed video back.

RenderIO runs FFmpeg on Cloudflare's edge network. You send a command, it processes the video, you get a download URL. No servers, no scaling, no infrastructure. For a full walkthrough of the API, see the FFmpeg API complete guide.

Core e-commerce video processing API operations

Resize for platforms

Each sales channel has different requirements:

# TikTok Shop: 9:16, 1080x1920
curl -X POST https://renderio.dev/api/v1/run-ffmpeg-command \
  -H "X-API-KEY: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "ffmpeg_command": "-i {{in_video}} -vf \"scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2:white\" -c:v libx264 -crf 20 -movflags +faststart {{out_video}}",
    "input_files": { "in_video": "https://cdn.example.com/product-original.mp4" },
    "output_files": { "out_video": "product-tiktok.mp4" }
  }'

# Amazon: 16:9, 1920x1080, max 5GB
curl -X POST https://renderio.dev/api/v1/run-ffmpeg-command \
  -H "X-API-KEY: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "ffmpeg_command": "-i {{in_video}} -vf \"scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2:white\" -c:v libx264 -crf 18 -movflags +faststart {{out_video}}",
    "input_files": { "in_video": "https://cdn.example.com/product-original.mp4" },
    "output_files": { "out_video": "product-amazon.mp4" }
  }'

# Instagram Shopping: 1:1, 1080x1080
curl -X POST https://renderio.dev/api/v1/run-ffmpeg-command \
  -H "X-API-KEY: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "ffmpeg_command": "-i {{in_video}} -vf \"crop=min(iw\\,ih):min(iw\\,ih),scale=1080:1080\" -c:v libx264 -crf 20 -movflags +faststart {{out_video}}",
    "input_files": { "in_video": "https://cdn.example.com/product-original.mp4" },
    "output_files": { "out_video": "product-instagram.mp4" }
  }'

Add watermarks

Protect product videos on different channels:

curl -X POST https://renderio.dev/api/v1/run-ffmpeg-command \
  -H "X-API-KEY: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "ffmpeg_command": "-i {{in_video}} -i {{in_logo}} -filter_complex \"[1:v]scale=120:-1,format=rgba,colorchannelmixer=aa=0.4[logo];[0:v][logo]overlay=W-w-20:H-h-20[v]\" -map \"[v]\" -map 0:a -c:v libx264 -crf 20 -c:a copy {{out_video}}",
    "input_files": {
      "in_video": "https://cdn.example.com/product.mp4",
      "in_logo": "https://cdn.example.com/brand-logo.png"
    },
    "output_files": { "out_video": "product-watermarked.mp4" }
  }'

The colorchannelmixer=aa=0.4 makes the watermark 40% transparent. Professional without being intrusive.

Compress for fast loading

Product pages need fast-loading video. Here's how to compress without visible quality loss:

curl -X POST https://renderio.dev/api/v1/run-ffmpeg-command \
  -H "X-API-KEY: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "ffmpeg_command": "-i {{in_video}} -c:v libx264 -crf 28 -preset slow -vf \"scale=720:-2\" -c:a aac -b:a 96k -movflags +faststart {{out_video}}",
    "input_files": { "in_video": "https://cdn.example.com/product-hd.mp4" },
    "output_files": { "out_video": "product-web.mp4" }
  }'

This produces a 720p video with aggressive compression. File size typically drops 70-80% while maintaining acceptable quality for product pages. For more compression strategies, check the video compression guide.

Create thumbnails

Extract the best frame for product listing thumbnails:

curl -X POST https://renderio.dev/api/v1/run-ffmpeg-command \
  -H "X-API-KEY: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "ffmpeg_command": "-i {{in_video}} -vf \"select=eq(pict_type\\,I),scale=800:-1\" -frames:v 1 {{out_thumb}}",
    "input_files": { "in_video": "https://cdn.example.com/product.mp4" },
    "output_files": { "out_thumb": "thumbnail.jpg" }
  }'

This extracts the first I-frame (keyframe), which is typically the clearest frame in the video. For more thumbnail strategies including scene detection and quality optimization, see the FFmpeg frame extraction guide.

Building the complete pipeline

One product, all platforms

async function processProductVideo(productId, videoUrl, logoUrl) {
  const platforms = [
    {
      name: "tiktok",
      command: `-i {{in_video}} -i {{in_logo}} -filter_complex "[1:v]scale=80:-1,format=rgba,colorchannelmixer=aa=0.3[logo];[0:v]scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2:white[bg];[bg][logo]overlay=W-w-20:20[v]" -map "[v]" -map 0:a? -c:v libx264 -crf 22 -c:a aac -movflags +faststart {{out_video}}`,
    },
    {
      name: "amazon",
      command: `-i {{in_video}} -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2:white" -c:v libx264 -crf 18 -movflags +faststart {{out_video}}`,
    },
    {
      name: "instagram",
      command: `-i {{in_video}} -i {{in_logo}} -filter_complex "[1:v]scale=80:-1,format=rgba,colorchannelmixer=aa=0.3[logo];[0:v]crop=min(iw\\,ih):min(iw\\,ih),scale=1080:1080[bg];[bg][logo]overlay=W-w-15:H-h-15[v]" -map "[v]" -map 0:a? -c:v libx264 -crf 20 -movflags +faststart {{out_video}}`,
    },
    {
      name: "web-compressed",
      command: `-i {{in_video}} -c:v libx264 -crf 28 -preset slow -vf "scale=720:-2" -c:a aac -b:a 96k -movflags +faststart {{out_video}}`,
    },
  ];

  const jobs = platforms.map(platform =>
    fetch("https://renderio.dev/api/v1/run-ffmpeg-command", {
      method: "POST",
      headers: {
        "X-API-KEY": process.env.RENDERIO_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        ffmpeg_command: platform.command,
        input_files: {
          in_video: videoUrl,
          in_logo: logoUrl,
        },
        output_files: { out_video: `${productId}-${platform.name}.mp4` },
      }),
    }).then(r => r.json())
  );

  return Promise.all(jobs);
}

4 API calls per product. 4 platform-ready videos. All processing in parallel.

Batch process catalog

async function processCatalog(products) {
  const BATCH_SIZE = 100;

  for (let i = 0; i < products.length; i += BATCH_SIZE) {
    const batch = products.slice(i, i + BATCH_SIZE);

    await Promise.all(
      batch.map(p =>
        processProductVideo(p.id, p.videoUrl, p.logoUrl)
      )
    );

    console.log(`Processed ${Math.min(i + BATCH_SIZE, products.length)}/${products.length} products`);
  }
}

1,000 products × 4 platforms = 4,000 API calls. That fits within the Business plan (20,000 commands/month).

Handling processing failures

Video processing can fail for a few reasons, and your pipeline needs to handle each one:

Invalid input URL

The source video doesn't exist or requires authentication. Use signed URLs with at least 1 hour of expiry. If you're pulling from Shopify's CDN, those URLs are public. But if you're hosting on S3, make sure the bucket policy or presigned URL allows access.

Timeout on large files

Videos over 500MB take longer. Poll with reasonable intervals (5-10 seconds) and set a maximum retry count. If a command hasn't completed after 5 minutes, check the error status rather than polling forever.

FFmpeg command errors

A typo in your filter chain fails the whole command. Test commands locally with a sample file before putting them in your pipeline. The error response includes FFmpeg's stderr output, so read it.

async function pollWithRetry(commandId, apiKey, maxAttempts = 60) {
  for (let i = 0; i < maxAttempts; i++) {
    const res = await fetch(`https://renderio.dev/api/v1/commands/${commandId}`, {
      headers: { "X-API-KEY": apiKey },
    });
    const data = await res.json();

    if (data.status === "SUCCESS") return data;
    if (data.status === "FAILED") throw new Error(`FFmpeg failed: ${data.error}`);

    await new Promise(r => setTimeout(r, 5000));
  }
  throw new Error(`Timeout after ${maxAttempts * 5}s`);
}

Webhook-based completion

For production pipelines, polling loops waste resources. Use webhooks instead:

{
  "ffmpeg_command": "-i {{in_video}} -vf \"scale=1080:1920:...\" -c:v libx264 -crf 20 {{out_video}}",
  "input_files": { "in_video": "https://cdn.example.com/product.mp4" },
  "output_files": { "out_video": "product-tiktok.mp4" },
  "webhook_url": "https://your-server.com/api/video-complete"
}

When the command finishes, RenderIO sends a POST to your webhook URL with the command status and output file URLs. Your server processes the callback, updates the product listing, and moves on. No polling. No wasted API calls.

This matters at scale. If you're processing 500 products per day across 4 platforms, that's 2,000 commands. With polling at 5-second intervals and an average processing time of 15 seconds, you'd make 6,000 status checks. With webhooks, you make zero.

Integration with e-commerce platforms

Shopify

Use Shopify's Admin API to upload processed videos back to product listings:

// After RenderIO processing completes
const processedVideoUrl = completedCommand.output_files["product-web.mp4"];

await shopify.product.update(productId, {
  media: [{
    alt: "Product video",
    mediaContentType: "VIDEO",
    originalSource: processedVideoUrl,
  }],
});

For automating this with Zapier (new product triggers video creation automatically), see the Zapier product video automation guide. The n8n video processing guide covers the same flow for n8n users.

WooCommerce

WooCommerce doesn't have native video fields on products. You'll need either a plugin like "Product Video for WooCommerce" or a custom meta field:

const response = await woocommerce.post("products/" + productId, {
  meta_data: [{
    key: "product_video_url",
    value: processedVideoUrl,
  }],
});

This stores the URL in meta_data, but your theme won't display it automatically. You'll need a custom template snippet or a video gallery plugin that reads from meta fields.

TikTok Shop

TikTok Shop video requirements: 9:16 aspect ratio, 1080x1920 minimum, MP4 format, under 500MB, 15-60 seconds. The resize command above handles the format. Upload via TikTok Shop's Content API or manually through Seller Center.

Automating the full workflow

The real power is connecting video processing to your product catalog so it runs automatically. There are two good approaches:

Zapier: New product trigger → RenderIO API → upload to storage. The Zapier product video guide walks through the complete Zap with template overlays and text.

n8n: Webhook or schedule trigger → batch process → upload. More flexibility for complex logic. See the n8n video processing guide.

For batch processing large catalogs at once, the batch process AI videos guide covers parallelization strategies.

Pricing for e-commerce

Catalog size	Platforms	API calls/month	Plan	Cost/month
30 products	4	120	Starter	$9
250 products	4	1,000	Growth	$29
5,000 products	4	20,000	Business	$99

Zero egress fees because RenderIO runs on Cloudflare R2. No hidden storage costs. No bandwidth charges.

The math is straightforward: count your products, multiply by the number of platform versions you need per product, and pick the plan that fits. Most small-to-medium stores land on Growth. Large catalogs or stores that reprocess on price/image changes need Business.

FAQ

How long does video processing take?

Typical product videos (30-60 seconds, 1080p source) process in 5-15 seconds per operation. Resizing is faster than complex filter chains. A four-platform pipeline for one product finishes in about 15-20 seconds total since all four commands run in parallel.

Can I process videos when a new product is added?

Yes. Set up a Shopify webhook (or use Zapier/n8n) to trigger video processing whenever a product is created or updated. The Zapier product video guide has the complete setup.

What video formats does TikTok Shop accept?

MP4 is the safe choice. TikTok Shop requires 9:16 aspect ratio, minimum 720x1280 resolution (1080x1920 recommended), H.264 codec, under 500MB, and between 15-60 seconds duration.

How do I handle processing failures?

Check the command status endpoint. Failed commands return a status: "failed" with an error field containing FFmpeg's stderr output. Common fixes: verify your input URL is accessible, check your FFmpeg command syntax, ensure the output format matches the filename extension.

Is there a file size limit?

No hard limit on the API side. Input files are fetched via URL, so the bottleneck is download speed. Videos over 1GB work fine but take longer to fetch and process. For very large files (2GB+), expect processing times of 1-3 minutes.

Build an AI UGC Video Processing Pipeline

RenderIO — Mon, 06 Apr 2026 11:18:50 +0000

The real bottleneck in AI UGC video production

AI-generated UGC for ads and social media has moved past the "can we do this" phase. Tools like HeyGen, Synthesia, and D-ID produce convincing avatar videos. The generation part works. Everything after generation is where teams get stuck.

You generate a video. Then you need to post-process it so it doesn't scream "AI." Then you need variations for A/B testing across ad sets. Then each variation needs reformatting for different platforms. One base video can turn into 50-100 output files. Without a pipeline, each one is manual work in Premiere or CapCut.

This guide walks through building that pipeline with FFmpeg and the RenderIO API, from raw AI output to platform-ready content.

How the AI UGC video processing pipeline works

AI Generation → Post-Processing → Variation → Platform Formatting → Distribution
  (HeyGen)       (RenderIO)     (RenderIO)     (RenderIO)         (n8n/Zapier)

Each stage is a separate API call. Each call runs independently. The entire pipeline from generation to distribution takes under 10 minutes for 50+ output files.

Stage 1: choose your AI generation tool

Pick the tool that matches what you're building:

HeyGen works best for talking-head UGC with custom avatars. If you're creating product demos or testimonial-style content, this is probably where you start. Their avatar quality has gotten noticeably better since late 2025. See our guide on converting HeyGen output to Instagram Reels for the full post-processing workflow.

Synthesia is more corporate. Training videos, internal comms, that sort of thing. The avatars feel professional but not "social media native."

D-ID turns a single photo into a talking video. Useful when you don't have studio footage. Less realistic than HeyGen but faster to set up.

Runway combined with a voice-over tool works for creative or lifestyle UGC where you want more visual flexibility than a talking head.

Output from any of these: one raw MP4 file, typically 16:9, 30-60 seconds.

Stage 2: post-processing raw AI video

Raw AI video has tells. Metadata flags it as AI-generated. Audio levels are inconsistent. The video looks "too clean" compared to native social content. Post-processing fixes all of that in one API call per base video.

Here's why each step matters:

map_metadata -1 strips generation metadata that platforms can detect
nlmeans + noise adds natural film grain (AI video is unnaturally clean)
eq shifts color just enough to break perceptual fingerprints
loudnorm normalizes audio to -14 LUFS (what TikTok and Reels expect)

curl -X POST https://renderio.dev/api/v1/run-ffmpeg-command \
  -H "X-API-KEY: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "ffmpeg_command": "-i {{in_video}} -map_metadata -1 -vf \"nlmeans=s=6:p=3:r=9,noise=alls=12:allf=t,eq=brightness=0.01:contrast=1.03:saturation=0.97\" -af \"loudnorm=I=-14:TP=-2:LRA=7\" -c:v libx264 -crf 18 -c:a aac -b:a 128k {{out_video}}",
    "input_files": { "in_video": "https://example.com/heygen-raw.mp4" },
    "output_files": { "out_video": "base-processed.mp4" }
  }'

The output is a clean base for variation creation. For more on making AI video look natural, we have a dedicated guide.

Troubleshooting post-processing

A few things that trip people up:

Grain looks blocky on short videos (under 15 seconds). Lower the noise value from alls=12 to alls=6. Short clips get compressed harder by platforms, and heavy grain turns into blocky artifacts after re-encoding.

Audio sounds distorted after loudnorm. This usually happens when the source audio is already very loud (above -8 LUFS). Add a limiter before loudnorm: -af "alimiter=limit=0.9,loudnorm=I=-14:TP=-2:LRA=7".

HeyGen output has variable frame rate. Force constant frame rate early in the chain by adding -r 30 before the output filename. Variable frame rate causes sync issues in some platform players.

Stage 3: creating AI UGC video variations

One base video becomes 10-20 unique variations. Each variation uses different FFmpeg parameters so every output has a distinct fingerprint. This matters for ad testing (different creatives per ad set) and for posting across accounts without duplicate detection.

Color grade variations

const colorVariations = [
  { name: "warm", filter: "colortemperature=temperature=6500" },
  { name: "cool", filter: "colortemperature=temperature=4500" },
  { name: "vivid", filter: "eq=saturation=1.3:contrast=1.1" },
  { name: "muted", filter: "eq=saturation=0.7:contrast=0.95" },
  { name: "vintage", filter: "eq=saturation=0.8:contrast=1.1,colorbalance=rs=0.05:gs=-0.02:bs=-0.05" },
];

Speed variations

const speedVariations = [
  { name: "normal", filter: "setpts=1.0*PTS", afilter: "atempo=1.0" },
  { name: "fast", filter: "setpts=0.9*PTS", afilter: "atempo=1.11" },
  { name: "slow", filter: "setpts=1.1*PTS", afilter: "atempo=0.91" },
];

Crop variations

Different crop positions change the video's perceptual hash, which helps if you're posting variations across multiple accounts. See our guide on batch processing AI videos for social media for platform-specific crop strategies.

const cropVariations = [
  { name: "center", filter: "crop=ih*9/16:ih:(iw-ih*9/16)/2:0" },
  { name: "left", filter: "crop=ih*9/16:ih:iw*0.1:0" },
  { name: "right", filter: "crop=ih*9/16:ih:iw*0.5:0" },
  { name: "tight", filter: "crop=iw*0.6:ih*0.6:iw*0.2:ih*0.1,scale=1080:1920" },
];

Combined variation generator

async function createVariations(baseVideoUrl) {
  const variations = [];

  for (const color of colorVariations) {
    for (const speed of speedVariations) {
      const name = `${color.name}-${speed.name}`;
      const vf = `${speed.filter},${color.filter}`;
      const af = speed.afilter;

      variations.push({
        name,
        command: `-i {{in_video}} -vf "${vf}" -af "${af}" -c:v libx264 -crf 22 -c:a aac -b:a 128k {{out_video}}`,
      });
    }
  }

  // 5 colors x 3 speeds = 15 variations
  const jobs = variations.map(v =>
    fetch("https://renderio.dev/api/v1/run-ffmpeg-command", {
      method: "POST",
      headers: {
        "X-API-KEY": process.env.RENDERIO_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        ffmpeg_command: v.command,
        input_files: { in_video: baseVideoUrl },
        output_files: { out_video: `${v.name}.mp4` },
      }),
    }).then(r => r.json())
  );

  return Promise.all(jobs);
}

15 variations, all processing in parallel. Total time: same as processing one video.

Stage 4: platform formatting for AI UGC videos

Each variation needs platform-specific formatting. This multiplies your output count. For the full breakdown of specs per platform, see batch processing AI videos for social media.

const platformConfigs = {
  tiktok: {
    command: `-i {{in_video}} -filter_complex "[0:v]scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920[v]" -map "[v]" -map 0:a -c:v libx264 -crf 22 -c:a aac -movflags +faststart {{out_video}}`,
  },
  reels: {
    command: `-i {{in_video}} -t 90 -filter_complex "[0:v]scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920[v]" -map "[v]" -map 0:a -c:v libx264 -crf 22 -c:a aac -movflags +faststart {{out_video}}`,
  },
  shorts: {
    command: `-i {{in_video}} -t 60 -filter_complex "[0:v]scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920[v]" -map "[v]" -map 0:a -c:v libx264 -crf 20 -c:a aac -movflags +faststart {{out_video}}`,
  },
  linkedin: {
    command: `-i {{in_video}} -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2" -af "loudnorm=I=-16" -c:v libx264 -crf 20 -c:a aac -movflags +faststart {{out_video}}`,
  },
};

async function formatForPlatforms(variationUrl, variationName) {
  const jobs = Object.entries(platformConfigs).map(([platform, config]) =>
    fetch("https://renderio.dev/api/v1/run-ffmpeg-command", {
      method: "POST",
      headers: {
        "X-API-KEY": process.env.RENDERIO_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        ffmpeg_command: config.command,
        input_files: { in_video: variationUrl },
        output_files: { out_video: `${variationName}-${platform}.mp4` },
      }),
    }).then(r => r.json())
  );

  return Promise.all(jobs);
}

15 variations x 4 platforms = 60 platform-ready videos. All from one AI generation.

Stage 5: distribution with n8n

Wire it all together with n8n (or Zapier). Check the n8n video processing guide for setup details.

Webhook trigger receives HeyGen export URL
HTTP Request sends POST to RenderIO for post-processing
Wait/Poll checks command status until complete
Loop iterates each variation config, sends POST to RenderIO
Wait/Poll checks all variation commands
Loop iterates each platform, sends POST to RenderIO
Wait/Poll checks all platform commands
Upload sends results to respective platform APIs or scheduling tools

The entire pipeline runs automatically. You input one HeyGen URL and get 60 platform-ready videos.

Cost analysis

Stage	API calls per base video	Notes
Post-processing	1	One-time cleanup
Variations	15	5 colors x 3 speeds
Platform formatting	60	15 variations x 4 platforms
Total	76	Per base video

On RenderIO's Growth plan at $29/month (1,000 commands), you can process about 13 base videos per month through the full pipeline. For higher volumes, the Business plan at $99/month (20,000 commands) handles 263 base videos per month.

Cost per output video (Business): ~$0.005
Cost per base video on Business (76 outputs): ~$0.38

Here's how it compares:

Method	Cost per base video	Your time
Manual processing in Premiere	$100-150 (at $50/hr)	2-3 hours
Adobe Premiere batch export	~$25 of time	30 min
RenderIO pipeline (Business)	$0.38	0 min

Getting started

Start with a simpler pipeline and expand:

Week 1: Post-processing only (1 API call per video)
Week 2: Add 3 color variations (4 API calls per video)
Week 3: Add platform formatting (16 API calls per video)
Week 4: Add speed variations and full automation (76 API calls per video)

The Starter plan ($9/month, 500 commands) covers week 1-2 for most teams. Scale to Growth or Business as your volume increases. You can also compress video with FFmpeg to reduce storage costs before uploading.

FAQ

How long does the full pipeline take to process one base video?

Under 10 minutes for all 76 API calls. RenderIO processes commands in parallel on Cloudflare's edge network, so 15 variation calls finish in roughly the same time as one.

Can I use this pipeline with AI video tools other than HeyGen?

Yes. The pipeline is tool-agnostic after stage 1. Any MP4 output works, whether it comes from HeyGen, Synthesia, D-ID, Runway, or even screen recordings. The post-processing and variation stages don't care how the video was generated.

What happens if an API call fails mid-pipeline?

Each command returns a status you can poll. Failed commands return an error with details. In an n8n workflow, add an error branch that retries failed calls up to 3 times with a 10-second delay between attempts.

Do I need all 15 variations, or can I start with fewer?

Start with 3 color variations and skip speed variations. That gives you 12 platform-ready files (3 variations x 4 platforms) from 4 API calls. Add speed variations once you're comfortable with the workflow.

Which RenderIO plan fits a UGC pipeline?

Depends on your volume. For 1-5 base videos per month, the Starter plan ($9/month, 500 commands) is enough. For 10-13 base videos, Growth ($29/month, 1,000 commands). For 50+ base videos, Business ($99/month, 20,000 commands).

Make AI-Generated Video Undetectable on TikTok

RenderIO — Mon, 06 Apr 2026 11:16:17 +0000

How to make AI video undetectable on TikTok

You generated a video with Runway, Kling, Pika, or Sora. It looks great. You upload it to TikTok. It gets suppressed or flagged.

The problem is twofold: metadata fingerprints from the generation tool, and visual patterns that detection algorithms catch. Both are fixable with FFmpeg. This guide walks through each fix step by step, so you can make AI-generated video undetectable before uploading.

What makes AI video detectable

Metadata fingerprints

Every AI video tool embeds metadata in the output file. The encoder field contains the tool's name or rendering engine. Creation timestamps are typically UTC and batch-generated (a giveaway when you upload seconds after "recording"). Some tools add proprietary tags and custom metadata fields. C2PA Content Credentials — increasingly common in 2025-2026 — explicitly declare AI origin. And the EXIF data (resolution, color space, technical settings) often matches the tool's default output exactly, which is another signal.

For a full walkthrough on stripping video metadata with FFmpeg, that guide covers every metadata field and how to remove them.

You can see this with ffprobe:

ffprobe -v quiet -print_format json -show_format input.mp4

Look for fields like encoder, comment, creation_time, and any tool-specific tags.

Visual patterns

AI video has characteristic patterns:

Consistent frame timing: AI renders at exact intervals. Natural video has micro-variations in frame timing.
Uniform noise patterns: AI-generated frames lack the random sensor noise present in camera footage.
Temporal consistency: AI maintains unnaturally smooth motion in areas that real cameras would show compression artifacts.
Color space: Many AI tools output in a specific color space (often BT.709 with particular gamma curves).

Step 1: Strip all metadata

Remove every metadata field:

ffmpeg -i ai_video.mp4 -map_metadata -1 -fflags +bitexact -c:v libx264 -crf 22 -c:a aac output.mp4

-map_metadata -1 removes all metadata containers. -fflags +bitexact prevents FFmpeg from writing its own metadata.

API call:

curl -X POST https://renderio.dev/api/v1/run-ffmpeg-command \
  -H "Content-Type: application/json" \
  -H "X-API-KEY: your_api_key" \
  -d '{
    "ffmpeg_command": "-i {{in_video}} -map_metadata -1 -fflags +bitexact -c:v libx264 -crf 22 -c:a aac {{out_video}}",
    "input_files": { "in_video": "https://example.com/ai-video.mp4" },
    "output_files": { "out_video": "clean.mp4" }
  }'

Step 2: Add natural sensor noise

Real cameras produce random noise from the image sensor. AI video is too clean. Add subtle noise:

ffmpeg -i ai_video.mp4 -vf "noise=alls=8:allf=t" -c:v libx264 -crf 22 output.mp4

alls=8 adds noise at strength 8 across all color planes. allf=t makes it temporal (varies per frame), mimicking real sensor behavior.

For a more natural look, add gaussian noise instead of uniform:

ffmpeg -i ai_video.mp4 -vf "noise=alls=6:allf=t+u" -c:v libx264 -crf 22 output.mp4

Step 3: Introduce frame timing variation

AI video has perfectly consistent frame timing. Real video from phones has slight jitter. Add micro-variations:

ffmpeg -i ai_video.mp4 -vf "setpts=PTS+random(0)*0.001" -c:v libx264 -crf 22 output.mp4

This adds up to 1ms of random timing variation per frame. Invisible during playback but breaks the perfect timing pattern.

Step 4: Re-encode to match phone camera output

TikTok expects video from phones. Match the encoding characteristics:

ffmpeg -i ai_video.mp4 \
  -c:v libx264 -profile:v high -level:v 4.0 \
  -crf 23 -preset medium \
  -pix_fmt yuv420p \
  -c:a aac -b:a 128k -ar 44100 \
  -movflags +faststart \
  output.mp4

This matches the H.264 High Profile Level 4.0 output that modern phones produce. yuv420p is the standard pixel format. movflags +faststart is how phone cameras write MP4 files.

Step 5: Crop to remove AI artifacts

AI videos often have subtle artifacts at frame edges (blurring, warping, or inconsistent generation). Crop a few pixels:

ffmpeg -i ai_video.mp4 -vf "crop=iw-8:ih-8:4:4" output.mp4

This removes 4 pixels from each edge. Eliminates edge artifacts and changes the perceptual hash.

Step 6: Adjust color space

Runway and Sora output in BT.709 with a specific gamma curve (usually 2.2 or sRGB transfer). Kling defaults to BT.709 but with flatter gamma that gives a slightly washed-out look. Pika's output varies by model version. The point is: each tool has a default color profile that detection systems can fingerprint. Shift it:

ffmpeg -i ai_video.mp4 -vf "eq=brightness=0.02:contrast=1.02:saturation=1.03:gamma=1.01" output.mp4

Slight brightness, contrast, saturation, and gamma adjustments. These shift the color profile away from the AI tool's default output.

The complete naturalizer command

Combine all steps into one FFmpeg command:

ffmpeg -i ai_video.mp4 \
  -vf "crop=iw-6:ih-6:3:3,noise=alls=6:allf=t,eq=brightness=0.015:saturation=1.02,hue=h=1" \
  -af "asetrate=44100*1.003,aresample=44100" \
  -c:v libx264 -profile:v high -level:v 4.0 -crf 23 -preset medium \
  -pix_fmt yuv420p \
  -c:a aac -b:a 128k -ar 44100 \
  -map_metadata -1 -fflags +bitexact \
  -movflags +faststart \
  output.mp4

This command:

Crops edges (removes AI artifacts, changes pHash)
Adds sensor noise (naturalizes the image)
Shifts brightness and color (moves away from AI defaults)
Shifts audio pitch slightly (alters audio fingerprint)
Encodes to phone-camera-like specs
Strips all metadata
Optimizes for mobile playback

API call:

curl -X POST https://renderio.dev/api/v1/run-ffmpeg-command \
  -H "Content-Type: application/json" \
  -H "X-API-KEY: your_api_key" \
  -d '{
    "ffmpeg_command": "-i {{in_video}} -vf \"crop=iw-6:ih-6:3:3,noise=alls=6:allf=t,eq=brightness=0.015:saturation=1.02,hue=h=1\" -af \"asetrate=44100*1.003,aresample=44100\" -c:v libx264 -profile:v high -level:v 4.0 -crf 23 -preset medium -pix_fmt yuv420p -c:a aac -b:a 128k -ar 44100 -map_metadata -1 -fflags +bitexact -movflags +faststart {{out_video}}",
    "input_files": { "in_video": "https://example.com/ai-video.mp4" },
    "output_files": { "out_video": "naturalized.mp4" }
  }'

Tool-specific considerations

Runway Gen-3/Gen-4

Runway writes multiple custom metadata fields: encoder, handler_name, and sometimes a comment field with generation parameters. The -map_metadata -1 -fflags +bitexact flags strip all of these.

Runway's color profile tends toward high saturation with punchy contrast. The naturalizer command's brightness and saturation shifts already handle this, but if your video still looks "too clean," add a slight gamma adjustment: gamma=0.98 in the eq filter.

Runway Gen-4 outputs at exactly 24fps with zero frame timing variation. Real phone cameras shoot at 29.97 or 30fps with slight jitter. Re-encode at 30fps with the timing variation from Step 3.

Kling AI

Kling has a known issue with temporal inconsistencies at scene transitions — frames sometimes stutter or repeat. The noise filter masks these, but also check for it visually before uploading. A single repeated frame is a dead giveaway to human reviewers.

Kling may embed watermarks depending on your subscription tier. Check the bottom-right corner of the frame. If present, crop by 20-30 pixels from the bottom edge:

ffmpeg -i kling_video.mp4 -vf "crop=iw:ih-30:0:0" -c:v libx264 -crf 22 output.mp4

Kling's audio tracks are often silent or contain synthesized ambient noise at suspiciously consistent levels. If your video has audio, verify it sounds natural or replace it entirely.

Sora

Sora produces some of the smoothest AI video on the market, which is actually a problem. Real video has micro-jitter, slight focus shifts, and compression artifacts from the camera sensor. Sora has none of that.

Beyond the noise and timing variation from the naturalizer command, consider adding a slight speed fluctuation. Slow the video by 2% and it introduces natural-feeling drag:

ffmpeg -i sora_video.mp4 -vf "setpts=PTS*1.02,noise=alls=7:allf=t" -c:v libx264 -crf 22 output.mp4

Sora also outputs with specific C2PA Content Credentials that explicitly declare AI generation. The metadata strip handles this, but double-check with ffprobe after processing.

Pika Labs

Pika's free tier adds a visible watermark in the lower-right corner. Crop it or cover it with your own overlay before running the naturalizer:

ffmpeg -i pika_video.mp4 -vf "crop=iw-40:ih-40:0:0" -c:v libx264 -crf 22 output.mp4

Pika's output resolution varies by model version (sometimes 576p, sometimes 720p, sometimes 1080p). If you're uploading to TikTok, resize to 1080x1920 after naturalizing. A non-standard resolution is a subtle signal.

For more on cleaning up AI artifacts specifically, see remove AI artifacts from video and make AI video look natural.

Batch processing AI videos

For content operations generating many AI videos:



API_KEY = "ffsk_your_key"
HEADERS = {"Content-Type": "application/json", "X-API-KEY": API_KEY}

videos = [
    "https://example.com/ai-video-1.mp4",
    "https://example.com/ai-video-2.mp4",
    "https://example.com/ai-video-3.mp4",
]

for i, url in enumerate(videos):
    noise = 5 + (i % 4)
    brightness = 0.01 + (i * 0.005)

    response = requests.post(
        "https://renderio.dev/api/v1/run-ffmpeg-command",
        headers=HEADERS,
        json={
            "ffmpeg_command": f'-i {{in_video}} -vf "crop=iw-6:ih-6:3:3,noise=alls={noise}:allf=t,eq=brightness={brightness:.3f}" -c:v libx264 -crf 23 -map_metadata -1 -fflags +bitexact {{out_video}}',
            "input_files": {"in_video": url},
            "output_files": {"out_video": f"natural_{i}.mp4"}
        }
    )
    print(f"Video {i}: {response.json()['command_id']}")

Verification

After processing, check four things:

Run ffprobe -v quiet -print_format json -show_format output.mp4 and confirm no tool-specific metadata fields remain. Look for encoder, comment, creation_time, and any custom tags. If any are present, your metadata strip didn't work.

View the video at 200% zoom. You should see subtle grain from the noise filter. If the image is perfectly clean, the noise wasn't applied.

Check file size. A 30-second 1080p video from a phone is typically 30-80MB. If your output is 5MB or 200MB, something's off with the encoding settings.

Play the audio back. A 0.3-0.5% pitch shift is inaudible. Above 1%, you'll hear it. If the audio sounds slightly chipmunked, dial back the pitch multiplier.

If you're posting the same AI video to multiple accounts, you'll also need to avoid TikTok duplicate detection at scale by generating unique variations. For deeper metadata removal, the remove AI metadata from video guide covers edge cases that the basic strip misses.

Get started

The Starter plan at $9/mo includes 500 commands, enough to process 10-15 AI-generated clips per day. Explore the FFmpeg video API or get your API key.

FAQ

Does TikTok actually detect AI-generated video?

Yes, and it's getting better at it. TikTok uses a combination of metadata analysis, perceptual fingerprinting, and (increasingly) visual pattern detection. C2PA Content Credentials are the most obvious signal. Tools like Runway and Sora now embed these by default. Metadata stripping handles C2PA. The visual patterns are harder to detect algorithmically, but TikTok is investing in it.

Will these techniques work on Instagram and YouTube too?

The same principles apply. Instagram uses similar fingerprinting for Reels. YouTube has its own content detection system (Content ID) but it's focused on copyright, not AI detection, at least for now. The metadata strip and noise addition work across all platforms.

Is it legal to remove AI metadata from videos?

Removing metadata is legal in most jurisdictions. However, some regions are implementing AI disclosure requirements (the EU AI Act, for example). Removing C2PA markers to avoid disclosure could have legal implications depending on how you use the video. This guide covers the technical steps; consult local regulations for compliance.

How much noise should I add without making the video look bad?

Noise strength 5-8 is the range. Below 5, the noise is too subtle to fool detection. Above 10, it's visible on mobile screens. For high-quality AI video (Sora, Runway Gen-4), start at 6. For lower-quality sources (Pika free tier, older Kling models), start at 4. They already have enough imperfections.

Do I need to process audio separately?

Not usually. The naturalizer command shifts audio pitch as part of the combined pipeline. If your AI video has no audio (many AI tools generate silent video), add a natural ambient track or keep it silent. TikTok doesn't flag silent videos specifically. If you're adding music, that replaces the audio fingerprint entirely.