transcribeinputReturns a timestamped transcript for a video URL or uploaded file. Every other tool builds on this.
{ video_url, language? }
An MCP server gives Claude, Cursor and other AI agents a set of video tools they can call directly: find the best moments in a long video, cut them, reframe to vertical, add captions and hand back a finished short. This page explains how clipping MCP servers work, what tools they expose and how to connect one.
The Model Context Protocol (MCP) is an open standard for connecting AI models to external tools and data. An MCP server is a small program that advertises a list of tools, each with a name, a description and a JSON schema for its inputs. The AI agent reads that list, decides which tool fits the task, calls it with structured arguments and gets a structured result back.
A clipping MCP server exposes video work as those tools. Instead of you opening an editor, the agent can transcribe a two-hour podcast, score the segments for hook strength, cut the top ones, reframe them to 9:16 and burn in captions, all through tool calls it chooses itself.
Four messages between the agent and the server turn a sentence into finished shorts.
On connection the client sends tools/list. The server answers with every tool it offers and the schema for each, so the model knows that find_moments takes a video URL and a count, and that cut_clip needs start and end times.
Given "clip the best three moments from this episode", the model picks find_moments and sends tools/call with {"video_url": "…", "count": 3}. The server validates the arguments against the schema before doing anything.
Transcription, moment scoring, cutting and rendering happen on the server side. Long jobs report progress through MCP notifications so the agent can keep the user informed instead of waiting silently.
The response is data, not a chat message: clip URLs, start and end times, a hook score and the transcript for each. The agent can summarise it, pass it to the next tool, or ask you which ones to publish.
Names vary by server. This is the common shape of a clipping toolset, with the arguments an agent sends.
transcribeinputReturns a timestamped transcript for a video URL or uploaded file. Every other tool builds on this.
{ video_url, language? }
find_momentsaiScores segments for hook strength, emotion and completeness, and returns the top candidates with reasons.
{ video_url, count, min_s?, max_s? }
cut_clipeditCuts a single clip between two timestamps, with optional padding so sentences aren't chopped mid-word.
{ video_url, start, end, pad_s? }
reframeaiConverts 16:9 to 9:16 or 1:1, tracking the active speaker so faces stay in frame.
{ clip_id, aspect: "9:16" | "1:1" }
add_captionseditBurns in word-level captions with a chosen style; returns a new clip ID.
{ clip_id, style?, highlight_words? }
exportoutputRenders the final MP4 at platform presets (TikTok, Reels, Shorts) and returns a download URL.
{ clip_id, preset, filename? }
Illustrative tool names. ClippingNet's own MCP server is in development; check the API page for current status.
Most clients read a JSON config that names each server and how to start or reach it. A local server runs over stdio (the client launches it as a child process); a hosted one is reached over HTTP with an API key. Add the block, restart the client, and the tools appear in the agent's tool list.
claude_desktop_config.json under mcpServers.claude mcp add <name> … or .mcp.json in the project..cursor/mcp.json or the MCP settings pane.Keep API keys in environment variables rather than in the config file when the project is shared.
{
"mcpServers": {
"clipping": {
"command": "npx",
"args": ["-y", "@example/clipping-mcp"],
"env": {
"CLIPPING_API_KEY": "${CLIPPING_API_KEY}"
}
},
"clipping-hosted": {
"url": "https://mcp.example.com/clipping",
"headers": {
"Authorization": "Bearer ${CLIPPING_API_KEY}"
}
}
}
}You describe the outcome. The model chooses the sequence of tools, handles retries and hands you clips to approve, rather than you clicking through a timeline.
Write the server once and it works in Claude, Cursor and any other MCP client. A bespoke API wrapper has to be rebuilt per tool.
Point the agent at a channel, a playlist or a folder of VODs and let it clip overnight. Clipping campaigns reward volume, and agents don't get bored.
Every tool has a schema. Bad arguments are rejected before a render starts, and results come back as structured data the agent can act on.
Chain with other servers: fetch from Drive, clip, caption, then schedule posts. The agent carries context between them without copy-paste.
Pair it with the earnings calculator: if a campaign pays per 1K views, an agent that produces ten clips an hour changes the maths.
No. The model only sees tool descriptions, the arguments it sends and the text results that come back. The video itself goes to the clipping server (local or hosted), never into the model's context.
Yes, if the server ships as a package that runs over stdio. Transcription and rendering then happen on your machine, which keeps footage private but needs a reasonably fast CPU or GPU.
Claude Desktop, Claude Code, Cursor, Windsurf, Zed, and a growing list of agent frameworks. Any client implementing the MCP spec can use any MCP server.
An API is for code you write. An MCP server is for an AI agent to use on your behalf; it wraps the same capabilities in a form the model can discover and call by itself. Most providers ship both.
It's in development alongside the clipping API. The API page has the current status and the planned job model (submit a video, get a job ID, receive clips by webhook).