Value

Your agents can process video at scale. No FFmpeg infrastructure to manage.

Your agents shouldn't be managing FFmpeg clusters. RenderIO is one tool call — that's the whole integration.

Ship video features in hours

Add the MCP server config, call a tool, and you're in production. No cluster to provision, no Docker image to build.

Scale to millions of videos without re-architecting

The same tool call that processes one video handles 10,000. RenderIO scales the sandboxes automatically — your agent code never changes.

Zero maintenance burden

RenderIO handles FFmpeg upgrades, security patches, and server sizing. Your team doesn't touch any of it.

Predictable costs, no idle servers

You pay per command, not per idle server hour. Costs track directly with usage.

MCP Server

Connect via MCP — no HTTP code required

Claude Code calls FFmpeg via the RenderIO MCP server — no REST client code needed. Load /renderio-api for placeholder rules, chaining, and webhook patterns.

13 typed MCP tools

run_ffmpeg_command, get_command, store_file, execute_preset, and more. All schema-validated before hitting the sandbox.

No HTTP client code

The agent calls tools natively. The MCP runtime handles HTTP, polling, and errors.

Skill for deeper context

The renderio-api skill teaches agents placeholder rules, chaining, webhooks, and file upload patterns — beyond what the tool schema alone covers.

Add to your agent config:

{
  "mcpServers": {
    "renderio": {
      "type": "http",
      "url": "https://renderio.dev/api/mcp",
      "authorization_token": "Bearer YOUR_OAUTH_TOKEN"
    }
  }
}

Get your OAuth token from the RenderIO dashboard. The MCP server uses OAuth 2.1 Bearer token auth.

13 available tools:

run_ffmpeg_commandRun a single FFmpeg command
run_chained_ffmpeg_commandsRun commands in sequence — output of one feeds the next
get_commandPoll for status and retrieve output files
list_commandsList past commands with status filtering
list_presetsList system and custom FFmpeg presets
create_presetSave a command template to reuse with different inputs
get_presetGet preset details
execute_presetRun a preset with specific input files
list_filesList stored files
get_fileGet file metadata and download URL
store_fileStore a remote file by URL into RenderIO storage
upload_fileUpload a local file using base64-encoded content
delete_fileDelete a file from storage
Quick setup

Add RenderIO to Claude Code in 60 seconds

01

Get an OAuth token

Go to renderio.dev/get-api-key and generate a free OAuth token. No credit card required.
02

Add RenderIO to ~/.claude/claude.json

{
  "mcpServers": {
    "renderio": {
      "type": "http",
      "url": "https://renderio.dev/api/mcp",
      "authorization_token": "Bearer YOUR_OAUTH_TOKEN"
    }
  }
}
03

Load the skill for context (optional)

Type /renderio-api in any Claude Code session. The skill gives Claude placeholder rules, chaining patterns, and recipe examples — reduces back-and-forth significantly.
04

Call a tool

Ask Claude to compress a video or reformat to vertical. It calls run_ffmpeg_command directly. No code for you to write.
Use cases

UGC and social media video tasks

Copy these tool calls directly. The agent passes them to the RenderIO MCP server — no REST code needed.

Reformat to vertical (9:16)

Crop any video to TikTok, Instagram Reels, or YouTube Shorts format. Centers the subject automatically.

run_ffmpeg_command({
  ffmpeg_command: "-i {{in_video}} -vf \"crop=ih*9/16:ih:(iw-ih*9/16)/2:0,scale=1080:1920\" -c:a copy {{out_video}}",
  input_files: { in_video: "https://example.com/ugc.mp4" },
  output_files: { out_video: "vertical.mp4" }
})

Burn in captions from SRT

Render AI-generated subtitles directly onto the video. Required for silent autoplay on social feeds.

run_ffmpeg_command({
  ffmpeg_command: "-i {{in_video}} -vf subtitles={{in_srt}} {{out_video}}",
  input_files: {
    in_video: "https://example.com/ugc.mp4",
    in_srt: "https://example.com/captions.srt"
  },
  output_files: { out_video: "captioned.mp4" }
})

Compress for platform upload limits

Reduce file size to fit Instagram (100 MB), TikTok (287 MB), or X (512 MB) limits while keeping quality.

run_ffmpeg_command({
  ffmpeg_command: "-i {{in_video}} -c:v libx264 -crf 28 -preset slow -c:a aac -b:a 128k {{out_video}}",
  input_files: { in_video: "https://example.com/ugc.mp4" },
  output_files: { out_video: "compressed.mp4" }
})

Extract a highlight clip

Trim a specific time range for a social clip or short. Agent passes timestamps from AI scene detection.

run_ffmpeg_command({
  ffmpeg_command: "-i {{in_video}} -ss 00:00:30 -to 00:01:00 -c copy {{out_clip}}",
  input_files: { in_video: "https://example.com/ugc.mp4" },
  output_files: { out_clip: "highlight.mp4" }
})

Generate share thumbnail

Extract a single frame at a specific second for OG image, preview card, or platform cover.

run_ffmpeg_command({
  ffmpeg_command: "-i {{in_video}} -ss 3 -vframes 1 -q:v 2 {{out_thumb}}",
  input_files: { in_video: "https://example.com/ugc.mp4" },
  output_files: { out_thumb: "thumbnail.jpg" }
})
How it works

Connect, call, get result

01

Connect

Add the RenderIO MCP server to your agent config with your OAuth token. The agent discovers 13 tools automatically.

{
  "mcpServers": {
    "renderio": {
      "type": "http",
      "url": "https://renderio.dev/api/mcp",
      "authorization_token": "Bearer ..."
    }
  }
}
02

Call a tool

The agent calls run_ffmpeg_command with the command and file mappings. The MCP runtime handles the HTTP and polling.

run_ffmpeg_command({
  ffmpeg_command:
    "-i {{in_video}} -vf scale=1280:720 {{out_video}}",
  input_files: { in_video: "https://..." },
  output_files: { out_video: "720p.mp4" }
})
// → { command_id: "a1b2c3d4..." }
03

Get result

Call get_command with the command_id. When status is SUCCESS, the output URL is at output_files.out_key.storage_url.

get_command({ command_id: "a1b2c3d4..." })
// → {
//     status: "SUCCESS",
//     output_files: {
//       out_video: {
//         storage_url: "https://media.renderio.dev/..."
//       }
//     }
//   }
Skills

Load the RenderIO skill for deeper context

Tools and knowledge are different. The MCP server handles tools. The renderio-api skill covers what the schema doesn't: placeholder syntax, chaining, webhook setup, upload flows.

Load in Claude Code

/renderio-api

Type /renderio-api in any Claude Code session. The skill loads context on MCP tools, placeholder syntax, key prefix rules, chained commands, and webhooks.

Install via OpenClaw

openclaw skills install renderio-ffmpeg-api

OpenClaw distributes skills for Claude Code and compatible agents. Installing via OpenClaw also configures the MCP server entry automatically.

What the skill covers:

  • MCP tool reference with examples
  • Placeholder syntax: {{in_video}}, {{out_video}}
  • Key prefix rules: in_ for inputs, out_ for outputs
  • Chained command pipelines
  • File upload (base64 via upload_file tool)
  • Webhook configuration and payload shape
  • Error codes and self-correction patterns
  • 10 copy-paste FFmpeg recipes
MCP Tool rules

What Claude Code needs to know

The MCP server validates these rules before FFmpeg runs. Get them wrong and you'll see a clear error to fix against.

Double-brace placeholders

{{in_video}}, {{out_video}} ✓

{in_video} or $in_video ✗

The ffmpeg_command field uses {{key}} syntax. Single braces fail server-side validation before the sandbox ever runs.

Key prefix convention

in_video, in_audio for inputs / out_video, out_thumb for outputs ✓

video, input, result ✗

All input_files keys must start with in_, all output_files keys with out_. Validated at the MCP layer.

Every key must appear in the command

Declare in_video in input_files and use {{in_video}} in the command ✓

Declare a key that never appears as a placeholder ✗

Unused keys and missing placeholders both fail. The schema check catches this before FFmpeg runs.

Status values are uppercase

QUEUED, PROCESSING, SUCCESS, FAILED ✓

completed, done, failed ✗

When calling get_command, always compare status as uppercase strings.

Output URL location

output_files.out_video.storage_url ✓

output_files.out_video (object, not a URL string) ✗

Each output file is an object with storage_url, filename, size_mbytes, and optionally duration, codec, width, height.

REST API

Prefer raw HTTP? The REST API is always there.

If your setup doesn't support MCP, you can call the REST API directly. Same FFmpeg commands, same output structure — just HTTP instead of tool calls. Base URL: https://api.renderio.dev. Auth: X-API-KEY header.

curl -X POST https://renderio.dev/api/v1/run-ffmpeg-command \
  -H "X-API-KEY: ffsk_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "ffmpeg_command": "-i {{in_video}} -vf scale=1280:720 {{out_video}}",
    "input_files": { "in_video": "https://example.com/input.mp4" },
    "output_files": { "out_video": "720p.mp4" }
  }'
Full REST API reference for agents
FAQ

Frequently asked questions

Is there a Claude Code skill for RenderIO?▾

Yes. Load /renderio-api in your Claude Code session. The skill covers MCP tool usage, placeholder rules, chained commands, file uploads, and webhooks.

What FFmpeg commands does RenderIO support?▾

Any valid FFmpeg command. RenderIO runs a real FFmpeg binary in a secure cloud sandbox. If it works locally with FFmpeg, it works on RenderIO.

How long does processing take?▾

Most commands complete in seconds. Processing time depends on the input file size and the complexity of the FFmpeg command. The MCP get_command tool polls for you — no manual polling loop needed.

Where are output files stored?▾

Output files are stored in RenderIO's cloud storage and accessible via signed URLs in the output_files response. Access the URL at output_files.out_key.storage_url.

Do I need to install FFmpeg?▾

No. RenderIO provides FFmpeg as a service. Your agent calls MCP tools — RenderIO handles the FFmpeg execution in a secure cloud sandbox.

Is there a free tier?▾

Yes. Get a free API key and OAuth token at renderio.dev/get-api-key — no credit card required.

Other agents

RenderIO works with every coding agent

Cursor

Connect the RenderIO MCP server in Cursor. The agent calls FFmpeg tools directly — no boilerplate HTTP code in your codebase.

Codex

Give Codex clean FFmpeg tools via MCP. No hallucinated shell commands — structured tool calls with validated parameters.

GitHub Copilot

GitHub Copilot workspace gets FFmpeg tools via MCP. Process video without adding a single dependency to your repo.

Windsurf

Cascade through video processing pipelines. RenderIO MCP tools chain naturally — resize, compress, thumbnail in one agentic flow.

Devin

Devin ships video features faster with RenderIO MCP. No FFmpeg infra to provision — tools are ready the moment Devin connects.

Hermes

Give Hermes native FFmpeg tools via MCP. The model calls run_ffmpeg_command directly — no HTTP client code, no wrappers.

OpenClaw

Install the RenderIO skill in OpenClaw. Your agents get 13 FFmpeg tools — MCP server included — in one command.

Connect Claude Code to FFmpeg

Get an OAuth token, drop in the MCP config, and you're done. No FFmpeg to install, no server to run.

Get OAuth TokenAgent Docs