DEV Community: RenderIO

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.