Integration

RenderIO integration

RenderIO runs FFmpeg in the cloud. Submit one FFmpeg command, a chain of commands sharing one workspace, or up to 10 commands in parallel, on input files given as public URLs, and get back the stored output files with their media properties (duration, codec, size, resolution). Store files from a URL or by upload, save reusable command presets and execute them, read past commands and files, and set the account webhook. The yt-dlp video download routes and the S3 storage destination setup (create, update, disable, test) are not exposed. Authentication is an API key from the RenderIO dashboard (prefix ffsk_), sent in the X-API-KEY header.

Connect RenderIO How integrations work

Ask it in chat

Say what should happen.
The workflow builds itself.

When this happens, do that in RenderIO.Built from the 23 RenderIO tools below, on the connection you add once.

What you can do with RenderIO

Each of these is one operation on one endpoint, available both as a workflow step and as a tool an AI agent can call on its own. Nothing bundles several operations into one action, so what a run did stays readable afterwards.

Most endpoints run on the free plan. A few, mainly the ones that publish on your behalf, need a paid plan.

Preset, 5 operations

create_presetCreate presetPOSTSaves a reusable FFmpeg recipe: the command (or commands, for a chain), the in_ input aliases it expects and the out_ files it writes. execute_preset then runs it with only the input URLs.
delete_presetDelete presetDELETEDeletes one of your presets. System presets cannot be deleted. Returns the deleted preset's id.
get_presetGet presetGETReturns one preset (yours or a system preset): its command type, FFmpeg command(s), expected in_ input aliases, output file definitions, category and metadata.
list_presetsList presetsGETLists presets: the system presets first, then your own, newest first. Each carries its FFmpeg command(s), the in_ input aliases it expects and its output file definitions. Filter by category; page with limit and offset.
update_presetUpdate presetPUTChanges one of your presets; only the fields you send change, at least one is required, and metadata is replaced as a whole. System presets cannot be changed.

File, 4 operations

delete_command_filesDelete command filesDELETEPermanently deletes every RenderIO-managed output file of a command; the command record itself is kept. Outputs written to your own bucket (a storage destination) are not touched. Returns how many files were deleted.
delete_fileDelete fileDELETEPermanently deletes a file from RenderIO-managed storage; its record stays with is_deleted true. A file in your own bucket is left unchanged and the answer says deleted false, external true.
get_fileGet fileGETReturns one stored file: status (PROCESSING, STORED or FAILED), storage_url download link once STORED, how it was created, and media properties such as duration, codec, width, height, frame rate and bitrates.
list_filesList filesGETLists your stored files (uploads, files stored from a URL and command outputs), newest first, with status, storage_url and media properties. Deleted files are left out. Page with limit (at most 100) and offset.

Webhook config, 3 operations

delete_webhook_configDelete webhook configDELETEDeactivates the account webhook so completed commands are no longer posted to it; the configuration is kept but disabled. Use set_webhook_config to set a webhook again.
get_webhook_configGet webhook configGETReturns the account webhook: whether one is configured, its URL, whether it is active, and the consecutive delivery failures (it is disabled after 8 in a row).
set_webhook_configSet webhook configPUTSets the account webhook URL that receives a POST with the results each time a command completes; also re-enables a webhook that was disabled after failures. An optional secret signs each delivery.

Command, 2 operations

get_commandGet commandGETReturns one command: status (QUEUED, PROCESSING, SUCCESS or FAILED), timings, error code and message on failure, and output_files mapping each out_ alias to its stored file with a storage_url download link and media properties.
list_commandsList commandsGETLists your commands, newest first, with each one's status, command type, timings, output files and original request. Filter by status; page with limit (at most 100) and offset.

Storage destination, 2 operations

get_storage_destinationGet storage destinationGETReturns one S3-compatible storage destination (Business plan): name, endpoint, region, bucket, key prefix, public base URL, masked access key id and whether it is disabled.
list_storage_destinationsList storage destinationsGETLists your S3-compatible storage destinations (Business plan): id, name, endpoint, region, bucket, key prefix, public base URL and whether each is disabled. Secrets are never returned.

Execute, 1 operation

execute_presetExecute presetPOSTRuns a preset on new input files (exactly the preset's input_file_keys) and returns status, timings and output_files with each output's storage_url. Waits for the job and returns the finished result; gives up after 10 minutes.

Health, 1 operation

get_healthGet healthGETChecks that the RenderIO API is up. Answers status ok and the server time; needs no API key.

Run chained ffmpeg command, 1 operation

run_chained_ffmpeg_commandsRun chained ffmpeg commandsPOSTRuns FFmpeg commands one after the other in one workspace, so a command can read an earlier one's output; returns status and output_files with storage_url. Waits for the job and returns the finished result; gives up after 10 minutes.

Run ffmpeg command, 1 operation

run_ffmpeg_commandRun ffmpeg commandPOSTRuns one FFmpeg command in the cloud on input files given as URLs and returns status, timings and output_files with each output's storage_url and media properties. Waits for the job and returns the finished result; gives up after 10 minutes.

Run multiple ffmpeg command, 1 operation

run_multiple_ffmpeg_commandsRun multiple ffmpeg commandsPOSTStarts up to 10 independent FFmpeg commands in parallel, each with its own input and output files, and returns one command id per command in the order sent. Read each result with get_command.

Store file, 1 operation

store_fileStore filePOSTDownloads a file from a public URL into RenderIO storage and returns the stored file with its storage_url and media properties, ready to use as a command input. Waits for the job and returns the finished result; gives up after 5 minutes.

Upload, 1 operation

upload_fileUpload filePOSTUploads a file into RenderIO storage and returns its file_id. Media metadata is extracted afterwards: call get_file until status is STORED to read the storage_url to use as a command input.

Use RenderIO from Claude Code, Cursor or Codex

Connect RenderIO in LiveContext, create an API key in Settings, then add the LiveContext MCP server to your client. Its RenderIO operations become tools the client can call, next to every other integration you connected.

Claude Code

claude mcp add --transport http livecontext https://livecontext.ai/mcp --header "X-API-Key: YOUR_API_KEY"

Codex (~/.codex/config.toml)

[mcp_servers.livecontext]
url = "https://livecontext.ai/mcp"

[mcp_servers.livecontext.http_headers]
"X-API-Key" = "YOUR_API_KEY"

Cursor, Claude Desktop and other JSON configs

{
  "mcpServers": {
    "livecontext": {
      "type": "http",
      "url": "https://livecontext.ai/mcp",
      "headers": {
        "X-API-Key": "YOUR_API_KEY"
      }
    }
  }
}

Set up the MCP server step by step

How to connect RenderIO

Create your workspace
Sign up free. Nothing to install.
Connect RenderIO once
Add your RenderIO connection in Settings. Every tool from this integration reuses it, and secrets are encrypted at rest and visible only to you.
Describe the job in chat
The workflow builds itself in front of you and picks the endpoints it needs. Drag the steps yourself on the canvas whenever you would rather be explicit.