Clipia launches an MCP server: generate images and video right inside Claude Code, Cursor and Codex

June 20, 2026. Clipia.ai, a Russian AI image and video generation platform, has launched a remote MCP server at https://mcp.clipia.ai/mcp. AI agents — Claude Code, Cursor, Codex, Claude Desktop and the claude.ai web app — can now generate images and video straight from a conversation: no wrapper service, no hand-written HTTP calls, no glue code. Setup is a single command. Auth is a plain API key. And, unusually for the audience, billing works with Russian bank cards.

Instructions updated for October 2026. The date above marks the server launch. The catalog now also covers speech, music, video composition and presentations. Tool availability depends on the connection profile; check the current list in your MCP client.

TL;DR

• What: a remote MCP server at mcp.clipia.ai/mcp — image and video generation from inside an AI agent.
• Where it runs: Claude Code, Cursor, Claude Desktop, and the claude.ai web app.
• Setup: one command in Claude Code, or a few lines in a Cursor config. ~2 minutes.
• Tools across media types: images, video, speech, music, composition, presentations, models, status and prompt search.
• Usage-based pricing: generation calls are paid and return their cost. Review the model, parameters and balance before starting.
• Sandbox, no charge: clipia_test_* keys return correct mock responses — debug integrations and CI without spending credits.
• Built for Russia: Russian-language UI and support, payments by Russian bank card.

What Clipia MCP is

Clipia MCP is a remote MCP server from the Russian platform Clipia.ai that connects AI agents to image- and video-generation models directly from a conversation. It implements the Model Context Protocol (MCP) — Anthropic's open standard for connecting assistants to external tools — and runs stateless over Streamable HTTP, with no local install required.

The protocol idea is simple. Previously, to let an agent create images you'd write a wrapper around a REST API, describe it to the model as a tool, maintain the schema by hand, parse responses, decode base64 and surface a link. Now you just connect the server and the agent can generate immediately — it pulled the tool schemas itself.

The interesting part is that the agent sees the result. generate_image returns not only a link to the finished file but a compressed JPEG preview right in the tool result. For a vision-capable model that means it literally looks at what it produced, judges it, and decides whether to keep it or refine the prompt — a "generate → look → adjust" loop without a human on every iteration.

How to connect in two minutes

First, open the Developer Console and create a key in API keys. The key is shown once — save it immediately. For debugging, create a sandbox key with the clipia_test_ prefix next to it.

Claude Code — one command in the terminal (it adds the server across all your projects):

claude mcp add --transport http clipia https://mcp.clipia.ai/mcp \
  --header "Authorization: Bearer YOUR_KEY"

The MCP client then loads the current list of available tools.

Cursor — add the server to .cursor/mcp.json:

{
  "mcpServers": {
    "clipia": {
      "url": "https://mcp.clipia.ai/mcp",
      "headers": { "Authorization": "Bearer YOUR_KEY" }
    }
  }
}

Codex CLI — add a block to ~/.codex/config.toml and export the key into your environment:

[mcp_servers.clipia]
url = "https://mcp.clipia.ai/mcp"
bearer_token_env_var = "CLIPIA_API_KEY"
in your shell:
export CLIPIA_API_KEY="YOUR_KEY"

Codex injects Authorization: Bearer from the CLIPIA_API_KEY variable automatically.

Claude Desktop connects with the same endpoint and key via the mcp-remote utility. The claude.ai web app and ChatGPT (Developer mode) connect as a Custom Connector with OAuth (Settings → Connectors → Add custom → https://mcp.clipia.ai/mcp). Ready-made configs for VS Code, Windsurf and Gemini CLI are at clipia.ai/mcp.

One detail that matters if you live in a terminal or CI: there is no mandatory browser OAuth. In Claude Code and Cursor the key goes in a header, so the connection works headless — on a GUI-less server, in a Docker container, in a CI runner. Three key schemes are supported: Authorization: Bearer clipia_* (recommended), Authorization: Key <key> and X-Api-Key: <key>.

What the agent can do in the current version

The client receives current tool schemas on connection. Images and video are now joined by other content-production steps:

• generate_image — text-to-image and image-to-image; usually returns the finished image in one call plus a JPEG preview (the agent sees the result and iterates).
• generate_video — text-to-video and image-to-video (an image_url switches to an i2v model); returns request_id and cost immediately.
• generate_audio and generate_music — speech and music.
• compose_video — compose a video from prepared materials.
• generate_presentation and edit_presentation — create and revise slide decks.
• chat and generate_scenario — text and scenario work.
• wait_generation — waits for a video to finish (long-poll up to 30s per call).
• get_generation — instant status or result by ID.
• list_models — catalog: model, type, capabilities, price in credits.
• get_model — input schema and price for a specific model.
• get_balance — credit balance and 30-day usage for the key.
• search_templates — hybrid search across 3,500+ ready-made prompt templates (RU/EN).

search_templates is a quiet edge: the agent doesn't invent a prompt from scratch, it pulls a working template for the task. For video models, where prompts are fiddly, that saves time and credits.

Use list_models and get_model for current models and capabilities. Check the selected model schema before reusing parameters from an older example.

Transparent pricing and a sandbox for debugging

A call to generate_image, generate_video or another generation tool starts a paid operation. Before calling it, inspect the model with get_model, check the balance with get_balance, and verify pricing for the intended configuration. A cost returned after submission is not a request for advance approval. Give the agent a budget and ask it to confirm a paid run before submitting.

Before wiring up a live key, it's wise to verify your parsing and handling. That's what sandbox keys with the clipia_test_ prefix are for. A call with such a key instantly returns a correct mock result: no real generation runs, no credits are spent. You debug response parsing, polling, webhook handling and agent behavior at no cost. It's especially handy in CI — tests run the sandbox key and don't burn credits on every run.

Choose the connection method

For terminal clients and automation, follow the API-key setup in the MCP documentation. Web clients can expose different actions and result views depending on the connector and permissions. Check your client’s current instructions rather than relying on an older chat screenshot.

Pricing and billing for Russian developers

Billing is in credits from your Clipia account, the same credits as in the app. For developers in Russia and the CIS who otherwise juggle foreign payment processors to use foreign generation APIs, the difference is concrete: Clipia accepts Russian bank cards, with a Russian-language UI and support. See current pricing for plans and credit packs. A generation response reports the cost of the submitted operation.

Who it's for

Clipia MCP is built for developers who embed media generation into agentic pipelines — marketing automation, content engines, product prototypes — and for designers and content teams who generate images and video right from a Claude or Cursor chat without switching to a separate tool.

Two typical scenarios:

• A creative factory from the terminal. "Generate 5 first-frame variants for an ad, dark studio, 9:16, then turn the best one into a 5-second video with a slow camera push-in" — the agent generates a batch, picks the best by preview, takes its image_url and builds the video. The whole loop in one conversation.
• Assets while you code. "I need three background images for landing sections, 16:9, dark theme" — the agent generates them, grabs the CDN links and, if it has filesystem access, drops them into folders. You never left the editor.

"We wanted the agent to do more than write code — to create the media that goes with it, in the same conversation, with no wrappers and no context switching. The MCP server is exactly that: you describe the task in words, the model calls generation itself, sees the result and refines it. And it all works with Russian card payments — something developers here rarely get from foreign platforms."

— Maxim Zakharov, founder of Clipia.ai

Get started now

1. Create an API key at clipia.ai in the Developer Console (and a clipia_test_ sandbox key next to it for debugging).
2. Run the single connect command in Claude Code (or add the server to your Cursor config — see above).
3. Tell the agent what to generate.

Full developer docs live at clipia.ai/developers: REST reference, OpenAPI spec, webhooks, limits and errors. The MCP landing with configs for every popular client is at clipia.ai/mcp.

About Clipia.ai

Clipia.ai is a Russian AI image and video generation platform founded in 2024 by Maxim Zakharov. It provides access to 60+ neural-network models through a single interface with a Russian-language UI and Russian card payments, plus a text assistant on top LLMs, a public REST API, SDKs (npm clipia-ai, PyPI clipia) and an MCP server. Website: clipia.ai. Developer docs: clipia.ai/developers.

FAQ

What is Clipia MCP and why would I use it?

Clipia MCP is a remote server using the Model Context Protocol that connects Claude Code, Cursor and other AI agents to image- and video-generation models. The agent calls a tool and gets finished media right in its working context — no app switching, no manual API requests.

How do I connect Clipia MCP to Claude Code?

Create an API key in the Developer Console at clipia.ai, then run: claude mcp add --transport http clipia https://mcp.clipia.ai/mcp --header "Authorization: Bearer your_key". Restart Claude Code and the tools appear automatically. The whole thing takes about two minutes.

Can I use Clipia MCP in CI/CD and headless environments?

Yes. Auth works with a Bearer key and no browser OAuth, so the server runs fully in automated pipelines. To test without spending credits, use clipia_test_ sandbox keys — they return correct mock responses with no real generation.

How much does generation via MCP cost, and are there hidden charges?

Check the model and configuration price before starting. Generation is a paid action and its response reports the cost. Use get_balance to check credits and a sandbox key for development.

Why does my client show a different tool list?

The list depends on the connection profile and available server capabilities. Reconnect and check the current catalog in your client; the eight-tool description applied to an early version.

Is Clipia MCP an alternative to foreign generation APIs?

Functionally, yes: a REST API, an MCP server, SDKs for Python and JavaScript, and support for many image and video models. The difference is that Clipia operates in Russian jurisdiction (Russian card payments), with a Russian-language UI and support, plus a text assistant on top LLMs in the same account.

Which models are available through Clipia MCP?

All models in the Clipia catalog — 60+ neural networks for images and video: Nano Banana 2, Nano Banana Pro, Imagen 4 Ultra, Seedance, Seedream and others. The current list with credit prices comes from list_models, and search across 3,500+ ready prompts comes from search_templates.

How does claude.ai show the generated result?

In the claude.ai web app, a generation appears in an interactive card: live status, the finished image or video, and a button to open the full-resolution original. In Claude Code and Cursor the result arrives as an inline preview in the response stream.