Add Vidaio's MCP server to Claude, ChatGPT, Cursor or any other MCP client, then compress and upscale videos just by asking.
8 min read
Vidaio runs an MCP (opens in a new tab) server at https://mcp.vidaio.io/mcp. Connect an AI assistant to it and the assistant can compress and upscale videos for you, on your Vidaio credits, in the middle of a conversation: hand it a link, say what you want, and it starts the job, waits for it and gives you the result.
Every client sets the connection up in its own way, but it's always the same connection underneath. This guide starts with that connection, then shows where it goes in Claude, ChatGPT, Cursor and VS Code. Any other client that speaks MCP works the same way.
You'll need three things:
Whatever the client, the server is the same:
| Setting | Value |
|---|---|
| Server URL | https://mcp.vidaio.io/mcp |
| Transport | HTTP (some clients call it Streamable HTTP) |
| Sign-in | OAuth, or your API key in a header |
There are two ways to sign in:
x-api-key exactly as it is, with nothing before it, or as Authorization: Bearer YOUR_VIDAIO_API_KEY. Many clients take their servers as JSON, in roughly this shape:{
"mcpServers": {
"vidaio": {
"url": "https://mcp.vidaio.io/mcp",
"headers": {
"x-api-key": "YOUR_VIDAIO_API_KEY"
}
}
}
}Replace YOUR_VIDAIO_API_KEY with your key wherever it appears in this guide.
Claude adds remote MCP servers as custom connectors, and the same connector works on the web and in the desktop app.
Vidaio and enter https://mcp.vidaio.io/mcp as the server URL.To use it, open a chat, select + > Connectors and turn Vidaio on. Claude asks before it runs each tool; you can let it always run the ones you trust. If you re-roll your API key, the connector stops working: disconnect it and connect again with the new key.
If you'd rather not use OAuth, choose No sign-in in step 3, then open Request headers, choose x-api-key, paste your API key as its value and mark it Required. Request headers are rolling out to Claude accounts gradually; if your dialog has none, use OAuth, or connect the desktop app through a small local bridge instead. mcp-remote (opens in a new tab) is a community tool that runs on your computer, adds the header and passes everything on to Vidaio. It needs Node.js (opens in a new tab). In the desktop app, open Settings > Developer > Edit Config and add Vidaio to the file it opens:
{
"mcpServers": {
"vidaio": {
"command": "npx",
"args": [
"-y",
"mcp-remote",
"https://mcp.vidaio.io/mcp",
"--header",
"x-api-key:${VIDAIO_API_KEY}"
],
"env": {
"VIDAIO_API_KEY": "YOUR_VIDAIO_API_KEY"
}
}
}
}Keep the header written as x-api-key:${VIDAIO_API_KEY}, with no space after the colon: the key itself goes in env. Quit and reopen the app, and Vidaio's tools appear under + > Connectors.
Add the server from your terminal:
claude mcp add --transport http vidaio https://mcp.vidaio.io/mcpThen run /mcp inside a session and choose Vidaio to sign in: a Vidaio page opens in your browser for your API key. To pass the key directly instead, add --header "x-api-key: YOUR_VIDAIO_API_KEY" to the command.
That adds it for the project you're in. Add --scope user to have it in every project. Run claude mcp list, or /mcp inside a session, to check that it's connected.
To share the server with your team through the project's .mcp.json, have Claude Code read each person's key from their own environment, so no key is committed:
{
"mcpServers": {
"vidaio": {
"type": "http",
"url": "https://mcp.vidaio.io/mcp",
"headers": {
"x-api-key": "${VIDAIO_API_KEY}"
}
}
}
}ChatGPT connects to MCP servers as custom apps, in developer mode, on the web.
Vidaio, enter https://mcp.vidaio.io/mcp as its URL and choose OAuth for its authentication.Cursor reads its MCP servers from mcp.json: ~/.cursor/mcp.json for every project, or .cursor/mcp.json in a project for that project alone. Add Vidaio to either:
{
"mcpServers": {
"vidaio": {
"url": "https://mcp.vidaio.io/mcp",
"headers": {
"x-api-key": "${env:VIDAIO_API_KEY}"
}
}
}
}${env:VIDAIO_API_KEY} reads the key from your environment, so set VIDAIO_API_KEY in your shell before you open Cursor, or put the key in its place. Vidaio then shows in Cursor's MCP settings, with its tools.
VS Code (with GitHub Copilot) reads MCP servers from .vscode/mcp.json in your workspace. Have it ask you for the key, which it then stores securely, rather than writing it in the file:
{
"inputs": [
{
"type": "promptString",
"id": "vidaio-api-key",
"description": "Vidaio API key",
"password": true
}
],
"servers": {
"vidaio": {
"type": "http",
"url": "https://mcp.vidaio.io/mcp",
"headers": {
"x-api-key": "${input:vidaio-api-key}"
}
}
}
}Start the server from the file (or from MCP: List Servers in the Command Palette), enter your key when asked, then pick Vidaio's tools in Copilot's agent mode.
Look in its settings or docs for adding a remote or HTTP MCP server, then give it the settings from the connection: the URL, HTTP as the transport, and either OAuth or the x-api-key header.
If a client can only start servers on your own computer (often called stdio or local servers), connect it through the same mcp-remote (opens in a new tab) bridge as the Claude desktop app above: the command is npx, and the arguments are the ones in that example, with your key in VIDAIO_API_KEY.
Once it's connected, you don't call the tools yourself: ask for what you want and the assistant picks the tool. For example:
https://example.com/videos/launch.mp4 with Vidaio."https://example.com/videos/teaser.mp4"Vidaio's server gives the assistant these tools:
| Tool | What it does |
|---|---|
compress_video | Compresses a video (up to 10 minutes, less at high resolution) to AV1 and waits about a minute for the result |
upscale_video | Upscales a video (up to 200 seconds) 2x or 4x and waits about a minute for the result |
start_compression | Starts compressing a video and returns the task's id straight away |
start_upscaling | Starts upscaling a video and returns the task's id straight away |
wait_for_task | Waits about a minute for a task, then returns its state and, once it's done, the link |
get_task_status | Checks how a task is going, without waiting |
get_task_result | Gets a finished task's link |
list_tasks | Lists your recent tasks, with their states and links |
cancel_task | Cancels a task that hasn't started processing yet |
estimate_cost | Works out what a task would cost, before starting it |
get_account | Shows your credit balance and rate limits |
The status, result and wait tools take the operation (compression or upscaling) and the task's id. Compression runs at High quality on the Standard tier unless you ask for another quality (Low or Medium) or for Premium, which runs on GPUs and finishes sooner. Upscaling doubles the video's resolution (2x) unless you ask for 4x, on the Standard tier unless you ask for Premium: generative AI that creates new fine detail (so small details can differ from the original), for short clips (up to about 20 seconds) from sources up to 720p, at a higher rate. The start tools can also upload the result to a pre-signed URL in your own storage.
Every task you run this way spends credits from your balance, as it would through the API.
https://mcp.vidaio.io/mcp and the transport is HTTP, not SSE or stdio.x-api-key and its value is your current key, with no stray spaces (or that Authorization reads Bearer and then the key). If you've re-rolled your key, every client needs the new one.Building something of your own instead? Build Vidaio into your app with the API covers the API, and the API reference (opens in a new tab) every endpoint.