Rendi

Rendi is FFmpeg as a service: send a command string and a map of file aliases, and Rendi runs it on its own infrastructure. Agents transcode, trim, concatenate, and probe media, chain commands, store and manage files, and react when a command finishes.

Verified 1 trigger 15 actions API key available

Rendi website Platform Documentation Capability data verified 2026-08-28

A source video lands in the pipeline needing a web master, a square cut, and a poster frame

Store File hands the source to Rendi and returns its probed duration, codec, dimensions, and frame rate

Agent checks the alias maps, because every input key and every output key has to carry the prefix the platform requires

Run Chained FFmpeg Commands runs all three passes in one shared alias space, reusing the machine and the already downloaded source

Get Command branches on the done and failed booleans and reads the error status when a pass fails

The pipeline owner gets the three outputs with the metadata Rendi probed from each

The pipeline owner approves the storage cleanup before any source file is removed

What This Integration Enables

Rendi is the escape hatch, and that is a compliment. Every other media connector gives you the transforms its product decided to expose. Rendi gives you FFmpeg: you send a command string and a map of file aliases, and it runs on the platform's infrastructure and hands back stored, probed output files. When the transform you need is a specific filter chain, an unusual container, a frame extracted at an exact timestamp, or a concatenation that no product API models, this is the connector that has it, without anyone on your team maintaining a machine to run it on.

FlowRunner agents run single commands, chain up to a small number of commands sharing one alias space, run and wait in a single step, store and probe files, drive multipart uploads for very large sources, and clean up outputs and stored files. Two design details are worth building around. Chaining is genuinely cheaper rather than merely faster, because the machine and the downloaded inputs are reused and one processing allocation is shared across the chain. And the vCPU setting is a concurrency control as much as a speed one, since commands only run in parallel while their combined allocation fits the account.

Without FlowRunner

Media transforms need a box A transcode or a trim means a machine somebody maintains, with FFmpeg installed and a queue in front of it

Every transform is a separate job Three passes over one source means downloading it three times and paying for three runs

Cleanup is guesswork Nobody is confident which stored files are still referenced, so nothing is ever deleted and storage only grows

With FlowRunner

Media transforms are a call The command string and the file aliases go out, and probed output files come back

Passes share a machine A chain reuses the downloaded inputs and one processing allocation, so several transforms cost less than the same transforms submitted apart

Cleanup is a reviewed decision The agent builds the deletion set, states what the listing cannot show it, and a person confirms before anything goes

Use Case Scenarios

One source, every derivative, one allocation

An approved cut lands from the editor. The agent calls Store File, which both hands the source to Rendi and runs the probe that returns duration, codec, dimensions, and frame rate, so the derivative sizes are chosen from real numbers rather than from an assumption. Run Chained FFmpeg Commands then produces the web master, the square social cut, and the poster frame in one chain, each command consuming the previous one's output by alias. The outputs go to Gumlet for delivery and the metadata row goes to Airtable. The source was downloaded once.

A transform nobody's product API offers

Legal needs the last eleven seconds removed from four hundred archived recordings, with the audio normalized and the container left alone. No product shaped API models that combination, and rebuilding an FFmpeg box for a one time job is not a good trade. The agent composes the command once, runs it against the archive list, and branches on the error status when a source turns out to be unreachable rather than failing the whole batch. Progress posts to Slack as it goes.

Reclaiming storage without losing a source

Storage costs are climbing and most of it is intermediate output nobody will look at again. The agent lists what it can see, matches it against the commands that produced it, and builds a proposed deletion set. Then it says out loud what its own inventory is missing, because that is the part a person needs in order to answer.

Human-in-Loop Highlight

A cleanup agent on Rendi cannot build a complete inventory, and it should say so rather than act as though it can. The file listing never returns deleted files or command input files, so the set an agent can enumerate is smaller than the set that exists, and a source someone handed to a command is invisible to the very listing a cleanup pass is built on. The bulk delete then reports by omission: an id that was already gone and an id that never existed are both simply absent from the result, so comparing what was sent against what came back is the only way to know what actually happened. So the agent posts the proposal with the gap stated: "142 output files across 38 commands are older than the retention rule, 61 GB total. Note that this listing excludes command input files, so any source stored for a chain is not shown here and is not in this set. Confirm the delete and I will report the difference between what I sent and what Rendi says it removed." A person confirms. FlowRunner treats the incompleteness as something to surface, not something to route around, because a digital andon cord that only pulls when the agent is certain is not much of a cord.

Agent processes routinely

Detects exception requiring judgment

Clear match Continues automatically

Ambiguous Routes to human via preferred channel

Human decides

Agent resumes with decision

Agent Capabilities

15 actions

Commands

Run FFmpeg Command Submits one FFmpeg command with its input and output alias maps and returns immediately. The command carries only the arguments, and every input alias and output alias has to carry the prefix the platform requires, which the connector checks before spending a request.
Run Chained FFmpeg Commands Submits several commands sharing one alias space, so a later command consumes an earlier one's output by name. The machine and the downloaded inputs are reused and one processing allocation is shared across the chain, which makes it materially cheaper than the same commands sent separately, not just faster.
Run FFmpeg Command And Wait Submits a command and polls it to completion. It returns a failed command rather than raising, because the error status is usually exactly what the flow needs to branch on, and on timeout the command keeps running so a later read can collect it.
Get Command Retrieves a command's state and outputs. The platform reports the same way for queued, processing, failed, and succeeded commands with the real state in the body, so this operation adds explicit done and failed booleans.
List Commands Lists commands on the account, scoped to the environment the API key selects. A listing that looks empty is often the right account on the wrong environment.
Delete Command Files Removes every output of one command. The narrow cleanup operation, and the one to prefer over a bulk delete when the scope is a single job.

Files

Store File Hands Rendi a publicly reachable URL and stores it. It is also the metadata operation: it runs a probe and returns duration, type, container, codec, dimensions, frame rate, pixel format, and bitrates, and that metadata survives deletion.
Get File Retrieves a stored file's record, optionally issuing a signed URL for a private output. A deleted file still answers here with everything except its storage location.
List Files Lists stored files. It never returns deleted files or command input files, so it is a view of current storage rather than a full history, which is the gap this page's human gate is built around.
Delete File Removes one file's bytes while keeping its metadata record, so the URL stops working and the probe results remain readable.
Delete Files In Bulk Removes several files at once. Ids that were already gone or never existed are simply absent from the result rather than reported as errors, so comparing the requested set against the returned set is the only way to know what happened.

Direct Upload

Start Direct Upload Begins a multipart upload for a very large file. The exact byte size has to be given up front, because the platform sizes the parts and checks quota from it, and the part size to use is the one the response returns rather than the one requested.
Complete Direct Upload Finalizes a multipart upload with the part numbers and the tag each part returned. The file reads as uploaded first and only becomes stored once the probe has finished.
Abort Direct Upload Cancels a multipart upload in progress rather than leaving a partial file in storage.
Upload File From URL Runs the whole multipart exchange in one call for a source Rendi cannot fetch itself, and aborts the upload if any part fails rather than leaving a partial file behind.

Triggers

1 triggers

Event Triggers

On Command Finished Fires on newly finished commands, optionally filtered to succeeded or failed only. Rendi's webhook URL is set in its dashboard with no create, list, or delete route, so there is nothing for a trigger to register and this one polls the command list instead. Its first pass records what is already finished and emits nothing, so starting a flow does not fire once per historical command.

Frequently Asked Questions

What can FlowRunner do with Rendi?

FlowRunner agents can run Run FFmpeg Command, Run Chained FFmpeg Commands, and Run FFmpeg Command And Wait in Rendi, plus 12 more actions.

Does connecting Rendi to FlowRunner require OAuth?

No. Rendi connects to FlowRunner with an API key, no OAuth flow required.

Can Rendi trigger a FlowRunner workflow automatically?

Yes. Rendi supports 1 trigger that can start a FlowRunner workflow automatically.

Start building with Rendi

$100 in credits. No card required. Connect in minutes.

Start Building Free Talk to us