Automate Product Video Processing with n8n + RenderIO

Product videos need to be everywhere, in every format

You sell products on TikTok Shop, Instagram Shopping, Facebook Marketplace, and your own site. Each platform wants different video specs. TikTok wants 9:16. Facebook wants 1:1 or 16:9. Instagram wants all three.

For a catalog of 200 products, each needing 3-4 platform sizes, that's 600-800 video variations. Doing this manually takes a video editor a full week. Doing it with n8n + RenderIO takes an afternoon of setup and runs automatically.

Use the RenderIO n8n node

RenderIO has a partner-verified community node on the n8n marketplace. Install from Settings → Community Nodes → search "renderio". It wraps the API into a visual interface with built-in auth, command execution, and file management.

For product video workflows, the node's preset feature lets you define templates once and reuse them across your catalog. The examples below use HTTP Request nodes for full control, but the same commands work with the native node.

The e-commerce video problem

Product videos are typically shot in one format (usually 16:9 landscape or 1:1 square). But you need:

One source video. Seven outputs. Multiply by your catalog size.

Workflow overview

Product Catalog → For Each Product → Resize for All Platforms → Add Brand Watermark → Compress → Store Results → Update Catalog

Phase 1: Product catalog integration

Your product catalog lives somewhere. Common sources:

Shopify (via n8n Shopify node): Pull products with video URLs from your Shopify store.

Airtable (via n8n Airtable node): A product database with columns: product_name, sku, video_url, platforms.

Google Sheets: Simple spreadsheet with product info and video URLs.

Custom API: Your e-commerce backend's product endpoint.

Example trigger from Airtable:

Node 1: Airtable Trigger Watch the "Products" table for new rows with a video URL.

Node 2: Prepare data (Code node)

const product = $input.first().json;
const platforms = [
  { name: "tiktok_shop", w: 1080, h: 1920, maxDuration: 60 },
  { name: "instagram_reels", w: 1080, h: 1920, maxDuration: 90 },
  { name: "instagram_feed", w: 1080, h: 1080, maxDuration: 60 },
  { name: "facebook_feed", w: 1280, h: 720, maxDuration: null },
  { name: "website", w: 1920, h: 1080, maxDuration: null }
];

return platforms.map(p => ({
  json: {
    sku: product.sku,
    productName: product.product_name,
    videoUrl: product.video_url,
    platform: p.name,
    width: p.w,
    height: p.h,
    maxDuration: p.maxDuration,
    outputName: `${product.sku}_${p.name}.mp4`
  }
}));

This creates 5 items per product, one for each platform.

Phase 2: Platform-specific processing

Node 3: Split in Batches (size: 3)

Node 4: Build FFmpeg command (Code node)

const item = $input.first().json;
let command;

// Base resize command
let vf = `scale=${item.width}:${item.height}:force_original_aspect_ratio=decrease,pad=${item.width}:${item.height}:(ow-iw)/2:(oh-ih)/2:white`;

// Duration limit
let durationFlag = '';
if (item.maxDuration) {
  durationFlag = `-t ${item.maxDuration}`;
}

command = `-i {{in_video}} ${durationFlag} -vf "${vf}" -c:v libx264 -crf 22 -preset fast -c:a aac -b:a 128k -movflags +faststart {{out_video}}`;

return [{
  json: {
    ...item,
    ffmpegCommand: command
  }
}];

Note: pad=...white uses white background instead of black. For product videos, white padding looks more professional and matches most e-commerce aesthetics.

Node 5: Submit to RenderIO (HTTP Request)

{
  "ffmpeg_command": "{{ $json.ffmpegCommand }}",
  "input_files": { "in_video": "{{ $json.videoUrl }}" },
  "output_files": { "out_video": "{{ $json.outputName }}" }
}

Nodes 6-8: Poll for completion

Phase 3: Brand watermark

After resizing, add your brand watermark. This runs as a second processing step on each output.

Node 9: Submit watermark (HTTP Request)

{
  "ffmpeg_command": "-i {{in_video}} -i {{logo}} -filter_complex \"[1:v]scale=80:-1,format=rgba,colorchannelmixer=aa=0.4[wm];[0:v][wm]overlay=W-w-15:H-h-15\" -c:v libx264 -crf 22 -c:a copy {{out_output}}",
  "input_files": {
    "in_video": "{{ $json.output_files.out_video.storage_url }}",
    "logo": "https://your-cdn.com/brand-logo.png"
  },
  "output_files": {
    "out_output": "branded_{{ $json.outputName }}"
  }
}

For product videos, a small, semi-transparent logo (40% opacity, 80px wide) in the bottom-right corner is standard.

Nodes 10-12: Poll for completion

Phase 4: Store and catalog

Node 13: Update product catalog

Write the output URLs back to your catalog:

Airtable update:

{
  "sku": "{{ $json.sku }}",
  "tiktok_video": "{{ $json.tiktokUrl }}",
  "instagram_reels_video": "{{ $json.instagramReelsUrl }}",
  "instagram_feed_video": "{{ $json.instagramFeedUrl }}",
  "facebook_video": "{{ $json.facebookUrl }}",
  "website_video": "{{ $json.websiteUrl }}"
}

Or Google Sheets:

Batch processing entire catalogs

For the initial setup, you need to process your entire catalog. Here's the batch approach:

Node 1: Schedule Trigger (run once, or nightly for new products)

Node 2: Fetch all products needing processing

// Fetch from Airtable with filter: video_processed = false
const products = $input.all();

return products.filter(p => !p.json.video_processed).map(p => ({
  json: p.json
}));

Node 3: Split in Batches (size: 1 product at a time)

Each product generates 5 platform items. Processing 1 product at a time means 5 concurrent platform renders. This keeps the workflow manageable.

Nodes 4+: Full processing pipeline per product

For a 200-product catalog at 5 platforms each (1,000 videos), expect:

• Processing time: 2-4 hours (depending on video lengths)

• API cost: ~500-1,000 processing minutes

Handling different product video types

Not all product videos are the same. Handle variations:

Short clips (under 15s): Loop to meet minimum platform duration.

-stream_loop 3 -i {{in_video}} -t 15 -c:v libx264 -crf 22 {{out_video}}

This loops the video 3 times and trims to 15 seconds.

Long videos (over 60s for TikTok): Trim to the platform limit.

-i {{in_video}} -t 60 -c:v libx264 -crf 22 {{out_video}}

Videos with no audio: Add silence so platforms don't reject them.

-i {{in_video}} -f lavfi -i anullsrc=r=44100:cl=stereo -c:v libx264 -c:a aac -shortest {{out_video}}

Build these as conditional branches in your Code node based on product video metadata.

Optimization tips

Combine resize + watermark in one step: Instead of two API calls (resize, then watermark), combine into one FFmpeg command:

-i {video} -i {logo} -filter_complex "[0:v]scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2:white[bg];[1:v]scale=80:-1,format=rgba,colorchannelmixer=aa=0.4[wm];[bg][wm]overlay=W-w-15:H-h-15" -c:v libx264 -crf 22 -c:a aac {output}

One API call instead of two. Half the processing time and cost.

Process by priority: Process TikTok and Instagram versions first (highest traffic), then Facebook and website versions.

Reuse resized base: If TikTok and Instagram Reels use the same dimensions (1080x1920), process once and duplicate the result URL.

Error recovery

For catalog-scale processing, some videos will fail. Build recovery:

1. Log all failures to a separate "Errors" sheet

2. Run a retry workflow daily that reprocesses failed items

3. Alert if failure rate exceeds 5%

IF: Status = "failed"
  → Write to Errors sheet (SKU, platform, error message, attempt count)
  → Continue to next product

Get started

1. Sign up at renderio.dev

2. Start with 5 products and 2 platforms

3. Verify output quality

4. Scale to full catalog

The Growth plan at $29/mo covers 1,000 commands. For more e-commerce workflows, see our video automation API.