Resources · Make integration

Rendi - FFmpeg API Make integrationAutomate Rendi - FFmpeg API with Make.

Can Make send FFmpeg commands to Rendi for you? Yes. The Rendi - FFmpeg API Make integration gives you 2 action modules, and this guide walks you from the connection to a first working scenario, one plain step at a time.

Try the Rendi - FFmpeg API integration on MakeSee the 2 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What does the Rendi - FFmpeg API Make integration let you do?

The Rendi - FFmpeg API Make integration links your Rendi account to Make, the visual tool where you build a scenario (the automation itself, a chain of bricks called modules). Once linked, a scenario can run an FFmpeg command on Rendi, or call any other endpoint of the Rendi API, without you writing code.

Hand a file to Rendi once another tool has it. Another app opens the scenario with its own trigger, then Run FFmpeg Command takes the data it received and sends your command to Rendi. The command itself is yours to write, Make only carries it.

Reach the parts of the API that have no module. The app ships with just 2 modules. When the one you need is missing, Make an API Call reuses the same connection and calls whichever Rendi endpoint you name.

Chain Rendi with the rest of your stack. Every module in Make passes its output along as a bundle (one item, such as one file or one record), so the result from Rendi can feed the next module of any other app.

Be aware of the limits. Rendi has no trigger in Make, so something else has to start the scenario. The Make documentation for this app is also marked as limited: it names the two modules and little more. Before you build, the Make review gives you the big picture, and Make troubleshooting helps when a run fails. Weighing another tool? Read n8n vs Make.

Connect

How do you connect Rendi - FFmpeg API to Make?

  1. 01

    Add a Rendi module

    In your scenario, click the +, search for Rendi and pick one of its two modules. In the module panel, click Create a connection. This connection is your Rendi account linked to Make once, then reused by every Rendi module.

  2. 02

    Name it, then authorize

    Give the connection a name if you like, which helps when you run several accounts. Then follow the window Make opens: either you authorize Make on the Rendi page, or you paste the key Rendi gives you. The documentation does not say which method Rendi uses.

  3. 03

    Save and check

    Click Save. The connection now shows in the module's dropdown, and any Rendi module you add later can pick it without asking for your credentials again. If the save fails, go back to the credentials you entered first.

First scenario

Build your first scenario with Rendi - FFmpeg API

GoalWhen another app hands over new data, Make sends your FFmpeg command to Rendi with that data.

  1. 01

    Create the scenario

    Open the Scenarios page, create a new scenario and click the +. Rendi cannot start a scenario, so this first module comes from the app that holds your data, or you keep only a schedule.

  2. 02

    Add Run FFmpeg Command

    Click the + to the right of the first module, search for Rendi and choose Run FFmpeg Command. Select your connection, or click Create a connection if you skipped that part.

  3. 03

    Fill in and map the fields

    Fill in the module fields and drag in the data from the first module where your command needs it. Make shows what the previous module returns, so there is nothing to type from memory.

  4. 04

    Test with Run once

    Click Run once. Make runs the scenario a single time and shows, on each module, the bundles it received and sent back. Read what Rendi returned before going further.

  5. 05

    Schedule and switch on

    On the first module, set the schedule (every 15 minutes by default for a new scenario), then switch the scenario on. From there, Make runs it by itself.

Modules

What can the Rendi - FFmpeg API modules do?

Rendi - FFmpeg API gives you 2 modules. For each one: what it does for you, when to reach for it, and what to watch out for.

Rendi - FFmpeg API1

Make an API Call

ActionIn the docs only

This module gets you any part of the Rendi API that has no dedicated module, using the connection you already set up. You name the endpoint, Make sends the request and returns the response as a bundle.

When to use it
as soon as the job goes beyond running a command, for instance reading something back from Rendi after the command has been sent.
Watch out
the endpoints are not described in the Make documentation, so check them in the Rendi docs.
Rendi - FFmpeg API2

Run FFmpeg Command

ActionIn the docs only

Here is the core of the integration: you give Make an FFmpeg command and it passes it to Rendi, with the data mapped from earlier modules. You write the command, Rendi runs it, and your scenario carries on with the response.

When to use it
whenever the file or data from another app has to go through FFmpeg before moving on.
Watch out
test with Run once first, every time the module runs on a bundle, Make counts one operation on your plan.
Need help

Need help automating Rendi - FFmpeg API with Make?

A person reads every message.

FAQ

Rendi - FFmpeg API and Make: common questions

01Is the Rendi - FFmpeg API Make integration free?
Yes, on the Make side. Rendi - FFmpeg API is a standard app, so it works on the Free plan. That plan gives you 2 active scenarios, a minimum of 15 minutes between two scheduled runs, runs of 5 minutes at most, files up to 5 MB and 512 MB of data transfer. Paid plans (Core, Pro, Teams, Enterprise) lower the interval to one minute and allow 40 minutes per run. Make counts usage in operations, one per module run on one bundle. What Rendi itself charges is not covered here.
02What do you need to connect Rendi - FFmpeg API to Make?
A Rendi account and a Make account are enough to begin. The Make documentation lists no prerequisite for this app. You add a Rendi module, click Create a connection, name it if you want, then either authorize Make on the Rendi page or paste the key Rendi provides, and click Save. The documentation does not say which of the two methods applies, so follow the window Make opens. The connection is then reused by both Rendi modules.
03Does the Rendi - FFmpeg API Make integration react in real time?
No, because Rendi has no trigger in Make. The scenario has to start some other way. The first option is a trigger from another app: an instant one, which that app fires through a webhook as soon as something happens, or a scheduled one, which Make checks at intervals. The second option is the scenario schedule on its own, every 15 minutes by default, and never less than 15 minutes on the Free plan. Run FFmpeg Command then comes after that first module.
04What if the Rendi - FFmpeg API Make integration lacks a module?
Use Make an API Call. With just 2 modules, Rendi will often leave something uncovered, and this module calls any endpoint of the Rendi API with the connection you already have. The catch is that Make marks its documentation for this app as limited, so the endpoints and their parameters have to come from the Rendi documentation. Test every call with Run once before you switch the scenario on. Each call counts as one operation, like any other module.
05Should you pick Make or n8n for Rendi - FFmpeg API?
It depends on what you need around Rendi. On Make, the app offers Run FFmpeg Command and Make an API Call, with no trigger, and it is available from the Free plan. The same app often has an n8n node too, but nothing here confirms one for Rendi, so check the n8n catalogue before you decide. Base the choice on the other apps in your flow and on the editor your team prefers, then compare the two tools on a real case.
Same platform

Other docs you might need on this stack.

Browse all integrations