Zapier Video Processing with RenderIO's FFmpeg API

February 14, 2026 · RenderIO

Zapier can't process video. Here's how to add it.

Zapier connects 6,000+ apps. It can trigger on a new file in Google Drive, send emails, update spreadsheets, post to Slack. But it can't touch video.

It can't resize, convert formats, or compress. The moment your workflow needs to transform a video file, Zapier stops being useful, unless you add an FFmpeg API.

RenderIO gives Zapier the missing video processing step. Any FFmpeg command, triggered by any Zapier event, with results delivered anywhere. No custom Zapier app needed, just HTTP requests through the built-in Webhooks action.

How the integration works

The pattern uses Zapier's "Webhooks by Zapier" action to talk to RenderIO's API:

  1. Trigger: Any Zapier trigger (new file, form submission, email, etc.)

  2. Action: Webhooks sends a POST request to RenderIO

  3. Wait: Delay step while RenderIO processes the video

  4. Check: Webhooks GET request checks processing status

  5. Use: Pass the processed video URL to the next step

You don't need custom code or a Zapier developer account. Just webhook configuration.

Step-by-step setup

Step 1: Get your RenderIO API key

  1. Sign up at renderio.dev

  2. Go to Dashboard → API Keys

  3. Create a new API key (starts with ffsk_)

Plans start at $9/mo for 500 commands.

Step 2: Create the Zap trigger

Choose any trigger that provides a video file URL:

  • Google Drive: New file in folder

  • Dropbox: New file in folder

  • Email by Zapier: New email with attachment

  • Typeform: New form submission with file upload

  • Webhook: Custom webhook from your app

The trigger must provide a publicly accessible URL to the video file. If your source is Google Drive, set the file sharing to "Anyone with the link." For private files, you'll need a pre-signed URL.

Step 3: Add the RenderIO API call

Add a "Webhooks by Zapier" action:

  • Action Event: POST

  • URL: https://renderio.dev/api/v1/run-ffmpeg-command

  • Payload Type: JSON

  • Headers:

    • X-API-KEY: your API key

    • Content-Type: application/json

Data:

{
  "ffmpeg_command": "-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 -b:a 128k -movflags +faststart {{out_video}}",
  "input_files": {
    "in_video": "{{trigger_file_url}}"
  },
  "output_files": {
    "out_video": "processed.mp4"
  }
}

Replace {{trigger_file_url}} with the actual field from your trigger step.

Step 4: Add a delay

Add a "Delay by Zapier" step. Start with 30 seconds for short videos (under 30 seconds of source material). For 1-5 minute videos, use 60-90 seconds. For longer videos, you'll want the polling pattern described later.

The delay is a rough approach. RenderIO also supports webhook callbacks (more on that below).

Step 5: Check the result

Add another "Webhooks by Zapier" action:

  • Action Event: GET

  • URL: https://renderio.dev/api/v1/commands/{{command_id}}

  • Headers:

    • X-API-KEY: your API key

The {{command_id}} comes from the Step 3 response.

Step 6: Use the result

The GET response includes the output file URL when processing is complete. Use this URL in subsequent Zapier steps:

  • Upload to Google Drive

  • Send via email

  • Post to Slack

  • Upload to a social media scheduling tool

  • Store in your CMS

Common video processing Zaps

Convert video format

Trigger: New MOV file uploaded to Dropbox Action: Convert to MP4

{
  "ffmpeg_command": "-i {{in_video}} -c:v libx264 -crf 20 -c:a aac -b:a 128k -movflags +faststart {{out_video}}",
  "input_files": { "in_video": "{{dropbox_file_url}}" },
  "output_files": { "out_video": "converted.mp4" }
}

This takes any input format FFmpeg supports (MOV, AVI, MKV, WebM) and outputs a web-ready MP4. The -movflags +faststart flag moves the metadata to the beginning of the file so it starts playing before the full download finishes. For more format conversion options, the FFmpeg cheat sheet has 50+ command examples.

Resize for TikTok

Trigger: New video in Google Drive "Raw Videos" folder Action: Resize to 1080x1920

{
  "ffmpeg_command": "-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}}",
  "input_files": { "in_video": "{{drive_file_url}}" },
  "output_files": { "out_video": "tiktok-ready.mp4" }
}

The pad filter adds black bars if the aspect ratio doesn't match 9:16. For blurred-background letterboxing instead of black bars, the video compression guide covers more creative scaling approaches.

Compress video

Trigger: New large video file (over 100MB) Action: Compress to web-friendly size

{
  "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": "{{file_url}}" },
  "output_files": { "out_video": "compressed.mp4" }
}

CRF 28 is fairly aggressive compression. Good for previews and sharing, not for final delivery. CRF 20-22 is a better balance between file size and quality. The -preset slow flag takes longer but produces smaller files at the same quality.

Extract audio

Trigger: New video uploaded Action: Extract audio as MP3

{
  "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" }
}

Add watermark

Trigger: New video approved in project management tool Action: Add company logo

{
  "ffmpeg_command": "-i {{in_video}} -i {{in_logo}} -filter_complex \"[1:v]scale=100:-1,format=rgba,colorchannelmixer=aa=0.4[logo];[0:v][logo]overlay=W-w-20:20[v]\" -map \"[v]\" -map 0:a -c:v libx264 -crf 20 -c:a copy {{out_video}}",
  "input_files": {
    "in_video": "{{file_url}}",
    "in_logo": "https://yourbrand.com/logo.png"
  },
  "output_files": { "out_video": "watermarked.mp4" }
}

The colorchannelmixer=aa=0.4 sets the logo to 40% opacity. Adjust the overlay position (W-w-20:20 = 20px from right, 20px from top) for different placements. The watermark guide has more positioning examples including animated watermarks. For trimming video before watermarking, you can chain both operations in a single command.

Multi-step Zap: process + upload + notify

Here's a complete 6-step Zap that converts a client video, uploads it to Google Drive, and notifies the team:

  1. Trigger: New file in Dropbox "Client Uploads" folder

  2. Filter: Only continue if filename ends with .mov, .avi, or .mkv

  3. Webhooks POST: Submit to RenderIO (convert to MP4, resize to 1080p)

  4. Delay: 60 seconds

  5. Webhooks GET: Check processing status

  6. Paths:

    • Path A (completed): Upload output URL to Google Drive "Processed" folder → Send Slack message with link

    • Path B (failed/processing): Send error notification to Slack

The Paths step handles both success and failure. Most failures are caused by inaccessible input URLs (expired sharing links, wrong permissions) or invalid FFmpeg syntax. Check the error message in the API response, which includes FFmpeg's stderr output.

Handling longer processing times

For videos over 60 seconds or complex filter chains, a fixed delay won't cut it. Two approaches:

Polling pattern

  1. Webhooks POST: Submit to RenderIO

  2. Delay: 15 seconds

  3. Webhooks GET: Check status

  4. Filter: If status is NOT "completed", use Zapier's Looping feature to go back to step 2

  5. Continue: When status is "SUCCESS"

This adds Zapier tasks to your usage (each loop iteration is a task), but guarantees you don't miss the completion.

Webhook callback (better approach)

Configure RenderIO to POST to a Zapier webhook URL when processing completes. This eliminates polling entirely:

  1. Create a "Webhooks by Zapier" trigger (this gives you a URL)

  2. In your submit step, include "webhook_url": "https://hooks.zapier.com/hooks/catch/YOUR_ID" in the request body

  3. When processing finishes, RenderIO POSTs the result to your Zap

  4. Continue with the output URL

No delays, no polling, no wasted Zapier tasks.

Debugging common failures

"Input file not accessible": The URL returned 403 or 404. Google Drive files need "Anyone with the link" sharing. Dropbox links need ?dl=1 appended. S3 URLs need to be pre-signed or public.

"Invalid FFmpeg command": Usually a quoting issue. Zapier's JSON editor sometimes mangles escaped quotes in the ffmpeg_command string. Test your command locally first: ffmpeg -i input.mp4 [your filters] output.mp4.

Status stuck on "processing": RenderIO has internal timeouts for very long jobs. Check the status endpoint. If it's been more than 10 minutes for a short video, the job likely failed silently. Re-submit.

Zapier timeout: Zapier's Webhooks action has a 30-second response timeout. RenderIO's submit endpoint responds immediately with a command_id (well within 30 seconds). The GET status endpoint also responds immediately. If you're hitting timeouts, the issue is likely DNS or network, not processing time.

Zapier vs Make for video processing

Zapier isn't the only automation platform. Make (formerly Integromat) has a more visual builder and handles branching better. For video processing:

  • Zapier is simpler for linear workflows (trigger → process → upload). The webhook action is straightforward.

  • Make has built-in HTTP modules that handle response parsing more cleanly. Its scenario structure makes polling loops more natural.

  • Both work fine with RenderIO's API since it's standard REST.

If you're already on Zapier, stay on Zapier. If you're choosing fresh, Make's scenario builder is better for complex multi-step video pipelines. Both cost about the same for equivalent workflows. The FFmpeg as a service model works with any automation platform that can make HTTP requests.

Pricing

PlanCommands/monthCostOverage
Starter500$9/mo$0.08/cmd
Growth1,000$29/mo$0.05/cmd
Business20,000$99/mo$0.02/cmd

Most Zapier users process 50-500 videos per month. The Starter plan covers light usage. Growth covers most automated workflows. Zero egress fees on all plans.

FAQ

Can Zapier handle large video files?

Zapier itself doesn't handle the video. It just passes the URL to RenderIO. File size limits depend on your RenderIO plan and the source hosting. Files up to 5GB work fine. The bottleneck is usually the input URL speed, not size.

What happens if processing takes longer than the delay step?

Your GET status check returns "processing" instead of "completed". Without a polling loop, the Zap continues with incomplete data. Use either the polling pattern or webhook callbacks described above to handle this reliably.

Can I chain multiple FFmpeg operations in one Zap step?

Yes. FFmpeg supports complex filter chains in a single command. Instead of separate steps for resize + watermark + compress, combine them: -vf "scale=1080:-2,overlay..." -c:v libx264 -crf 22. One API call, one Zap step, one processed output.

Do I need a paid Zapier plan?

The Webhooks action requires a paid Zapier plan (Starter or higher). Free Zapier accounts don't have access to the Webhooks by Zapier action. You need at minimum a Zapier Starter plan (19.99/mo)plusaRenderIOplan(19.99/mo) plus a RenderIO plan (9/mo).

Can I use this with Zapier's new AI features?

Zapier's AI actions (like "Generate Text with AI") work alongside video processing steps. You could generate a video title with AI, then watermark that title onto the video in the same Zap. The AI step outputs text, which you embed into the FFmpeg command's drawtext filter.