VideoGen

@videogen/mcp

A Model Context Protocol (MCP) server that exposes the full VideoGen API to any MCP client (Cursor, Claude Desktop, Windsurf, etc.). Your agent can generate videos from scripts, produce images / voiceovers / music / avatars, upload files, export and remix projects, and manage runs — all authenticated with your own API key.

Learn more about the VideoGen MCP server.

Find the hosted server on Smithery.

ChatGPT

The hosted plugin includes a VideoGen home sidebar app (open_home). It follows the product home: the general creation prompt and suggestions, recent projects, example categories, featured workflows, reusable assets, and templates. Browsing does not start generation; Start sends the draft into a ChatGPT conversation. Project and library links open the matching VideoGen environment.

The home catalog is generated from the same helpers as frontend/ and committed in web/homeCatalog.ts, keeping the standalone MCP/npm/Docker build independent of internal packages. After changing the product catalog, refresh it from the repo root with cd api && node --import tsx scripts/generate-chatgpt-home.ts (with current base/defs/static JS builds). build:js bundles the page alongside the existing upload and preview widgets. Deploy MCP and rescan the existing plugin before expecting the sidebar entry to be available in ChatGPT.

Home-specific checks (no browser or live account required):

cd mcp

node --import ./test/register.mjs --test src/homeWidget.test.ts test/homeBridge.test.mjs cd ../api TSX_TSCONFIG_PATH=../mcp/web/tsconfig.json node --import tsx --test ../mcp/test/homePage.test.tsx

Use the public VideoGen plugin on the ChatGPT Plugins Directory. That is the supported way for every user to run VideoGen in ChatGPT.

The /mcp/chatgpt endpoint, ChatGPT Apps commerce notes, open_uploader widget, and the connector checklist later in this file are for internal testing of that plugin.

It ships in two transports. Tool surface is the same except for the internal-testing ChatGPT Apps surface (see above):

• Local (stdio) — the client launches @videogen/mcp as a subprocess and reads the key from VIDEOGEN_API_KEY.
• Remote (Streamable HTTP) — a hosted, multi-tenant HTTP server. Clients connect over the network and authenticate per request with Authorization: Bearer ; no key lives on the server.

Host surfaces (remote): /mcp (and stdio) is the STANDARD surface: when the user is out of credits or needs a plan feature, tools and guidance walk them into get_app_deep_link (OPEN_UPGRADE / OPEN_PURCHASE_CREDITS / OPEN_ENABLE_TOP_UPS). /mcp/chatgpt is an internal-testing ChatGPT Apps surface for the public plugin: those commerce deep links are omitted, billing errors are rewritten to “manage your VideoGen account,” and copy never says purchase / buy / upgrade / top-ups (OpenAI Plugins digital-goods policy). See .cursor/rules/chatgpt-mcp-no-commerce.mdc and mcp/src/hostSurface.ts.

This is distinct from the hosted documentation MCP at https://docs.videogen.io/_mcp/server, which only lets clients read the API docs. This server actually _executes_ the API.

How it works

• Wraps the official @videogen/sdk and calls the live API through the SDK's authenticated passthrough.
• The local transport reads your key from VIDEOGEN_API_KEY; the remote transport reads it from each request's Authorization: Bearer header and builds a fresh, per-request server bound to that team (stateless — no session state is shared between requests).
• The key never leaves your machine except in requests to the VideoGen API (local), or is forwarded only to the VideoGen API for the duration of the request and never persisted (remote).
• Long-running operations (workflows, media tools, project exports) use composite tools. The hosted HTTP transport returns the run/execution id immediately; use the corresponding get_* tool to continue polling. The local stdio transport waits for completion by default.

Configuration

Get an API key from app.videogen.io/api. Both transports expose the same tools; the remote server is recommended.

Remote (Streamable HTTP) — recommended

Nothing to install or update. Point any MCP client that supports the Streamable HTTP transport at the hosted endpoint and send your API key as a bearer token:

{

"mcpServers": { "videogen": { "url": "https://mcp.videogen.io/mcp", "headers": { "Authorization": "Bearer sk_videogen_live_..." } } } }

The remote server:

• Accepts MCP JSON-RPC messages via POST /mcp (stateless — a fresh server per request).
• Reads the API key or OAuth access token from the Authorization: Bearer header. The standard /mcp endpoint requires credentials for every request and returns 401 with a WWW-Authenticate challenge to start OAuth. The internal-testing /mcp/chatgpt endpoint serves tool discovery unauthenticated and returns its OAuth challenge on a protected tool result because ChatGPT does not start OAuth from the standard transport challenge. The credential is forwarded only to the VideoGen API and never stored.
• Exposes GET /health for load-balancer / Cloud Run startup probes.
• Handles CORS preflight (OPTIONS) so browser-based clients can connect.
• Supports three upload paths. For small assets (images, logos, short audio), upload_file takes base64-encoded contents inline (fileData). For large files, create_file_upload returns { fileId, uploadUrl }; the client PUTs the raw bytes to that short-lived pre-signed URL (no Authorization header) and then calls get_file with { fileId, wait: true } to wait for processing. On the internal-testing /mcp/chatgpt surface, open_uploader renders an in-chat upload widget so the user can pick a file directly, or pass photos they already attached (files). The widget itself calls create_file_upload, PUTs the bytes client-side, and reports back only the resulting vg_file_... id, so the pre-signed URL is never surfaced to the model. On that surface upload_file and create_file_upload are hidden from the model (ui.visibility is app only): a filename does not upload a ChatGPT attachment, and the server never fetches the attachment URL. Either way you get a vg_file_... id to pass to other tools. The local (stdio) server instead uploads by local filePath. (The server never fetches a caller-supplied URL, so there is no SSRF surface.)

Local (stdio) — Cursor / Claude Desktop

Runs as a subprocess launched by your client with npx. Reads the API key from the VIDEOGEN_API_KEY environment variable, which never leaves your machine except in requests to the VideoGen API:

{

"mcpServers": { "videogen": { "command": "npx", "args": ["-y", "@videogen/mcp"], "env": { "VIDEOGEN_API_KEY": "sk_videogen_live_..." } } } }

Environment variables

Tools

See the callable tool reference and complete input/output JSON schemas for 50 live hosted tools. The schema snapshot is captured from MCP tools/list; use discovery on your connected server for the latest definitions.

Workflows (end-to-end video)

script_to_video, voiceover_to_video, slideshow_to_video, storyboard_to_video, list_workflow_runs, get_workflow_run, cancel_workflow_run

Media tools

generate_image, generate_video_clip, text_to_speech, generate_sound_effect, generate_music, generate_avatar, vectorize_image, remove_image_background, remove_video_background, upscale_image, upscale_video, image_3d_effect, list_tool_executions, get_tool_execution, cancel_tool_execution

Projects

list_projects, get_project, export_project, get_project_export, remix_project, list_project_remix_actions

Files

upload_file, create_file_upload, get_file, list_files, open_uploader

open_uploader is a widget on the internal-testing /mcp/chatgpt surface (remote server only): it renders an in-chat file picker (a React component served as an MCP UI resource) so a ChatGPT user can attach a file without pasting a link. Pass photos already attached in the chat as files. It is a no-op on clients that don't render MCP Apps UI. Those use upload_file / create_file_upload instead. ChatGPT users should use the public VideoGen plugin.

Entities

list_entities, create_entity, get_entity, update_entity, archive_entity, add_entity_reference, remove_entity_reference

Create ACTOR / PRODUCT / VISUAL_STYLE entities, attach uploaded image references, then pass vg_enti_... ids into workflows and generate_avatar (actorEntityId; on storyboard_to_video, per-scene productEntityIds / actorEntityIds / visualStyleEntityId).

Resources & account

list_tts_voices, list_languages, get_me, get_app_deep_link

Guidance (docs for agents)

Operational manuals exposed as MCP resources and mirror tools (no API credential required):

Call the matching get_*_guidance tool before non-trivial setup, polling, workflow/remix/export, or tools-vs-workflows decisions. Many hosts never auto-attach resources; the tools are the reliable path. Content is grounded in the public docs at docs.videogen.io but written for