Automate Product Video Creation with Zapier

New product in Shopify. Video on TikTok Shop. No human in between.

Adding a product to your Shopify store should automatically create a TikTok Shop video. Not in a week when your editor gets to it. Immediately.

This Zap watches for new Shopify products, generates a product video from a template, processes it for TikTok, and stores it ready for upload. The entire flow runs without intervention. For the basic Zapier + RenderIO webhook setup, see the Zapier video processing guide.

Prerequisites

A video template: 1080x1920, 15 seconds, with space for product image and text. Create once in CapCut, Canva, or After Effects. Upload to a publicly accessible URL.
Shopify store: With products that have images.
RenderIO account: Starter plan at $9/month (500 commands/month).
Zapier account: Professional plan recommended for Code and Path steps.

The Zap

Step 1: Trigger — new product in Shopify

App: Shopify Event: New Product Connection: Your Shopify store

This fires when you create a new product. It provides the product title, price, description, and image URLs.

Step 2: Extract product data

App: Code by Zapier (JavaScript)

const title = inputData.title.replace(/[^a-zA-Z0-9 ]/g, "").replace(/ /g, "_");
const price = "$" + parseFloat(inputData.price).toFixed(2);
const image = inputData.imageUrl;

// Truncate title for FFmpeg overlay (max 30 chars)
const shortTitle = title.length > 30 ? title.substring(0, 27) + "..." : title;

return {
  safeTitle: shortTitle,
  price: price,
  imageUrl: image,
  sku: inputData.sku || title.toLowerCase().replace(/_/g, "-"),
};

Step 3: Generate product video

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_template}} -i {{in_product}} -filter_complex \"[1:v]scale=500:-1,format=rgba,fade=t=in:st=0.5:d=0.8:alpha=1[img];[0:v][img]overlay=(W-w)/2:350:enable='gte(t,0.5)',drawtext=text='{{safeTitle}}':fontsize=40:fontcolor=white:borderw=2:bordercolor=black:x=(w-text_w)/2:y=1200:enable='gte(t,1.2)',drawtext=text='{{price}}':fontsize=56:fontcolor=#00FF88:borderw=2:bordercolor=black:x=(w-text_w)/2:y=1320:enable='gte(t,1.8)',drawtext=text='Shop Now':fontsize=32:fontcolor=white:borderw=2:bordercolor=black:x=(w-text_w)/2:y=1500:enable='gte(t,3)'[v]\" -map \"[v]\" -map 0:a -c:v libx264 -crf 20 -c:a copy -movflags +faststart -t 15 {{out_video}}",
  "input_files": {
    "in_template": "https://storage.example.com/product-template-v1.mp4",
    "in_product": "{{imageUrl}}"
  },
  "output_files": {
    "out_video": "{{sku}}-tiktok.mp4"
  }
}

That's a dense command. Here's what each part does:

[1:v]scale=500:-1 — Scales the product image to 500px wide, keeping aspect ratio
fade=t=in:st=0.5:d=0.8:alpha=1 — Fades the image in starting at 0.5 seconds over 0.8 seconds
overlay=(W-w)/2:350 — Centers the image horizontally, places it 350px from the top
enable='gte(t,0.5)' — Only shows the overlay after 0.5 seconds (pairs with the fade)
drawtext=text='{{safeTitle}}' — Renders the product name at y=1200
drawtext=text='{{price}}' — Renders the price in green (#00FF88) at y=1320
drawtext=text='Shop Now' — CTA text appears at 3 seconds
borderw=2:bordercolor=black — Black text border for readability against any background
-t 15 — Caps the output at 15 seconds

The timing creates a reveal sequence: template plays → product image fades in → title appears → price appears → CTA appears. Each element is staggered by about 0.6 seconds.

Step 4: Wait for processing

App: Delay by Zapier Duration: 45 seconds

Why 45 seconds? Most product videos (short clips, simple overlays) process in 10-20 seconds. The 45-second buffer accounts for queue time during peak hours. If you're using longer templates (30+ seconds) or higher resolution inputs, increase this to 60-90 seconds.

The tradeoff: a shorter delay risks checking before the video is ready (and you'd need a retry path). A longer delay slows down the whole Zap but is more reliable. For production use, consider the webhook approach described below in the "Webhook alternative" section.

Step 5: Check result

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

Step 6: Handle result with Paths

Path A: Success

Rule: Status equals "SUCCESS"
Continue to Step 7

Path B: Failed

Rule: Status equals "FAILED"
Send email: "Failed to create video for product: "
Log to Google Sheet: SKU, title, error message, timestamp

Path C: Still processing

Rule: Status equals "processing"
Add another Delay (30 seconds) → Check status again
After 3 retries, fall through to the Failed path

Step 7: Save the video

App: Google Drive (or Dropbox, S3, etc.) Event: Upload File File URL: Folder: "Product Videos / TikTok" Filename: {{sku}}-tiktok.mp4

Step 8: Notify team

App: Slack Event: Send Channel Message Channel: #product-videos Message: "New product video created for (). Ready for TikTok Shop upload."

Webhook alternative (skip the delay)

The 45-second delay is the simplest approach, but it's wasteful. You're paying for a Zapier delay step and sometimes waiting longer than needed.

A better production setup uses two Zaps:

Zap 1 — Submit:

Shopify trigger → Extract data → Submit to RenderIO with webhook_url
The webhook_url points to Zap 2's webhook trigger
Done. No delay, no polling.

Zap 2 — Handle completion:

Webhook trigger receives the callback from RenderIO
Check status → Save to Google Drive → Notify Slack

This costs one extra Zap but eliminates the guessing game with delay timing. For stores adding more than a few products per day, it's worth the switch.

Adding variations

For each product, create 3 variations with different visual treatments. After Step 5 (status confirmed), add a loop:

// Code step — Generate 3 variation configs
const variations = [
  { suffix: "warm", vf: "colortemperature=temperature=6500,eq=saturation=1.1" },
  { suffix: "cool", vf: "colortemperature=temperature=4500,eq=saturation=0.95" },
  { suffix: "vivid", vf: "eq=saturation=1.3:contrast=1.05" },
];

return { variations: JSON.stringify(variations) };

Loop through each variation with a RenderIO API call:

{
  "ffmpeg_command": "-i {{in_video}} -vf \"{{variation_vf}}\" -c:v libx264 -crf 22 -c:a copy {{out_video}}",
  "input_files": { "in_video": "{{base_video_url}}" },
  "output_files": { "out_video": "{{sku}}-{{variation_suffix}}.mp4" }
}

Each product now has 4 videos: 1 base + 3 variations. The variations process from the already-generated base video, so they're fast (just a color filter, no overlay rendering).

Handling product updates

Create a second Zap for product updates:

Trigger: Updated Product in Shopify

When a product price changes or image updates, regenerate the video:

Trigger: Shopify — Updated Product
Filter: Only continue if price or image changed (compare with stored values in a Google Sheet or Airtable)
Delete old video: Remove from storage
Generate new video: Same process as the creation Zap
Update storage: Replace the old video file

This keeps your TikTok Shop videos in sync with your catalog. Price changes especially matter. You don't want a video showing " $29.99" when the product now costs "$ 24.99".

Template rotation

Avoid repetitive-looking videos by rotating templates:

// Code step — Select template based on product index or category
const templates = [
  "https://storage.example.com/template-gradient.mp4",
  "https://storage.example.com/template-lifestyle.mp4",
  "https://storage.example.com/template-minimal.mp4",
  "https://storage.example.com/template-bold.mp4",
];

// Use product ID to deterministically select template
const index = parseInt(inputData.productId) % templates.length;
return { templateUrl: templates[index] };

Four templates means consecutive products get different visual styles. The modulo approach is deterministic: the same product always gets the same template, so regenerating (after a price update, for example) produces a consistent look.

Troubleshooting

"Failed" status with no useful error: Check that your template URL and product image URL are publicly accessible. Try opening them in an incognito browser window. Private S3 buckets or Shopify admin URLs won't work. You need public or presigned URLs.

Video is blank or black: The overlay positioning is wrong for your template. The y=350 value assumes a 1920-tall video with product space in the upper third. Adjust the coordinates to match your template layout. Test with one product before enabling the Zap.

Text is cut off: The fontsize=40 works for titles up to about 25 characters. If your product names are longer (the code truncates at 30), reduce the font size or add line wrapping with drawtext's line_spacing option. Better yet, keep product names short in Shopify.

Delay times out but video isn't ready: Your template or input file is large. Increase the delay to 60-90 seconds, or switch to the webhook approach. Check the command status manually via curl to see actual processing times for your videos.

Zapier task limits: Each product uses 8-12 Zapier tasks depending on whether you create variations. At 50 products/month with 3 variations each, that's ~600 tasks. Factor this into your Zapier plan selection.

Complete workflow diagram

Shopify: New Product
    ↓
Code: Extract & format data
    ↓
Webhooks POST: RenderIO (generate video)
    ↓
Delay: 45 seconds
    ↓
Webhooks GET: Check status
    ↓
Paths: Success / Still Processing / Failed
    ↓ (Success)
Loop: Create 3 variations
    ↓
Save: Upload to Google Drive
    ↓
Slack: Notify team

Scaling considerations

Products/month	Videos (with 3 variations)	API calls	Plan	Cost
10	40	40	Starter	$9/mo
50	200	200	Starter	$9/mo
200	800	800	Growth	$29/mo
500	2,000	2,000	Business	$99/mo

At 500 new products per month with 3 variations each, you're at 2,000 API calls. The Business plan handles that with room to spare.

The Zapier side adds up faster than the API side: each product uses 8-12 Zapier tasks depending on variations. Factor this into your Zapier plan selection.

For an alternative to Zapier with more flexibility (and no per-task pricing), see the n8n video processing guide. If you want to build the pipeline in code instead of a no-code tool, the FFmpeg API complete guide covers direct API integration.

Zapier FFmpeg integration — general FFmpeg operations in Zapier
Resize video for TikTok with Zapier — TikTok-specific formatting
E-commerce video processing API — building the pipeline in code
n8n video processing guide — same automation, different tool

FAQ

How much does this cost in Zapier tasks?

Each product creation uses 8-12 Zapier tasks: trigger (1) + extract data (1) + submit (1) + delay (1) + check status (1) + path (1) + save (1) + notify (1), plus 1 per variation if you create those. At 50 products/month with variations, budget for about 600 Zapier tasks.

Can I customize the video template?

Yes. The template is just an MP4 file with space for overlays. Create it in any video editor — CapCut, Canva, After Effects, even Keynote. The FFmpeg command positions the product image and text at fixed coordinates, so make sure your template has clear space at those positions (centered horizontally, y=350 for image, y=1200 for title, y=1320 for price).

What if the video processing fails?

The Paths step (Step 6) catches failures and sends an email notification with the product title. Common causes: inaccessible image URL, template URL expired, FFmpeg command syntax error. Check the error field in the API response for FFmpeg's stderr output, which usually tells you exactly what went wrong.

Can I use this for Instagram Reels too?

Yes. Add a second processing step that takes the TikTok video and resizes it for Reels (same 9:16, but you might want different text positioning or a different CTA). Or submit two commands in parallel — one for TikTok, one for Reels — with different filter chains. The Zapier resize video for TikTok guide covers platform-specific formatting.

How do I update videos when product details change?

Create a second Zap triggered by "Updated Product in Shopify." Add a filter to only continue if the price or image changed (compare with values stored in a Google Sheet). Then follow the same generation flow. Delete the old video from storage first to avoid cluttering your drive.