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.
Connect via MCP — no HTTP code required
Hermes gets 13 typed FFmpeg tools via RenderIO MCP — from run_ffmpeg_command to execute_preset — with schema validation that prevents hallucinated parameters.
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 commandrun_chained_ffmpeg_commandsRun commands in sequence — output of one feeds the nextget_commandPoll for status and retrieve output fileslist_commandsList past commands with status filteringlist_presetsList system and custom FFmpeg presetscreate_presetSave a command template to reuse with different inputsget_presetGet preset detailsexecute_presetRun a preset with specific input fileslist_filesList stored filesget_fileGet file metadata and download URLstore_fileStore a remote file by URL into RenderIO storageupload_fileUpload a local file using base64-encoded contentdelete_fileDelete a file from storageAdd RenderIO to Hermes in 60 seconds
Get an OAuth token
Go to renderio.dev/get-api-key and generate a free OAuth token.Set up an MCP bridge for Hermes
Hermes runs via Ollama or LangGraph. Use an MCP client library (e.g. mcp-python, LangGraph MCP tools) to connect the RenderIO server and expose it as callable tools to the model.Pass the server config to your bridge
{
"renderio": {
"type": "http",
"url": "https://renderio.dev/api/mcp",
"authorization_token": "Bearer YOUR_OAUTH_TOKEN"
}
}Call run_ffmpeg_command
Hermes calls run_ffmpeg_command with structured parameters. The server validates placeholder syntax and key prefixes before FFmpeg runs — malformed calls return typed errors Hermes can fix on retry.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" }
})Connect, call, get result
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 ..."
}
}
}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..." }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/..."
// }
// }
// }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-apiType /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-apiOpenClaw 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
What Hermes 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.
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" }
}'Frequently asked questions
Does Hermes support MCP?▾
Yes. Hermes models support structured tool/function calling. Any framework that wraps Hermes with MCP server support (like Ollama with MCP bridges, or LangGraph) can connect to the RenderIO MCP server at https://renderio.dev/api/mcp.
Why use MCP over calling the REST API from Hermes?▾
MCP tools have typed schemas. When Hermes calls run_ffmpeg_command, the server validates placeholder syntax and key prefixes before execution. Malformed calls get a structured error response Hermes can self-correct from — no retrying against a black-box REST error.
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.
RenderIO works with every coding agent
Claude Code
Add FFmpeg video processing to any Claude Code session. Connect the MCP server, load the skill, and Claude handles the rest.
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.
OpenClaw
Install the RenderIO skill in OpenClaw. Your agents get 13 FFmpeg tools — MCP server included — in one command.
Connect Hermes to FFmpeg
Get an OAuth token, drop in the MCP config, and you're done. No FFmpeg to install, no server to run.