Generate AI UGC videos from Claude, ChatGPT or Cursor with MCP

Short answer: add https://mcp.kreavo.ai/mcp as a remote MCP server in your client, sign in once through OAuth, and ask for a video. The model calls kreavo_generate_video, gets back an ID, then polls kreavo_check_video_status until a video URL comes back. On the default settings (5 s, 720p) that costs 140 credits, or $1.40.

MCP in three lines

The Model Context Protocol is a standard way for an LLM client to discover and call tools exposed by a server. The client lists the tools, the model decides when to call them, and the server does the work. Here the server is remote: it speaks Streamable HTTP and uses OAuth, so you don't install a package or paste an API key.

Setup

Claude Code

claude mcp add --transport http kreavo https://mcp.kreavo.ai/mcp

Or commit it to a project-level .mcp.json (Claude Code asks you to approve project servers the first time):

{ "mcpServers": { "kreavo": { "type": "http", "url": "https://mcp.kreavo.ai/mcp" } } }

Claude Desktop / claude.ai

1. Settings → Connectors
2. "Add custom connector"
3. Name Kreavo, URL https://mcp.kreavo.ai/mcp
4. Connect, then sign in with your Kreavo account

On Team and Enterprise plans, an owner adds the connector first from Admin settings → Connectors.

ChatGPT

There is no listed Kreavo plugin in ChatGPT yet, so you add the server by hand. At the time of writing, that means going to the Plugins page (chatgpt.com/plugins), clicking the plus button, choosing "Add custom MCP server", entering https://mcp.kreavo.ai/mcp as the public endpoint and picking OAuth for authentication. Earlier versions put this under Settings → Connectors, with developer mode turned on, and workspace policies can require an admin to allow custom servers. ChatGPT renames these menus fairly often, so look for "custom MCP server" or "Connectors" wherever the current screen puts them.

There are a few differences when you use it from ChatGPT. Tools that spend credits are flagged as destructive, so ChatGPT asks you to confirm before each paid generation. The model parameter is limited to a shorter list. Requests for sexual content or nudity are blocked before anything is created or charged. Images you attach in the chat are accepted as inputs.

Cursor

~/.cursor/mcp.json (global) or .cursor/mcp.json (project):

{ "mcpServers": { "kreavo": { "url": "https://mcp.kreavo.ai/mcp" } } }

VS Code

.vscode/mcp.json in the workspace, or your user mcp.json (command "MCP: Open User Configuration"):

{ "servers": { "kreavo": { "type": "http", "url": "https://mcp.kreavo.ai/mcp" } } }

What the login looks like

The first time the client calls the server, it gets a 401 that points it to the OAuth metadata. It then opens your browser on a consent screen titled "Connect Claude" (or ChatGPT, Cursor, VS Code…), with the account email and "Authorize" / "Cancel" buttons. If you aren't signed in to Kreavo in that browser, you sign in first and land back on that screen. The flow uses PKCE (S256) with dynamic client registration. Access tokens last 7 days. Refresh tokens last 90 days and change each time they're used. If the confirmation page opens in a different browser (for example from a mail app), it tells you to finish in the browser that started the flow. That's on purpose: the request is tied to that browser.

A real conversation, step by step

Prompt in Claude Desktop, with a link to the product photo (here, the image URL from the product page):

Make a 5-second vertical UGC-style clip of the serum bottle in this photo: https://… — a woman picks it up from a bathroom shelf, smiles at the camera, natural daylight. Check what it costs first.

The tool calls, shortened (IDs and URLs removed):

→ kreavo_list_models
← table of models with a "Credits" column (seedance-2-fast: 140 for 5 s at 720p)

→ kreavo_generate_video {
    "prompt": "A woman picks up the serum bottle from a bathroom shelf, smiles at the camera, handheld phone footage, natural daylight",
    "image_url": "<product photo URL>",
    "model": "seedance-2-fast",
    "duration": 5,
    "resolution": "720p",
    "aspect_ratio": "9:16"
  }
← Video ID: <id>. Use kreavo_check_video_status with task_id=<id>

→ kreavo_check_video_status { "task_id": "<id>" }
← Video Still Processing ⏳ … Try again in 15-30 seconds

→ kreavo_check_video_status { "task_id": "<id>" }
← Video Ready ✅ <video URL>

The video also shows up in the account's gallery on kreavo.ai, so you don't have to save the URL yourself.

Why a URL and not an attached photo? In Claude and Cursor, the model can see an image you attach, but it can't hand that file to a tool. kreavo_upload_image exists for local files: it takes the image as base64 text and returns a public URL. Since the model has to write that whole base64 string into the call, it's only practical for small files, for example from Claude Code. For anything bigger, give a public https link to the image. ChatGPT is the exception: images attached in the chat are passed to the tools as files.

How the async part works

Video generation takes minutes, which is longer than you'd want one tool call to stay open. So the three video tools (kreavo_generate_video, kreavo_generate_product_video, kreavo_control_motion) return an ID right away along with an explicit instruction to poll. The model reads that instruction and calls kreavo_check_video_status, which answers in one of three ways:

• Still Processing: wait 15–30 s and call again.
• Ready: the video URL, sent as text. MCP has no video content type, so you get a link and not an inline player.
• Failed: a short reason tag such as moderation:content_policy (every video failure comes back in this moderation:<reason> form). Failed generations are refunded.

Most image models answer synchronously. The image comes back inline if it's 950 KB or less, otherwise you get just the URL. gpt-image-2 is the exception: it returns a task ID, and you poll kreavo_check_image_status the same way.

If your agent loops by itself, give it a rule like "wait about 20 seconds between status checks". Otherwise some clients poll too eagerly and burn through the rate limit.

Costs and limits, honestly

1 credit = $0.01. These are the live prices from the billing functions as of November 2026:

Other tools: kreavo_create_character costs 50 credits, kreavo_virtual_tryon costs 55 (paid plans only), and kreavo_control_motion costs 9 credits per second at 720p or 14 per second at 1080p, based on the length of the reference video (3 to 30 s, rounded up to the next second).

Things to know before you give an agent this server:

• No price prompt before a charge. The generation tools spend credits straight away. Every paid tool's description says it spends credits and points to kreavo_list_models, but checking the price is up to the model, or up to you in the prompt. ChatGPT is the exception because it asks for confirmation.
• Video length: 4–15 s for most models. Seedance 2.5 goes up to 30 s, Kling 3.0 starts at 5 s, Kreavo Motion is 5 or 8 s, and Veo 3.1 is fixed at 8 s.
• Rate limit: 120 requests per minute per account. Above that you get 429.
• Uploads: PNG, JPEG, WebP or GIF, up to 10 MB each, 30 uploads per hour, 200 files and 200 MB per day.
• Sessions: closed after 24 h without activity. Clients reconnect on their own.
• Not enough credits: the tool returns an error that says so and nothing is charged. Video needs a paid plan or the $1 trial.

Three workflows that work well

1. Ten ad angles for one Shopify product. Give the agent the product page and ask for 10 hooks: problem/solution, unboxing, before/after, "POV: you finally found…", and so on. It takes the product photo URL from the page, then calls kreavo_generate_video ten times with different prompts and polls each ID. At 5 s / 720p on seedance-2-fast that's 1,400 credits ($14) for ten clips you can test as ads.

2. A consistent AI influencer. kreavo_create_character (50 credits) once, kreavo_list_scenes to choose sets (studio, lifestyle, travel…), kreavo_generate_photoshoot for stills in each scene, then kreavo_generate_product_video with the character_id, a product image and a script. The same face shows up in every asset, which you can't count on when each clip is prompted from scratch.

3. Assets from your editor. In Cursor or VS Code, have the agent read a product JSON in your repo and generate a set of images with gpt-image-2 (8 credits each), or catalog shots with kreavo_virtual_tryon, while you work on the storefront code. The URLs come back into the conversation, so the agent can write them straight into your fixtures.

Wrapping up

MCP turns "make me a video" into a few typed tool calls: generate, then poll. Your client handles auth and decides when to call each tool. The tools are the same in Claude, ChatGPT, Cursor and VS Code (ChatGPT adds the checks described above), so whatever prompts and agent loops you write carry over from one client to another.

If you want to try it, the setup page is kreavo.ai/mcp. New accounts get 150 free credits for images, and video starts with a $1 trial.