Batch Video Processing with Zapier + RenderIO

Processing one video in Zapier is easy. Processing 50 requires a pattern.

The basic Zap handles one video: trigger, process, save. But real workflows deal with batches. A creator uploads 20 clips. A client sends 15 raw files. A folder accumulates 50 videos over a week.

Zapier can batch process videos with the right setup. This guide covers loops, error handling, rate limits, and practical patterns for processing multiple videos reliably. If you're new to Zapier + video, the Zapier video processing setup guide covers the basic webhook integration first.

The batch processing pattern

Zapier doesn't have native batch processing for webhooks. But it has two approaches:

1. One-at-a-time triggers: Process each video as it arrives (simplest)

2. Scheduled batch: Run a scheduled Zap that processes all new files at once

Approach 1: One-at-a-time

Each new file triggers a separate Zap run. This is the simplest and most reliable:

1. Trigger: New File in Google Drive folder

2. Webhooks POST: Send to RenderIO

3. Delay: 45 seconds

4. Webhooks GET: Check status

5. Save result

Zapier handles 20 files uploaded simultaneously because each gets its own Zap run. No loop needed.

The downside: if you upload 100 files at once, you'll use 100 Zap runs. On Zapier's Starter plan (750 tasks/month), this consumes tasks quickly.

Approach 2: Scheduled batch

Process all accumulated files on a schedule:

1. Trigger: Schedule by Zapier (every hour, daily, etc.)

2. Google Drive: Find Files in Folder (returns all new files)

3. Looping by Zapier: Loop through each file

4. Webhooks POST: Send each to RenderIO

5. Delay: 30 seconds per file

6. Webhooks GET: Check each status

7. Move file: Move processed file to "Done" folder

This uses fewer Zap tasks because one trigger handles multiple files.

Handling errors with Zapier Paths

Video processing can fail. The file might be corrupted, the format unsupported, or the URL expired. Handle this with Paths:

After the status check step, add Paths:

Path A: Success

• Rule: Status equals "SUCCESS"

• Actions: Download output, save to folder, notify team

Path B: Still processing

• Rule: Status equals "processing"

• Actions: Add another delay (30 seconds), check status again

• Use a Zapier Looping step to retry up to 5 times

Path C: Failed

• Rule: Status equals "FAILED"

• Actions: Send error notification to Slack, log to Google Sheet

Check Status → Path A (completed) → Save result
             → Path B (processing) → Delay → Re-check
             → Path C (failed) → Notify team

Rate limit management

RenderIO handles concurrent requests well, but Zapier's webhook steps have their own limits. Best practices:

Space out requests

If processing a large batch, add small delays between submissions:

1. Loop start

2. Webhooks POST: Submit video to RenderIO

3. Delay: 5 seconds (spacing between submissions)

4. Loop end

5. Delay: 60 seconds (wait for all to process)

6. Loop start

7. Webhooks GET: Check each status

8. Loop end

Submit all, then check all

Instead of submit-wait-check for each video sequentially, submit everything first, wait once, then check everything:

Submit video 1 → Submit video 2 → Submit video 3
                    ↓
              Wait 60 seconds
                    ↓
Check video 1 → Check video 2 → Check video 3

This is faster because all videos process in parallel on RenderIO while you wait once.

Practical batch workflow: Weekly content processing

A content team processes raw footage every Monday:

Zap configuration

1. Trigger: Schedule - Every Monday at 9 AM

2. Google Drive: Find Files in "This Week's Raw" folder

3. Code by Zapier (JavaScript):

const files = inputData.files.split(",");
return { fileCount: files.length, files: files };

4. Looping by Zapier: For each file URL:

5. Webhooks POST (inside loop):

{
  "ffmpeg_command": "-i {{in_video}} -vf \"scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2:black\" -af \"loudnorm=I=-14\" -c:v libx264 -crf 22 -c:a aac -b:a 128k -movflags +faststart {{out_video}}",
  "input_files": { "in_video": "{{loop_item}}" },
  "output_files": { "out_video": "processed-{{loop_index}}.mp4" }
}

6. Delay: 5 seconds (between submissions)

7. End loop

8. Delay: 90 seconds (processing time)

9. Looping by Zapier: For each command_id from step 5:

10. Webhooks GET (inside loop): URL: https://renderio.dev/api/v1/commands/{{command_id}}

11. Google Drive: Upload result to "Processed" folder

12. End loop

13. Slack: "Processed videos for this week"

Processing videos with different settings

Use Zapier's Formatter or Code step to apply different FFmpeg commands based on file attributes:

// Code by Zapier
const filename = inputData.filename.toLowerCase();
let ffmpegCommand;

if (filename.includes("tiktok")) {
  ffmpegCommand = '-i {{in_video}} -vf "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2:black" -c:v libx264 -crf 22 -c:a aac -movflags +faststart {{out_video}}';
} else if (filename.includes("youtube")) {
  ffmpegCommand = '-i {{in_video}} -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2:black" -c:v libx264 -crf 20 -c:a aac -movflags +faststart {{out_video}}';
} else {
  // Default: compress only
  ffmpegCommand = '-i {{in_video}} -c:v libx264 -crf 24 -c:a aac -movflags +faststart {{out_video}}';
}

return { ffmpegCommand };

Monitoring batch progress

Track batch processing with a Google Sheets log:

After each video processes, add a row:

This gives you a audit trail and helps debug failures.

Cost considerations

RenderIO's Starter plan at $9/month handles up to 500 commands per month. For most Zapier batch workflows, the Growth plan at$29/month (1,000 commands) provides more than enough capacity. Zero egress fees on all plans.

Batch processing in Zapier works. You just need the right pattern. Submit in parallel, wait once, check results.