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

Windsurf's Cascade agent calls run_ffmpeg_command, get_command, and store_file in sequence via MCP — a complete video pipeline without any HTTP client code.

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 Windsurf in 60 seconds

01

Get an OAuth token

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

Add to ~/.codeium/windsurf/mcp_config.json

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

Restart Windsurf

Restart Windsurf after saving the config. Cascade will pick up the RenderIO tools on next launch.
04

Build a chained pipeline with Cascade

Ask Cascade to resize a video then extract a thumbnail in one task. It calls run_chained_ffmpeg_commands — both steps run server-side with no intermediate downloads.
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 Windsurf 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" }
  }'
FAQ

Frequently asked questions

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.

Connect Windsurf to FFmpeg

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