Resources · Make integration

FFmpeg Micro Make integrationAutomate FFmpeg Micro with Make.

Media jobs that start and finish without you babysitting them. The FFmpeg Micro Make integration gives you 13 modules: one trigger, ten actions and two searches. This guide explains each one in plain words, then walks you through a first scenario you can test.

Try the FFmpeg Micro integration on MakeSee the 13 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the FFmpeg Micro Make integration automate?

The FFmpeg Micro Make integration lets Make start transcode and transcribe jobs in FFmpeg Micro, follow them, and pick up the result links, all without writing code. You build a scenario (the automation itself, a chain of modules), and each module is one brick of it: a trigger, an action or a search.

Hand off finished files automatically. Put Watch completed jobs at the start of a scenario, then Get a download URL so the next app in the chain receives a link instead of waiting for someone to copy it by hand.

Launch a job the moment a file shows up. A scenario can send a file with Upload a file, then start processing with Create a transcode job or Create a transcribe job. Add Wait for a transcode job right after if the following step needs the finished output inside the same run.

Keep an eye on what is running. List transcode jobs and List transcribe jobs are searches: they can return zero, one or many jobs, each one a bundle (an item passed to the next module). Handy for a status report sent to your team chat.

One honest limit: Make's own documentation for FFmpeg Micro is thin. It lists the modules without describing them, so field names and formats are something you discover inside the editor, not on this page. When a listed module falls short, Make an API call reaches any endpoint of the FFmpeg Micro API with the same connection. Still weighing tools? Our n8n vs Make comparison lays out the criteria, the Make pricing guide explains operations, and the Make training covers scenario building from scratch.

Connect

How do you connect FFmpeg Micro to Make?

  1. 01

    Add an FFmpeg Micro module

    In your scenario, click the +, search for FFmpeg Micro and pick any module. Then click Create a connection. A connection is your FFmpeg Micro account linked to Make once, then reused by every FFmpeg Micro module you add later.

  2. 02

    Name it and authorize

    Give the connection a name if you like, something that tells you which account it points to. Then follow what Make asks for: either an authorization page from FFmpeg Micro, or a key that FFmpeg Micro gives you, which you paste into the field.

  3. 03

    Save and check the fields

    Click Save. Once the connection exists, Make can fill in the lists it is able to read from your account, so the module fields become easier to complete. If the fields stay empty, the connection is the first thing to recheck.

First scenario

Your first scenario with FFmpeg Micro

GoalWhen a job finishes in FFmpeg Micro, Make fetches a download URL for its result and passes it on.

  1. 01

    Create the scenario

    Open the Scenarios page, create a new scenario and click the big +. This first module decides when the whole automation starts, so it will be the trigger.

  2. 02

    Add Watch completed jobs

    Search for FFmpeg Micro, choose Watch completed jobs and pick your connection, or click Create a connection if this is your first FFmpeg Micro module.

  3. 03

    Chain Get a download URL

    Click the + on the right of the trigger and add Get a download URL. Map the job coming from the trigger into its fields, so Make asks for the link of that exact job. If it was a transcribe job, pick Get a transcription download URL instead.

  4. 04

    Test with Run once

    Finish a job in FFmpeg Micro, then click Run once. Open the bubble above each module to read the bundles it received. No bundle on the trigger usually means no job has completed since you set it up.

  5. 05

    Schedule and switch on

    Click the clock on the trigger to set how often Make checks. A new scenario runs every 15 minutes by default, and 15 minutes is also the shortest gap on the Free plan. Then switch the scenario on.

Triggers

What starts an FFmpeg Micro scenario

1 module starts a scenario when something happens in FFmpeg Micro. A scheduled trigger is checked by Make on the scenario's schedule; an instant one is called by FFmpeg Micro as soon as it happens.

FFmpeg Micro1Watch completed jobs

Watch completed jobs

triggerIn the docs only

You get a scenario that picks up FFmpeg Micro jobs once they are done, so the rest of your chain can work on finished output instead of half-baked files. Make lists this trigger without a description, so its name is the best guide to what it returns.

How it fires
it is a scheduled trigger, so Make checks FFmpeg Micro on the scenario's schedule (the clock badge on the module), every 15 minutes by default, down to 1 minute on paid plans.
When to use it
when jobs are started from several places, including outside Make, and you want one scenario to deliver or log every result.
Watch out
a job that finishes just after a check is only picked up at the next one, so plan for that delay.
Modules

Everything FFmpeg Micro can do in Make

FFmpeg Micro gives you 12 modules. For each one: what it does for you, when to reach for it, and what to watch out for.

FFmpeg Micro1

Create a transcode job

ActionIn the docs only

Starts a transcode job in FFmpeg Micro from your scenario, so converting a media file no longer needs someone to launch it by hand. The job then runs on the FFmpeg Micro side.

When to use it
right after a file lands in your system and needs a new format before it reaches the next tool.
Watch out
the module only starts the job; pair it with a wait or a check before using the output.
FFmpeg Micro2

Create a transcribe job

ActionIn the docs only

Hands an audio or video file to FFmpeg Micro for transcription, and your scenario moves on while the text is being produced. Good ground for turning recorded calls or interviews into something searchable.

When to use it
when a new recording arrives and your team wants its text without asking anyone.
Watch out
the transcript is not ready when this module ends; fetch it later with the transcription modules.
FFmpeg Micro3

Get a download URL

ActionIn the docs only

Gives you a link to the result of a job, ready to send to a storage app, an email or a chat message. It is the piece that turns a finished job into something people can actually open.

When to use it
after a transcode job has completed, whether you learned it from the trigger or from a wait module.
Watch out
for transcripts, Get a transcription download URL is the sibling to pick instead.
FFmpeg Micro4

Get a transcode job

ActionIn the docs only

Reads one transcode job so your scenario knows where it stands. Useful when you already hold a job reference and only need its details, not a list of every job on the account.

When to use it
in a follow-up scenario that receives a job reference from another app and must decide what to do next.
Watch out
it looks the job up once and does not wait; use Wait for a transcode job to pause until it ends.
FFmpeg Micro5

Get a transcribe job

ActionIn the docs only

Fetches the details of a single transcribe job, which lets a scenario branch on its state before sending anything to your team. One call, one job, no searching involved.

When to use it
when a form or a spreadsheet row carries the job reference and you need to check it before a reply goes out.
Watch out
field names are not documented by Make, so run the module once and read the bundle before mapping.
FFmpeg Micro6

Get a transcription download URL

ActionIn the docs only

Returns a link to the text produced by a transcribe job, so the transcript can travel to a document, a CRM note or a support ticket. It closes the loop opened by Create a transcribe job.

When to use it
once the transcribe job is finished and someone downstream needs the file.
Watch out
call it on a finished job; on one still running there is nothing to hand over yet.
FFmpeg Micro7

List transcode jobs

SearchIn the docs only

Pulls the transcode jobs from your account in one go, which is the easiest way to build an overview or a clean-up routine. As a search, it can return zero, one or many bundles.

When to use it
for a status summary sent to your team, or to spot jobs that never completed.
Watch out
each returned job flows through the next modules as its own bundle, and each module run counts as an operation (one execution Make bills on your plan).
FFmpeg Micro8

List transcribe jobs

SearchIn the docs only

Gives you every transcribe job the account can see, handy when you need to reconcile what was sent for transcription with what came back. Zero results is a valid answer, not an error.

When to use it
when a project wraps up and you want a record of every recording processed for it.
Watch out
add a filter after the search if only part of the jobs matter, so later modules do not burn operations on the rest.
FFmpeg Micro9

Make an API call

ActionIn the docs only

Lets you call any endpoint of the FFmpeg Micro API from the scenario, reusing the connection you already created. It is the escape hatch when the listed modules stop short of what you need.

When to use it
when the FFmpeg Micro API offers an option that none of the twelve other modules exposes.
Watch out
you write the request yourself, so keep the FFmpeg Micro API reference open, since Make does not document it.
FFmpeg Micro10

Upload a file

ActionIn the docs only

Sends a file from your scenario to FFmpeg Micro, which is usually the first move before any processing. The file can come from an earlier module, such as a storage app or an email attachment.

When to use it
when the source media lives in another tool and FFmpeg Micro has never seen it.
Watch out
on the Make Free plan, files over 5 MB exceed the limit, and data transfer is capped at 512 MB.
FFmpeg Micro11

Wait for a transcode job

ActionIn the docs only

Holds the scenario until a transcode job has ended, so the next module works on a finished file. It saves you from building a second scenario only to catch the result.

When to use it
in a single chain that uploads, transcodes, then delivers, all in one run.
Watch out
a run is capped at 5 minutes on the Free plan and 40 on paid plans, so a long job may outlast the wait; Watch completed jobs is the safer route then.
FFmpeg Micro12

Wait for a transcribe job

ActionIn the docs only

Pauses the run until the transcript is done, then lets the flow continue with a completed job in hand. Your scenario reads top to bottom, with no second automation to maintain.

When to use it
when a short recording goes in and its text must reach a document before the scenario ends.
Watch out
the same execution time caps apply here, 5 minutes on Free and 40 on paid plans, so long recordings fit the trigger better.
Need help

Need help automating FFmpeg Micro with Make?

A person reads every message.

FAQ

FFmpeg Micro and Make: common questions

01Is the FFmpeg Micro Make integration free?
Yes, on the Make side. FFmpeg Micro is a standard app, available from the Free plan. That plan allows 2 active scenarios, a 15 minute minimum between scheduled runs, runs of 5 minutes at most, files up to 5 MB and 512 MB of data transfer. Paid plans lower the interval to 1 minute and allow 40 minutes per run. Make counts usage in operations, one per module execution. Your FFmpeg Micro account and its own terms are separate from Make.
02What do you need to connect FFmpeg Micro to Make?
An FFmpeg Micro account and a Make account. Make's documentation lists no specific prerequisite and no dedicated connection steps for this app, so the generic flow applies: add any FFmpeg Micro module, click Create a connection, optionally name it, then either authorize Make on the FFmpeg Micro page or paste the key FFmpeg Micro provides, and click Save. The same connection then serves all 13 modules, including Make an API call.
03Does the FFmpeg Micro trigger in Make fire instantly?
No. Watch completed jobs is a scheduled trigger: Make checks FFmpeg Micro on the scenario's schedule rather than being notified by the app. A new scenario checks every 15 minutes by default, which is also the minimum on the Free plan, while paid plans go down to 1 minute. If you need the next step to follow a job closely, start the job and add a Wait for a transcode job or Wait for a transcribe job module in the same scenario.
04What if an FFmpeg Micro module is missing in Make?
Use Make an API call. It reaches any endpoint of the FFmpeg Micro API with the connection you already have, so an option missing from the other twelve modules is still within reach. Keep in mind that Make's documentation for FFmpeg Micro is limited: it lists modules without describing them. The FFmpeg Micro API reference is the place to read which requests exist, and a Run once test shows what each module actually returns.
05Should you use Make or n8n with FFmpeg Micro?
It depends on the tool your team already runs. On Make, FFmpeg Micro comes with 13 ready modules, a scheduled trigger for finished jobs and Make an API call for everything else, all usable from the Free plan. Apps like this one often have an n8n node too, so check what n8n offers for FFmpeg Micro before deciding. Compare the modules each side gives you for your exact scenario rather than picking on reputation.
Same platform

Other docs you might need on this stack.

Browse all integrations