Connect AI agents with the MCP server

The MCP server at https://api.rendobar.com/mcp gives an MCP client the whole platform: submit a job, upload a file, poll status, chain a completed job into the next one, and manage API keys. Connect it with one command over OAuth, no API key to copy.

Connect

Claude Code
claude.ai
Other MCP clients

claude mcp add --transport http rendobar https://api.rendobar.com/mcp

Your browser opens once to approve access.

Settings, Connectors, Add custom connector. Paste the URL and approve in the browser prompt.

https://api.rendobar.com/mcp

Any client that speaks Streamable HTTP with OAuth 2.1 connects the same way: point it at the URL below and approve in the browser that opens.

https://api.rendobar.com/mcp

Clients without OAuth support can authenticate with an API key instead: header Authorization: Bearer rb_..., from Settings, API keys on the dashboard.

What can I do with it?

Call list_job_types first. It returns every active job type fresh, so it never goes stale like a hardcoded list would. Pass type (for example "compose") to get that one job type’s complete parameter schema instead, with per-field documentation: ranges, defaults, units, and usage notes. Agents should do this before authoring a complex payload like a compose timeline.

Tool	What it does	Returns
`list_job_types`	Every active job type: use cases, what it chains with, a params digest, and an example payload. With `type`, the full annotated parameter schema for that one type.	`{ jobTypes[], guidance }` or `{ type, paramsJsonSchema, example, guidance }`
`submit_job`	Submit a job. `inputs` accepts a URL string, `{ url }`, `{ content }` (inline text), or `{ job: "job_..." }` for chaining. A URL can be a `storage://` URI, and `destinations` writes the output to a connected bucket.	`{ jobId, status }`
`get_job`	Check status and results. `wait: true` blocks up to 45 seconds instead of polling. A completed video job includes an inline poster image.	`{ id, status, output?, cost?, error? }`
`list_jobs`	Recent jobs, filterable by `status` and `type`.	`{ jobs[], total }`
`probe_media`	Run ffprobe against a media URL as an async job. Poll `get_job` for the normalized summary and full report.	`{ jobId, status }`
`get_account`	Credit balance, plan limits, active jobs, and rate limit usage.	`{ balance, plan, limits }`
`cancel_job`	Cancel a `waiting`, `dispatched` or `running` job.	`{ id, status: "cancelled" }`
`upload_media`	Open an upload session. Presigned URLs for shell-capable callers, or a `pageUrl` for the user to upload from their own device.	`{ session, pageUrl, files[] }`
`complete_upload`	Finalize an asset after its bytes land in storage.	`{ asset: { id, url, status } }`
`get_upload`	Check an upload session’s progress. `wait: true` blocks up to 45 seconds.	`{ status, assets[] }`
`list_storage`	The organization’s connected buckets. Use an id as `storage://<id>/<path>` in `inputs`, or as `storage://<id>` in `destinations` unless its `access` is `"read"`. Credentials are never returned.	`{ storage[], note }`

{ job: "job_..." } inside submit_job’s inputs chains a completed job straight into the next one today for ffmpeg inputs. For any other job type, pass the prior job’s output URL (from get_job) as a plain URL input instead. A failed call returns isError: true with { error: { code, message, retryable } } instead of throwing, so the agent can react to it. See the error catalogue for codes.

Can I use it from my phone?

A phone has no filesystem the agent can reach, so a media file routes through a page you open yourself.

Connect on claude.ai mobile

Settings, Connectors, Add custom connector, paste https://api.rendobar.com/mcp, approve.

Ask for the edit

“Trim this video to the first 10 seconds and burn in captions.” Claude calls list_job_types, then upload_media with no files declared, since it can’t read anything off your phone.

Tap the upload link

upload_media returns a pageUrl. Claude sends it to you in the chat. Open it, pick the file from your camera roll, and it uploads.

Get the result in chat

Claude polls get_upload({ wait: true }) until the asset is ready, calls submit_job with its URL, then get_job({ wait: true }), and replies with the finished clip.

From an agent with shell access

An agent that can run shell commands skips the upload page and PUTs bytes directly.

Declare the file

Pass the filename and size. A known size gets you a presigned URL right away: a single PUT under 100 MB, part URLs above it.

upload_media({ files: [{ filename: "clip.mp4", size: 8421312 }] })

PUT the bytes

curl -sS -X PUT --upload-file clip.mp4 "https://<presigned-url-from-upload_media>"

Finalize the asset

complete_upload({ assetId: "asset_8f2a1c" })

Returns the ready asset, including its stable url. For a multipart upload, pass parts: [{ partNumber, etag }] collected from each part’s PUT response.

Submit the job

submit_job({
  type: "ffmpeg",
  inputs: { "clip.mp4": "https://api.rendobar.com/assets/asset_8f2a1c/content" },
  params: { command: "ffmpeg -i clip.mp4 -vf scale=1280:720 -c:v libx264 -crf 23 out.mp4" }
})

Returns { jobId: "job_9c31", status: "waiting" }.

Chain a second job off the first

Pass the completed job’s id as the next job’s input. No download, no re-upload.

submit_job({
  type: "ffmpeg",
  inputs: { "out.mp4": { job: "job_9c31" } },
  params: { command: "ffmpeg -i out.mp4 -vf drawtext=text='done':x=10:y=10 final.mp4" }
})

Wait for the result

get_job({ jobId: "job_a71f", wait: true })

Blocks up to 45 seconds, then returns output.file.url.

Run the local server for direct disk access

The hosted server can’t read your disk, so even a shell-capable agent goes through the presigned-URL handshake above. @rendobar/mcp, the local stdio server, skips that: its upload_file tool reads a file off disk and uploads it in a single call. It has the same storage tools as the hosted server, plus list_storage_files for finding a path inside a connected bucket. Get an API key at app.rendobar.com, Settings, API keys.

Claude Code
Claude Desktop
Other clients

claude mcp add rendobar -s user --env RENDOBAR_API_KEY=rb_... -- npx -y @rendobar/mcp

Edit the config file, then restart Claude Desktop.

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "rendobar": {
      "command": "npx",
      "args": ["-y", "@rendobar/mcp"],
      "env": { "RENDOBAR_API_KEY": "rb_..." }
    }
  }
}

Cursor, Cline, Windsurf, Zed, and Continue all run the same npx -y @rendobar/mcp command with the RENDOBAR_API_KEY env var. Only the config file and the top-level key name differ (mcpServers for most, context_servers for Zed).

Needs Node 20.10 or later. The server checks at startup and exits with a clear message if it’s older.

How do I limit what it can reach?

Approving a connection grants access to one workspace, and you can take it back. Account, Security lists every app you have connected, what each one can reach, and the workspace it was granted in. Revoking cuts an app off and forces it to ask again from the start. One caveat worth knowing: revoking deletes the grant and every stored token, so the app cannot get new access or renew what it has, but an access token it is already holding stays valid until it expires. That is under an hour. An app connected before 2026-09-13 cannot call list_storage, because storage scopes did not exist when you approved it. Revoke it and connect again to allow Storage.

Getting Started

Concepts

Storage

Jobs

Automation

Developer tools

Support

Connect AI agents with the MCP server

Connect

What can I do with it?

Can I use it from my phone?

From an agent with shell access

Run the local server for direct disk access

How do I limit what it can reach?

See also

​Connect

​What can I do with it?

​Can I use it from my phone?

​From an agent with shell access

​Run the local server for direct disk access

​How do I limit what it can reach?

​See also

Connect

What can I do with it?

Can I use it from my phone?

From an agent with shell access

Run the local server for direct disk access

How do I limit what it can reach?

See also