dev.clipkit/clipkit MCP Server
dev.clipkit/clipkit
AI-powered video generation from structured JSON—render MP4s via the ClipKit Protocol.
What this kind of tool is for
- Automate a build, test, or deployment step you repeat by hand.
- Review or refactor code in an existing repository without leaving your agent.
- Bridge an internal service or CLI into the agent toolset.
How to compare servers like this
- Scope of control:
- Repos and CI are hard to undo; prefer tools that ask before anything irreversible.
- Environment fit:
- Match the runtime it expects (Node, Python, a container) to what you actually run.
- Maintenance signal:
- Check the last-commit date — dev tooling that lags upstream breaks first.
- Config surface:
- Prefer tools whose environment-variable or config keys are documented plainly.
This page carries your copy-paste config: pick your MCP client in the install section on this page and use the copy button.
What is the dev.clipkit/clipkit MCP server?
The ClipKit MCP server enables AI agents to author, validate, and render videos by describing them as structured JSON data (the ClipKit Protocol). It turns timeline definitions into GPU-rendered MP4 files, with support for local rendering via headless Chrome or cloud GPU acceleration.
ClipKit is a video infrastructure platform designed for AI agents. Instead of using traditional video editors, you describe a video as a JSON timeline following the ClipKit Protocol, and the system renders it to MP4. The MCP server integration lets Claude, Cursor, and other agents build and render videos programmatically, making it ideal for automated video generation, motion graphics, and content creation workflows.
How to install dev.clipkit/clipkit
Copy-paste configuration for popular MCP clients.
{
"mcpServers": {
"clipkit": {
"url": "https://www.clipkit.dev/mcp"
}
}
}Tools & capabilities
Tools this server exposes to the agent.
render— Render a ClipKit Protocol document (JSON timeline) to MP4 video, with options for local rendering or cloud GPU accelerationvalidate— Validate a ClipKit Protocol document against the schema and provide plain-language error summariespreview— Generate a preview or playback of a video timeline before final renderingauthor— Help construct and edit ClipKit Protocol documents (JSON timelines) with proper structure and syntax
Use cases
- Generate promotional videos or demo clips from structured data without manual editing
- Automate video creation workflows where an AI agent describes scenes, transitions, and effects as JSON
- Create motion graphics and animated content by defining keyframes and compositions in the ClipKit Protocol
- Build video content at scale by templating timelines and rendering variations programmatically
- Transcribe audio to captions and synchronize them with video timelines using speech-to-text integration
dev.clipkit/clipkit MCP server FAQ
It's an MCP server that gives AI agents the ability to author, validate, and render videos by describing them as JSON documents (the ClipKit Protocol). Agents can build video timelines and render them to MP4 files.
The CLI and MCP server are free. Local rendering via headless Chrome is free; cloud GPU-accelerated rendering (for ProRes, AV1, and transparent output) is a paid service.
Point your agent at the MCP server endpoint (https://www.clipkit.dev/mcp for remote, or run `npx -y @clipkit/cli mcp` locally). See clipkit.dev/docs/mcp for agent-specific quickstarts.
Local rendering produces MP4 with H.264. Cloud rendering adds ProRes, AV1, and transparent video output options.
Local rendering requires no auth. Cloud rendering requires a ClipKit account; check clipkit.dev for pricing and signup.
The runtime is under the Business Source License 1.1 (converts to Apache-2.0 after 4 years). You can use it freely for your own products and customers, but cannot offer a competing hosted ClipKit-rendering service.
README (reference)
Source of truth, from the repository.
ClipKit
The video infra for agents. ClipKit turns a JSON timeline — the open ClipKit Protocol — into rendered video on the GPU. Describe a video as structured data; get an MP4. Built for AI agents and the developers shipping them.
clipkit.dev · Docs · Protocol · Agent quickstarts
https://github.com/user-attachments/assets/ff4b7e9b-2e0a-40f4-a6a1-042e981fc65f
<p align="center"><sub><b>↑ Made with ClipKit.</b> Every frame of this promo was rendered from a ClipKit Protocol document — no editor, no timeline UI, just structured data. <a href="https://api.clipkit.dev/storage/v1/object/public/remote-assets/clipkit-promo.mp4">▶ Play</a> if it doesn't load inline.</sub></p>Quick start
npm install -g @clipkit/cli
clipkit new my-video.json # scaffold a Source
clipkit render my-video.json -o out.mp4 # render locally (headless Chrome)
…or from code:
import { render } from '@clipkit/renderer';
import { writeFile } from 'node:fs/promises';
const { buffer } = await render({ source }); // source = a ClipKit Protocol document
await writeFile('out.mp4', buffer);
Local rendering uses your installed Google Chrome (for WebCodecs). For GPU-accelerated
and pro-format (ProRes / AV1 / transparent) output, render on the hosted service with
clipkit render --cloud.
What's here
A monorepo; each package publishes to npm under the @clipkit scope.
| Package | What it is |
|---|---|
@clipkit/protocol | the ClipKit Protocol — schema, types, validation |
@clipkit/runtime | the engine — WebGPU/WebGL2 compositor + WebCodecs encoder |
@clipkit/renderer | render a Source to MP4 locally (headless Chrome) |
@clipkit/editor | a configurable, embeddable editor over the schema |
@clipkit/editor-core | the editor's UI-free data layer |
@clipkit/playback | browser playback engine |
@clipkit/patterns | composable motion-graphics units |
@clipkit/sfx | procedural sound-effects synthesis |
@clipkit/music-analysis | beat / tempo analysis for authoring |
@clipkit/speech-to-text | transcription → captions |
@clipkit/lint | protocol-aware validation + plain-language summaries |
@clipkit/mcp-server | an MCP server so agents can author + render video |
@clipkit/cli | the local-first CLI |
For AI agents
ClipKit ships an MCP server — point your agent at it and it can build, validate, preview, and render ClipKit videos:
npx -y @clipkit/cli mcp # stdio MCP server
See the agent quickstarts for Claude, Cursor, and more.
License
Apache-2.0 — except @clipkit/runtime, which is under the
Business Source License 1.1 and converts to Apache-2.0 four years after
each release. In plain terms: use it, embed it, build your own product on it, and render
for your own customers — all free. The one thing you can't do is offer a competing
hosted ClipKit-rendering service. See LICENSING.md and
TRADEMARK.md.
Related MCP servers

Cloudgate Workflow
Build and manage Cloudgate workflow-APIs: controllers, actions, workflow graphs, and databases.
Format/lint JS, Python, HubL for automation platforms. Tools: format_code, format_json, ask_codefmt

codeitall
Behavioral oracle for Rust crate APIs: runtime behavior, yank/advisory, deprecation, sig search

Code Pathfinder
Open-source SAST engine with cross-file dataflow analysis for Python, Go, and Docker security scanning.
cloro
Scrape AI answer engines and Google Search/News with country and state-level geo-targeting.
