How to Process Video in Make.com with FFmpeg (No Module Required)

Originally published at ffmpeg-micro.com

Make.com doesn't have a native FFmpeg module. If you've searched for one, you already know this. The community forums are full of workarounds involving self-hosted servers, Docker containers, and duct-taped shell scripts.

There's a simpler path. You can call FFmpeg Micro's REST API directly from Make.com's HTTP module. No server to manage, no FFmpeg to install, no module to wait for.

This tutorial walks through a complete Make.com scenario: upload a video, transcode it to MP4, and download the result. You'll have a working video processing automation in about 15 minutes.

What You Need

• A Make.com account (free tier works)
• An FFmpeg Micro API key (grab one at ffmpeg-micro.com)
• A video file URL to process (any publicly accessible URL, or upload via the API)

Setting Up the Make.com Scenario

The scenario has four HTTP modules chained together. Each one calls a different FFmpeg Micro endpoint.

Step 1: Upload Your Video

FFmpeg Micro uses a three-step upload flow. First, request a presigned upload URL.

Add an HTTP > Make a request module with these settings:

• URL: https://api.ffmpeg-micro.com/v1/upload/presigned-url
• Method: POST
• Headers:
  • Authorization: Bearer YOUR_API_KEY
  • Content-Type: application/json
• Body type: Raw (JSON)
• Request content:

{
  "filename": "input-video.mp4",
  "contentType": "video/mp4",
  "fileSize": 10485760
}

The response gives you an uploadUrl and a filename. Map these to the next module.

Next, add a second HTTP module to PUT the file to that upload URL. Then add a third module to confirm the upload:

• URL: https://api.ffmpeg-micro.com/v1/upload/confirm
• Method: POST
• Headers: same Authorization and Content-Type
• Request content:

{
  "filename": "{{mapped filename from step 1}}",
  "fileSize": 10485760
}

The confirm response returns a fileUrl that points to your uploaded video. This is the URL you'll pass to the transcode step.

Already have a public video URL? Skip the upload entirely. If your video is hosted on S3, Cloudflare R2, or any CDN, you can pass that URL directly to the transcode endpoint.

Step 2: Transcode the Video

Add another HTTP module:

• URL: https://api.ffmpeg-micro.com/v1/transcodes
• Method: POST
• Headers:
  • Authorization: Bearer YOUR_API_KEY
  • Content-Type: application/json
• Body type: Raw (JSON)
• Request content:

{
  "inputs": [{"url": "{{fileUrl from upload confirm}}"}],
  "outputFormat": "mp4",
  "preset": {
    "quality": "high",
    "resolution": "1080p"
  }
}

This creates a transcode job and returns a jobId. The inputs field takes an array of objects, each with a url property. For most scenarios you'll pass one video, but the API supports up to 10 inputs for concatenation or multi-input workflows.

The preset field is the simple way to control output quality. Valid quality values are low, medium, and high. Resolution options: 480p, 720p, 1080p, 4k.

If you need more control, swap preset for options to pass raw FFmpeg flags:

{
  "inputs": [{"url": "{{fileUrl}}"}],
  "outputFormat": "webm",
  "options": [
    {"option": "-c:v", "argument": "libvpx-vp9"},
    {"option": "-crf", "argument": "30"},
    {"option": "-b:v", "argument": "0"}
  ]
}

Step 3: Poll for Completion

Video transcoding takes time. You need to check the job status before downloading.

Add a Repeater module (under Flow Control) set to repeat every 10 seconds, followed by an HTTP module:

• URL: https://api.ffmpeg-micro.com/v1/transcodes/{{jobId}}
• Method: GET
• Headers: same Authorization

Check the status field in the response. When it reads completed, break out of the loop.

In Make.com, you can add a Router after this module. One path continues to download (filtered on status = completed). The other path loops back to the repeater (filtered on status = processing or status = queued).

Step 4: Download the Result

Once the job completes, grab the output:

• URL: https://api.ffmpeg-micro.com/v1/transcodes/{{jobId}}/download
• Method: GET
• Headers: same Authorization

This returns a signed download URL. Add one more HTTP module to GET that URL and save the file wherever you need it: Google Drive, Dropbox, S3, or back into your Make.com workflow.

Common Make.com Scenarios

Once the basic flow works, you can trigger it from anything Make.com connects to:

• New file in Google Drive triggers transcode to MP4, saves the result back to a different folder
• New row in Google Sheets with a video URL kicks off batch processing
• Webhook from your app triggers video processing when users upload content
• Scheduled batch runs to process a queue of videos overnight

You can also convert between formats (MP4, WebM, MOV, AVI, MKV) or extract audio (MP3, WAV, AAC, FLAC) using the same transcode endpoint. Just change the outputFormat value.

Why Not Self-Host FFmpeg?

Make.com Cloud doesn't support running FFmpeg directly. You'd need a separate server (AWS EC2, DigitalOcean, etc.) running FFmpeg, then call that server from Make.com. That means managing infrastructure, handling scaling, dealing with FFmpeg updates, and paying for a server that sits idle between jobs.

FFmpeg Micro handles all of that. You pay per minute of video processed, and the infrastructure scales automatically. The HTTP module approach also means your entire automation lives inside Make.com where you can monitor, debug, and modify it without touching a server.

Get Started

Sign up at ffmpeg-micro.com to get your API key. The free tier includes enough processing minutes to build and test your Make.com scenario. Once it's working, the paid plans scale with your usage.

If you're already using the Make.com HTTP module for other APIs, this will feel familiar. The only difference is the polling step for job completion, and that's just a repeater with a filter.