# Generate AI videos from Claude, Cursor or Claude Code with the Klakix MCP server

> Source: <https://dev.to/klakix/generate-ai-videos-from-claude-cursor-or-claude-code-with-the-klakix-mcp-server-450m>
> Published: 2026-11-20 16:07:44+00:00

**Key takeaway:** Klakix's remote MCP server exposes 19 generation tools and 7 prompts over Streamable HTTP with OAuth 2.1, and a dependency-free npx klakix-mcp bridge lets stdio-only clients like Claude Desktop reach it with a Bearer API key.

Claude writes text and code. It does not render video. If you want it to hand you an MP4, it has to call a model somewhere, and the cleanest way to wire that up today is an MCP server.

This post walks through the [Klakix](https://klakix.com/mcp) MCP server: how to connect it to Claude, Claude Code, Cursor and a few other clients, what the tools look like, and how to keep an eye on cost before anything is generated. It also covers the open-source packages behind it, in case you want to build a remote MCP server of your own. I work on Klakix, so read this as a hands-on guide from the maintainer's side, not a neutral review.

The server lives at one URL:

```
https://klakix.com/api/mcp
```

It is a remote MCP server (Streamable HTTP, stateless, JSON responses). You add the URL to a client, sign in with your Klakix account through OAuth 2.1, and the client gets 19 tools and 7 ready-made workflows (MCP prompts). Between them they cover video, images, audio, talking-head videos, effects, upscaling and templates.

The models behind the tools include Seedance 2.5 and 2.0, Kling 4.0 and 3.0, Veo 3.1 Lite, Wan 3.0 and MiniMax H3 Max for video, Nano Banana 2, GPT Image 2.5 and Muse Image for images, HeyGen Avatar IV and OmniHuman 1.5 for talking videos, Topaz Video AI for upscaling, and Klakix's own voice, music and sound effect models. You don't pick these in a settings screen; you ask the assistant, and it can call `list_models` to see what is available.

Credits are shared with the website and are spent at web prices. There is no subscription requirement. One practical detail: a new account can make voiceovers straight away, while the video and image tools unlock after the first credit purchase.

Open **Customize > Connectors**, choose **+ Add**, then **Add custom connector**. Name it `Klakix`, paste `https://klakix.com/api/mcp` as the URL and continue. Keep the detected authentication settings, add it, then sign in and approve. In a new chat, click **+**, open **Connectors** and turn Klakix on. The free Claude plan allows one custom connector.

If you prefer a config file, or your client only starts local stdio servers, use the small `klakix-mcp` bridge. Create an API key at [klakix.com/app/mcp](https://klakix.com/app/mcp) (it is shown once) and add this to `claude_desktop_config.json`:

```
{
  "mcpServers": {
    "klakix": {
      "command": "npx",
      "args": ["-y", "klakix-mcp"],
      "env": { "KLAKIX_API_KEY": "avy_sk_..." }
    }
  }
}
```

The package has no dependencies and needs Node.js 20 or newer. It reads JSON-RPC from stdin, posts each message to the remote server and writes the replies to stdout. The key only goes out as a Bearer token.

```
claude mcp add --transport http --scope user klakix https://klakix.com/api/mcp
```

Then run `/mcp` inside Claude Code and sign in through the browser. If you would rather use a key:

```
claude mcp add --transport http --scope user klakix https://klakix.com/api/mcp \
  --header "Authorization: Bearer avy_sk_..."
```

Put this in `~/.cursor/mcp.json`:

```
{
  "mcpServers": {
    "klakix": {
      "url": "https://klakix.com/api/mcp"
    }
  }
}
```

`.vscode/mcp.json`:

```
{
  "servers": {
    "klakix": {
      "type": "http",
      "url": "https://klakix.com/api/mcp"
    }
  }
}
```

Codex and Gemini CLI take one line each:

```
codex mcp add klakix --url https://klakix.com/api/mcp
codex mcp login klakix

gemini mcp add --transport http klakix https://klakix.com/api/mcp
```

For tools like n8n or Make, create an API key and send it as `Authorization: Bearer avy_sk_...`.

The tools split into three groups, and the grouping matters for cost.

Tools that create something and spend credits: `generate_video`, `generate_image`, `generate_audio`, `create_talking_video`, `apply_effect`, `transfer_motion`, `upscale_video`, `create_explainer_video` and `run_template`.

Tools for files and results, which are free: `upload_media` (import from a URL or an earlier result), `get_generation` (status and file links, and it can wait for completion), `list_generations` and `cancel_generation`. Cancelling a queued generation refunds its credits.

Account and catalog tools, also free: `get_account`, `list_models`, `get_model`, `estimate_cost`, `list_voices` and `list_templates`.

The seven prompts are workflows you can invoke by name: `product_ad`, `ugc_ad`, `storyboard_film`, `photo_to_video`, `social_reel`, `voiceover_pack` and `character_consistency`.

**1. Check before you spend.**

How many credits do I have? Then list the video models, and tell me what a 5-second vertical clip of a paper boat on a rainy street would cost on two of them. Don't generate anything yet.

The assistant calls `get_account`, `list_models` and `estimate_cost`. None of these spend credits. `get_model` gives you the settings, limits and example prompts for a single model if you want to see what it accepts before choosing.

**2. A product video from a photo.**

Use the product_ad workflow with this photo of my ceramic mug. Vertical, 5 seconds, slow camera move, no text. Show me the estimated cost and wait for my OK before generating.

Telling the assistant to wait for your go-ahead is just a normal instruction in the prompt, and it works well here. After you confirm, `generate_video` queues the job and `get_generation` returns the status and, when it is done, the file link. Results download as MP4, PNG or MP3.

**3. A voiceover.**

Read this script in a calm voice, then suggest three voices from the list first so I can pick.

`list_voices` returns voices with preview links, and `generate_audio` produces the voiceover. The same tool also handles multi-voice dialogue, music and sound effects. Voiceovers are the one thing a brand-new account can do before buying credits.

Generation can take minutes and costs real credits, so I would build the habit of asking for `estimate_cost` first. Credits never expire, and a generation that fails for a technical reason or a safety block is refunded automatically. Parallel generations are limited: 3 without a plan, more on the plans. Clips run from 3 to 30 seconds depending on the model.

Prompts and uploaded images go through the same checks as the website. Celebrities, public figures, people without their consent and copyrighted characters are blocked, tools that use a photo of a person ask for a consent confirmation, and there is no face swap or voice cloning. That is worth knowing before you plan a workflow around it.

The repository at [github.com/klakix-ai/klakix-mcp](https://github.com/klakix-ai/klakix-mcp) contains the building blocks we run in production, extracted as MIT-licensed packages:

`klakix-mcp`, the stdio bridge shown above.`@klakix/mcp-server`, a stateless Streamable HTTP MCP server for the Web Fetch API. Tools use zod schemas, and there are hooks for scope checks, rate limiting and logging, plus an SSRF-safe media fetcher. It runs on Node, Next.js, Hono, Bun, Deno and Cloudflare Workers.`@klakix/mcp-oauth`, an OAuth 2.1 authorization server for remote MCP servers: PKCE S256, dynamic client registration (RFC 7591), client ID metadata documents, RFC 8414 and RFC 9728 metadata, refresh token rotation with reuse detection, and revocation. It is storage-agnostic and has no dependencies.`examples/self-hosted`, a complete server with OAuth sign-in and demo tools that you can run locally.
To be precise about the boundary: the protocol layer, the OAuth server, the bridge and the client configs are open. The generation backend (model routing, pricing, moderation, storage) is part of the hosted service and is not in the repo.

If you want a server of your own, this is the smallest useful version:

``` js
import { createMcpHandler, defineTool, toolOk } from "@klakix/mcp-server";
import { z } from "zod";

const echo = defineTool({
  name: "echo",
  title: "Echo",
  description: "Returns the text you send.",
  inputSchema: z.object({ text: z.string() }),
  handler: async ({ text }) => toolOk(text, { text }),
});

export const mcp = createMcpHandler({
  serverInfo: { name: "my-server", version: "1.0.0" },
  tools: [echo],
  authenticate: async (request) =>
    request.headers.get("authorization") === `Bearer ${process.env.API_KEY}`
      ? { id: "me" }
      : null,
});

// Any Fetch API runtime: export default { fetch: mcp.handle }
```

And to try the full example with OAuth locally:

```
git clone https://github.com/klakix-ai/klakix-mcp.git
cd klakix-mcp
npm install
npm run build
npm start -w examples/self-hosted
claude mcp add --transport http demo http://localhost:8787/mcp
```

If something in the setup does not work for your client, open an issue on the repo. I read them.
