MCP server: generate video and images from your agent

The Jantaris MCP server gives an AI agent (Claude Code, Codex, Cursor and others) a set of tools: the model list with prices, a cost estimate before you start, video, image and music generation, task status and balance. You type "make a 9:16 reel about coffee" and the agent picks a model, shows the cost and starts the job. It is billed from the same prepaid balance as the API, and failed generations cost nothing.

MCP (Model Context Protocol) is an open standard that lets AI agent apps plug in external tools. Think of it as a socket: you enter the server URL and a key once, and the agent sees which tools it has and when to use them. No code, no endpoints to learn.

One-click install

• Add to Cursor - Cursor reads the key from the JANTARIS_API_KEY environment variable (set it first, see the Codex section below).
• Add to VS Code - VS Code asks for the key once and keeps it in secure storage.

The same buttons, plus ready-to-copy commands for Claude Code and Codex with the right address, are in the dashboard under API keys. Neither the buttons nor the commands contain your key. Right after you create a key, the dashboard also shows a Claude Code command with that key filled in, once.

API key

1. Open the dashboard, API keys tab.
2. Name the key, e.g. mcp-claude-code, and set a Monthly limit in dollars, e.g. 15.
3. Click Create key and copy sk-jt-... (shown once).

The monthly limit is your fuse. An agent with a video tool can, in a bad loop, start several clips in a row. When the key hits its limit the API answers 403 and nothing more leaves your balance. More: Authentication.

Replace sk-jt-... with your key in the examples below.

Claude Code

One command in your terminal (same on macOS, Linux and Windows PowerShell):

claude mcp add --transport http jantaris https://jantaris.com/mcp --header "Authorization: Bearer sk-jt-..."

By default the server is available only in the current project folder. To use it in every project add --scope user:

claude mcp add --transport http jantaris https://jantaris.com/mcp --scope user --header "Authorization: Bearer sk-jt-..."

Check:

claude mcp list

jantaris should show Connected. Inside a Claude Code session type /mcp to see the status and tool list.

Claude Code asks for permission before each tool call. Keep it that way for generate - you see which model and parameters the agent wants to send.

If Claude Code already uses Jantaris as its model provider (ANTHROPIC_BASE_URL, see Claude Code), MCP works alongside it - same key or a separate one, both draw from one balance.

Codex CLI

Codex keeps the key in an environment variable and only stores the variable name in its config.

macOS and Linux:

export JANTARIS_API_KEY="sk-jt-..."
codex mcp add jantaris --url https://jantaris.com/mcp --bearer-token-env-var JANTARIS_API_KEY

Windows PowerShell (saves the variable permanently, then open a new terminal):

[Environment]::SetEnvironmentVariable("JANTARIS_API_KEY", "sk-jt-...", "User")
codex mcp add jantaris --url https://jantaris.com/mcp --bearer-token-env-var JANTARIS_API_KEY

The command writes this to ~/.codex/config.toml (Windows: %USERPROFILE%\.codex\config.toml):

[mcp_servers.jantaris]
url = "https://jantaris.com/mcp"
bearer_token_env_var = "JANTARIS_API_KEY"

Check with codex mcp list. Full guide, including what Codex cannot do: Codex CLI with Jantaris.

Cursor

Create .cursor/mcp.json in your project (or ~/.cursor/mcp.json for all projects):

{
  "mcpServers": {
    "jantaris": {
      "url": "https://jantaris.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:JANTARIS_API_KEY}"
      }
    }
  }
}

Cursor replaces ${env:JANTARIS_API_KEY} with the environment variable, so the key never lands in the file. Set the variable as in the Codex section above and restart Cursor. If you prefer, paste the key directly: "Authorization": "Bearer sk-jt-..." - then do not commit the file.

After saving, the jantaris server shows up in the MCP server list in Cursor settings. You can toggle it off there without deleting it.

VS Code

Agent mode in VS Code (GitHub Copilot) reads .vscode/mcp.json. This version asks for the key on first start and keeps it in VS Code's secure storage, not in the file:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "jantaris-key",
      "description": "Jantaris key (sk-jt-...)",
      "password": true
    }
  ],
  "servers": {
    "jantaris": {
      "type": "http",
      "url": "https://jantaris.com/mcp",
      "headers": {
        "Authorization": "Bearer ${input:jantaris-key}"
      }
    }
  }
}

Check: Command Palette (Ctrl+Shift+P, Cmd+Shift+P on macOS), run MCP: List Servers, pick jantaris and look at its status.

Cline

In the Cline panel click the MCP Servers icon, Remote Servers tab: name jantaris, URL https://jantaris.com/mcp, transport Streamable HTTP. Add the key header in the settings file (Configure MCP Servers):

{
  "mcpServers": {
    "jantaris": {
      "type": "streamableHttp",
      "url": "https://jantaris.com/mcp",
      "headers": {
        "Authorization": "Bearer sk-jt-..."
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Leave autoApprove empty so Cline asks before every generation.

Claude Desktop

In the Claude app (and on claude.ai) you add a remote server as a custom connector:

1. Customize, then Connectors.
2. + Add, then Add custom connector.
3. Name: Jantaris, URL: https://jantaris.com/mcp.
4. Authentication: No sign in, and under Request headers add the header Authorization with the value Bearer sk-jt-....

According to Anthropic's help center, custom connectors work on Free (one connector), Pro, Max, Team and Enterprise plans. On Team and Enterprise an organization owner adds the connector in organization settings. The connector connects from Anthropic's servers, not from your computer.

OpenCode

In opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "jantaris": {
      "type": "remote",
      "url": "https://jantaris.com/mcp",
      "enabled": true,
      "headers": {
        "Authorization": "Bearer sk-jt-..."
      }
    }
  }
}

Other apps

Any app that supports remote MCP servers over Streamable HTTP needs the same three things: the URL https://jantaris.com/mcp, an Authorization header and the value Bearer sk-jt-.... For example Windsurf uses serverUrl instead of url in mcp_config.json:

{
  "mcpServers": {
    "jantaris": {
      "serverUrl": "https://jantaris.com/mcp",
      "headers": { "Authorization": "Bearer sk-jt-..." }
    }
  }
}

Server tools

Images usually finish within 45 seconds. Video takes 1-4 minutes: generate waits up to 240 seconds, and if the job is still running the agent gets a task id and a hint to call wait_for_task. Apps that support progress (MCP progressToken) show "running 40 s" while waiting.

Output links are valid for a limited time (expires_at). Every result includes a ready curl -o command, so you can ask the agent to "save the video in media/".

Spend controls: approve-then-run

Two guards stop an agent from spending more than you agreed to:

1. max_cost in generate: if the estimate is higher, the job does not start and nothing is charged or reserved.
2. confirm_token from estimate_cost: the agent shows you the cost, you say OK, and it calls generate with the same input and this token. If the model or any parameter changed since the estimate, or 15 minutes passed, the call is refused and nothing is charged.

Recommended flow (the ready prompts below follow it): search_models -> estimate_cost -> you approve -> generate with confirm_token and max_cost -> wait_for_task if needed.

A separate key with a monthly limit (see API key) is the third guard: get_balance shows how much of it is used.

Files from your computer

Image-to-video, lip sync or reference audio need a file URL. upload_file handles it in one of three ways:

• data_base64 (+ filename) - the agent sends the file in the call, up to 8 MB.
• source_url - the server downloads a public link (up to 25 MB).
• request_upload_url: true - the server returns a one-time address valid for 10 minutes, and the agent runs:

curl -T photo.png "https://jantaris.com/mcp/upload/..."

Invoke-WebRequest -Method Put -InFile .\photo.png -Uri "https://jantaris.com/mcp/upload/..."

Each way returns url, mime, bytes and expires_at. Allowed types: PNG, JPG, WebP, MP4, MOV, MP3, WAV (checked by file content, not name). Files are deleted after 30 days.

Ready prompts

The server ships recipes your app lists as prompts or slash commands (in Claude Code: /mcp__jantaris__reel_9x16). Each one walks the agent through model search, cost approval, upload and generation:

Example prompts

Paste these into your agent once the server is connected:

• "Make a 9:16 Seedance 2.5 reel, 5 seconds, about morning coffee in a small cafe. Show me the cost first and wait for my OK."
• "Generate 3 cover variants for this README with GPT Image 2.5, 16:9, and save them in docs/img/."
• "Show the 5 cheapest video models that support 1080p, with price per second."
• "How much balance do I have left?"
• "Ask Gemini 3.8 Flash for a second opinion on this function and compare it with yours."

Current prices of the example models: Seedance 2.5 from $0.261 per second, GPT Image 2.5 $0.0432 per image, Nano Banana Pro from $0.0747 per image. Full list: Pricing.

Safety and cost

• A separate key with a monthly limit for every agent. Over the limit you get 403 and the account balance is untouched.
• Approve before generating. The agent calls estimate_cost, shows the cost and passes confirm_token and max_cost to generate (see Spend controls). Put that rule into AGENTS.md too.
• Do not auto-approve the generate tool. Auto-approving search_models, list_models, get_model, estimate_cost, get_task, wait_for_task, list_tasks, get_balance and search_docs is safe, they cost nothing.
• Failed generation = $0. Funds are reserved for the duration of the task and fully released if the model returns an error.
• Keep the key out of your repo. In project files use variables (${env:...} in Cursor, ${input:...} in VS Code, bearer_token_env_var in Codex).

Common errors

More codes: Errors.