Channel watcher
Cron reads a YouTube channel's RSS, submits each new video, webhook collects clips, top-scored go to a review folder. API. See automatic YouTube clipper.
Every serious AI clipper now exposes its pipeline two ways: a REST API for code you write, and an MCP server for AI assistants that call tools on their own. This page explains when to use which, the job model they all share (submit, poll or webhook, fetch clips, re-render), what each provider offers with limits and prices, working examples for both, and the gotchas that cost credits.
A clipping API is for code: you write the pipeline, decide every step, and call endpoints with a key. A clipping MCP server is for a language model: it advertises the same capabilities as typed tools, the model reads the schemas and decides which to call, and a human (or a guardrail) approves the irreversible ones. Under both sits the same engine and the same monthly quota.
Deeper on the MCP side: AI clipping MCP servers. On the agent loop: agents explained.
Clipping takes minutes, so no provider does it in one request. The shape is submit → wait → fetch → refine, whether you call it over REST or through MCP tools.
A source URL (YouTube, Twitch, S3, a public MP4) or an upload, plus config: clip-length band, count, ratio, caption template, sometimes a prompt. You get a job ID back immediately. Credits or a video slot are usually reserved here, not when clips are ready. (katto_create_clip_job, OpusClip projects, Klap inputs, Vizard submit.)
Poll GET /jobs/{id} every 30 seconds or so, or register a webhook and verify its signature (Katto exposes the secret via katto_get_webhook_secret; OpusClip and Klap offer webhooks; Vizard supports poll or webhook). Expect minutes to tens of minutes; longer for 4K. Handle a failed job as refundable (most providers refund the slot).
An array of clips: MP4 URL, start and end, score, title, captions or SRT URL, sometimes a reason and the transcript segment. Filter by score, dedupe overlapping ranges, and store the metadata; download URLs often expire (lifetime is rarely documented).
Change ratio or caption style, dub to another language, export to a platform preset or an NLE timeline. Katto's re-renders and dubs are free of quota; Klap charges $0.48 per export; OpusClip charges credits for Agent Opus output but not for most re-renders. Know which before an agent loops on "try again".
Some APIs post or schedule (OpusClip scheduler API on Pro; Katto via its app and REST). Over MCP, publishing typically needs a confirmation link or host approval (OpusClip's connector requires one). Keep posting behind a human until the brand rules are encoded; one missed hashtag voids a campaign clip.
From each vendor's docs as reviewed on this site. Rate limits and caps are the published ones; test before relying on them.
| Provider | REST API | MCP | Auth | Limits / cost | Sources | Review |
|---|---|---|---|---|---|---|
| Katto | OpenAPI 3.1, webhooks, all plans incl. Free | Hosted mcp.katto.tech/mcp + local npx katto-mcp; 16 tools; CLI too | OAuth 2.1 (hosted) / API key | Per video; re-renders & dubs free; Free 2, Solo 10, Creator 25 videos | YouTube, Twitch, Vimeo, Rumble, Zoom, Dailymotion | Read |
| OpusClip | Projects, clips, templates, posting, webhooks, transcripts, exports; Pro (beta), Max, Business | Hosted mcp.opus.pro/mcp, OAuth, 26 tools; Claude connector (workflow only) | API key / OAuth | 30 req/min; 900 credits or 15 h per workspace/month; 4 concurrent; 10-credit project minimum | 20+ incl. public MP4 URLs | Read |
| Klap | Usage-priced, any plan; inputs, shorts, exports | — | API key | $0.44 / input · $0.32 / short · $0.48 / export; 5 h long-to-short; webhooks/rate limits thinly documented; base URL inconsistent in examples | YouTube, S3, GCP, public URLs (Drive, Twitch "soon") | Read |
| Vizard | Submit + poll/webhook; up to 100 clips/job, 4 ratios; paid plans | — | API key | Creator 3 req/min, 20/h; Business 10/min, 60/h; v2 clipping ≈ 1.25× credits | 13 incl. YouTube, Drive, Vimeo, StreamYard, TikTok, X, Twitch, Loom | Read |
| SupoClip | REST with API keys, self-hosted (localhost:8000, /docs) | Server in repo mcp/, self-hosted | API key (yours) | No quotas; your AssemblyAI + LLM usage; AGPL-3.0 | Upload (self-host); links on hosted | Read |
| ClipTalk | — | Hosted cliptalk.pro/mcp, OAuth 2.1, 22 tools; video creation, not clipping | OAuth 2.1 PKCE | Credits; estimate_cost dry run; failed gens refunded | Public links via import_media | Read |
| Submagic | Business + API ($69/mo) with minute packs | — | API key | 250 min $57 · 500 $75 · 1,000 $150 · 10,000 $1,000 | Upload | Read |
| ClipForge · Quso · StreamClipping · CapCut | None published | — | — | — | — | All reviews |
ClippingNet's own API is in development (job ID on submit, webhook delivery, clip specs); see the API page for status. For a scored comparison see AI clipping API comparison.
Left: a REST pipeline in three calls (shape is generic; field names vary by provider). Right: connecting an MCP server so an assistant can do the same thing from a sentence.
done → fetch clips → filter by score ≥ 80 → download.{
"mcpServers": {
"katto": { "url": "https://mcp.katto.tech/mcp" },
"opusclip": { "url": "https://mcp.opus.pro/mcp" },
"cliptalk": { "url": "https://www.cliptalk.pro/mcp" }
}
}
// Claude Code: claude mcp add --transport http katto https://mcp.katto.tech/mcp# 1. submit
JOB=$(curl -s -X POST "$API/jobs" \
-H "Authorization: Bearer $CLIP_API_KEY" \
-H "Content-Type: application/json" \
-d '{"url":"https://youtube.com/watch?v=…",
"clip_length":"30-60s","count":6,
"aspect":"9:16","captions":"bold"}' | jq -r .id)
# 2. poll (or register a webhook instead)
until [ "$(curl -s "$API/jobs/$JOB" \
-H "Authorization: Bearer $CLIP_API_KEY" | jq -r .status)" = "done" ]
do sleep 30; done
# 3. fetch, filter by score, download
curl -s "$API/jobs/$JOB/clips" -H "Authorization: Bearer $CLIP_API_KEY" \
| jq -c '.[] | select(.score >= 80)' \
| while read c; do
curl -s -o "review/$(echo $c | jq -r .id).mp4" "$(echo $c | jq -r .mp4_url)"
doneCron reads a YouTube channel's RSS, submits each new video, webhook collects clips, top-scored go to a review folder. API. See automatic YouTube clipper.
Claude or Cursor with Katto or OpusClip MCP: paste a link, describe the angle, approve the three it picks. MCP, L2 autonomy.
One API integration, per-client brand templates and briefs, clips filed per client, a scheduler for posting. API, with MCP for ad-hoc requests.
SupoClip on your box with Ollama, its MCP server connected to Claude Code, nothing leaves the network. MCP + local API.
Most providers charge on source length when the job starts, not when clips are usable. Narrow the range (where supported) and estimate first (estimate_cost, dry-run tools).
Vizard Creator is 3 requests a minute; OpusClip 30/min and 4 concurrent jobs. Batch jobs, back off on 429, and don't poll every second.
OpusClip caps API use at 900 credits or 15 hours per workspace per month, separate from plan credits, and enforces a 10-credit minimum per project. Plan around it.
Lifetime is rarely documented. Download on fetch and store the metadata yourself; don't link to vendor URLs from your own system.
Use the signing secret and reject unsigned calls; an open webhook endpoint is an invitation to spoof "done" with someone else's URL.
A file dropped into Claude isn't visible to the server. Share a public link or use an upload tool with a file path; private or age-restricted posts won't import.
Katto: REST, CLI and MCP on the free plan (2 videos a month), €4.90/month annual for 10. SupoClip is free if you self-host. Klap's usage pricing (about $8.44 for a 90-minute source with 10 exported shorts) suits sporadic use with no subscription.
Katto (hosted and local, 16 tools), OpusClip (hosted, 26 tools, Pro+), SupoClip (self-hosted), and ClipTalk (hosted, 22 tools, but for generating videos rather than clipping). Klap, Vizard and Submagic are API-only.
OpusClip's scheduler API on Pro and Katto's REST publishing can; Klap and Vizard return files for you to post. Over MCP, posting is usually gated behind a confirmation. Keep it human until the brief's rules are fully encoded.
Minutes to tens of minutes. Vizard quotes roughly ten minutes for a 30-minute talking-head video; Klap's and OpusClip's are similar; 4K and long sources take longer. Design for asynchronous completion.
Only if a model will choose the steps. For a fixed pipeline, the API is simpler and more controllable. Many teams add MCP later for one-off briefs and exploration. See clipping MCP servers.