MCP server#

Clipkit ships a hosted MCP connector — add it to Claude (or Cursor, Codex, Gemini, Cline…) by URL and the model authors video projects directly through tool calls instead of generating JSON in chat. No install, no sign-in, no key for free authoring.

Under the hood it's a thin wrapper around @clipkit/protocol: every mutation runs through the same validator the runtime uses, so an agent can never advance a project into a state the renderer would reject.

Get started#

Add this URL as a custom MCP connector:

https://www.clipkit.dev/mcp

That's the whole setup. The endpoint:

• speaks the standard Streamable HTTP transport,
• runs sessionless (any request lands on any instance — see Projects and sessions),
• is open — no sign-in, no OAuth, and no API key for free authoring,
• works in web and desktop clients alike (nothing runs on your machine).

Pick your client below for a copy-paste quickstart.

Connect your agent#

One-step quickstarts for every major MCP client — same URL each time, wired the way that client expects:

Client	Quickstart
Claude Code (CLI)	Connect →
Claude Desktop	Connect →
OpenAI Codex (CLI)	Connect →
OpenAI API (Agents SDK / Responses)	Connect →
ChatGPT (Developer Mode)	Connect →
Grok (app + xAI API)	Connect →
Cursor	Connect →
Cline	Connect →
Gemini CLI	Connect →
Zed	Connect →
Nous Hermes	Connect →
MCP Inspector (verify it works)	Connect →
OpenClaw	Connect →

Using a client that isn't listed? Any MCP client works — add a remote server with URL https://www.clipkit.dev/mcp and pick the Streamable HTTP transport (not SSE).

Projects and sessions#

The hosted connector is sessionless: there's no per-connection memory, so a project is addressed by an explicit project_id.

• create_project, set_project, create_promo, and load_project each return a project_id.
• Pass that project_id to subsequent tools (add_element, edit_element, preview_still, …) to keep working on the same project.

Hosted projects are scratch state and expire after a period of inactivity. The durable artifacts are the editor link (open_in_editor) and renders (render_video) — or call get_project and store the JSON yourself.

Free, anonymous authoring needs no key. A CLIPKIT_API_KEY (Settings → API keys) is only required for the paid render_video path. Creating projects and rendering stills (preview_still) are free.

transcribe_to_captions is not on the hosted connector. It runs Whisper in a child process and needs ffmpeg on the host, neither of which exists in the hosted sandbox. Use the local server for transcription. (Hosted speech-to-text is on the roadmap.)

Tools#

Every stateful tool takes a project_id (see Projects and sessions). Validation is non-negotiable — every mutation hits @clipkit/protocol before being applied. Invalid edits return a structured error with the offending JSON path; valid edits commit atomically, so the agent never observes a half-applied project.

Resources#

The server publishes the canonical Clipkit reference docs as MCP resources, so any host that supports resource attachment can pull them into the model's context without web search.

Resources are embedded at the server's build time — the bytes you load are the bytes that shipped with the version of the server, never a live fetch.

Workflow#

A typical agent loop:

1. create_project — start with the right dimensions and duration; keep the returned project_id.
2. add_element once per element (text, shape, image, video, audio, caption), or set_project to author the whole composition at once.
3. edit_element to tune properties iteratively (color, position, font_size).
4. preview_still to SEE a frame; validate_project to confirm before exporting.
5. get_project to retrieve the final JSON.
6. open_in_editor for an editor link, or render_video for a finished MP4.

Schema reference#

See the protocol spec for the full element type catalog (video, image, text, shape, audio, group, caption, particles) and every field on every element.

Run it locally#

Prefer to run the server on your own machine — to keep project data local, self-host, or use transcribe_to_captions (which only works locally)? ClipKit also runs over stdio via npx, with no clone and no build:

npx -y @clipkit/cli mcp

You won't normally invoke it directly — configure your MCP host to launch it. Each agent quickstart carries the exact config for its client.

Hosted vs local#

Close, but not the same toolset:

"Local" describes where the project state and Whisper live. preview_still and render_video still call clipkit.dev in both modes — neither runs a renderer on your machine, so the local server is not an offline mode.

Hosts that connect from a vendor's servers — ChatGPT, the Grok app, the OpenAI Responses API mcp tool — can't launch a local process, so they're hosted-only.

Claude Desktop#

Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "clipkit": {
      "command": "npx",
      "args": ["-y", "@clipkit/cli", "mcp"]
    }
  }
}

Restart Claude Desktop. The Clipkit tools appear in the tools menu; the clipkit:// resources appear under the Resources picker.

Cursor / Zed / other hosts#

Use the same command + args pair. Any MCP host that speaks the stdio transport will work — see the agent quickstarts for per-client config keys.

Local differences#

• project_id is optional. A local server holds one implicit project per process, so you can omit project_id entirely.
• State is in-memory. It lives only for the server session and isn't persisted — call get_project and save the JSON, or open_in_editor, to keep your work.
• transcribe_to_captions works here, with two prerequisites: ffmpeg on your machine, and the Whisper engine — an optional peer the lean install skips. The first time you call it without the engine, it fails with the exact fix: npm i @huggingface/transformers (~350 MB, one-time).
• render_video works here, but it's still the paid cloud render — set CLIPKIT_API_KEY (a ck_live_… key from Settings → API keys) in the server's env, or the tool returns an error telling you to.
• ingest_asset is missing. Asset hosting is authenticated and team-scoped, so it only exists on the hosted connector. Reference media by URL instead.
• First run is light — the CLI installs lean (~50 MB); the ~350 MB Whisper runtime is an opt-in you only pull if you use transcribe_to_captions. npx caches the download after the first run.