ClipSpeedAI MCP in Cursor: Connect the Clipping Engine to Your Editor Agent

The endpoint is ClipSpeedAI's; the config file is Cursor's

Two values on this page are guaranteed by ClipSpeedAI and will not drift:

• The server URL: https://api.clipspeed.ai/mcp, spoken over streamable HTTP.
• The credential header: Authorization: Bearer <your API key>.

Everything wrapped around those two values belongs to Cursor. Which file it reads, what the top-level object is called, whether headers go in a nested map, whether a graphical panel writes the file for you — those are the client's business, they have changed shape across MCP-capable editors, and this page does not print a filename it cannot vouch for. Add ClipSpeedAI as a remote HTTP MCP server following Cursor's MCP documentation, and when their schema asks for a URL and a set of headers, supply the two values above verbatim. If a future Cursor release renames a key, the documentation is right and this page is stale; the URL and the header are the parts that survive.

Support tier, stated the way ClipSpeedAI states it rather than the way a vendor page would like to. There are three bands. Claude Code, Claude Desktop, Windsurf and Claude on the web have been exercised end to end and sit in the top band. Cursor sits in the second: compatible, verification in progress. Codex, OpenClaw and Hermes share that band. ChatGPT is behind them in a third band, gated on its own vendor's rollout.

What compatible actually buys you: Cursor speaks the same MCP protocol and uses the same HTTP-plus-Bearer transport as every other client on the list, so the connection path is not experimental. What it does not buy you: ClipSpeedAI has not run end-to-end verification on Cursor, so on an unusual failure you have less certainty than you would on a verified client. That asymmetry has one practical consequence, and it appears twice more in this guide — when something behaves strangely, reproduce it somewhere verified before concluding the server is at fault. ClipSpeedAI MCP for Windsurf: Complete Setup Guide covers the closest verified equivalent, an editor reached through a config file rather than a consent screen.

If you remember life before language servers, you already know MCP

Editors solved this exact problem once already. Before the Language Server Protocol, every editor shipped its own Python integration, its own Go integration, its own TypeScript integration, and each one rotted at a different rate. LSP replaced the matrix with a line: a language publishes one server, any editor that speaks the protocol gets completions and diagnostics for free.

The Model Context Protocol makes the same trade for tools. Rather than every AI application hard-coding a ClipSpeedAI integration, ClipSpeedAI runs one MCP server and any MCP-capable client connects to it. The client opens a session, asks what the server can do, and receives back a list of callable tools — tool names, prose descriptions written to be read by a model rather than a human, and a schema per tool describing the arguments it accepts. Those definitions go into the model's context. When the model decides a tool is warranted, the client dispatches the call, the server performs the real work, and structured results come back for the model to reason over. What Is MCP? Model Context Protocol Explained is the longer version if this is new.

The consequence that matters inside an editor is that tool discovery happens at runtime, not at build time. Cursor's agent does not know what ClipSpeedAI can do until it connects; then it knows, and it knows the argument schemas too. This is why the reference table further down describes purpose rather than parameter names: the authoritative schema arrives over the wire at connect time, and a table on a web page is a snapshot at best.

It is also why MCP is not a rename of function calling. Function calling is the model-side half — the model emits a structured request instead of prose. MCP is the half underneath: how a tool gets discovered, how the call travels, how the caller proves who it is. You can have one without the other, and MCP vs Function Calling: What Actually Differs pulls the two apart properly.

Your key: csai_live_, forty-eight hex characters, and one chance to copy it

Authentication to the ClipSpeedAI MCP server is a single long-lived API key. The shape is exact: the literal prefix csai_live_ followed by 48 hexadecimal characters — twenty-four random bytes, hex-encoded. If what you pasted does not start with csai_live_ and run to that length, you have a truncated copy, and truncated copies fail as unauthorized rather than as malformed.

Generate one under Account → API & Integrations → Generate API Key, which is the UI over POST /auth/api-keys. The full key is displayed once, at creation, and never again. ClipSpeedAI stores only the first eighteen characters for display purposes — that is csai_live_ plus the first eight hex characters, followed by an ellipsis. Enough to tell two keys apart in a list; useless for authenticating. Copy the whole thing into your password manager before you close the dialog.

Listing keys via GET /auth/api-keys returns, per key: an id, the name you gave it, that display prefix, the plan, a rate limit, requests_today, total_requests, last_request_at, an active flag and a creation timestamp. Those counters are the most under-used part of the whole integration. Because each key carries its own rate limit and its own running totals, issuing a separate key per client — one for Cursor, one for Claude Code, one for anything running in CI — turns an opaque "is it working?" into a readable answer. If requests_today on the Cursor key is still zero after you have asked the agent to list templates, the calls are not reaching ClipSpeedAI at all and the problem is upstream of the server.

Revocation is real, not cosmetic. DELETE /auth/api-keys/:id flips the key's active flag off and stamps a revocation time; the key stops authenticating. That makes per-client keys cheap to clean up: a key that leaks out of a repository can be killed without touching the one your CI job depends on.

Rotate in this order, every time: create the replacement first, update every place the old key is configured, confirm each one works, and revoke the old key last. Reversing those steps produces a window where nothing authenticates. Rotate immediately if a key lands in a commit, a screenshot, a support ticket, or a machine that is no longer yours.

Eligibility note: API key generation requires a plan with API access. A $1 trial account qualifies; a free account does not — the endpoint returns 403 Feature not available. Keys are shown once at creation, carry a per-key daily rate limit (exceeding it returns 429 rate_limit_error), and can be revoked at any time, which stamps a revocation time against the key.

Wiring Cursor up without guessing at its schema

The install is five steps, only one of which is Cursor-specific enough to need their docs open.

1. Create the key. Account → API & Integrations → Generate API Key. Copy it in full while it is on screen.
2. Register ClipSpeedAI in Cursor as a remote HTTP MCP server. Follow Cursor's MCP documentation for where server definitions live and what the fields are called in your build. Give the server a short name — clipspeed is what the rest of this page assumes — set its URL to https://api.clipspeed.ai/mcp, and add one header, Authorization, whose value is the word Bearer, a single space, then your key. The word is not optional and the space is not decorative.
3. Restart the editor. Editing a config file underneath a running process is not reliably picked up. Restart rather than debugging a config that was never re-read.
4. Check that the server appears with ten tools. Tool discovery is the real handshake. If the names are listed, the transport worked and the key was accepted; there is nothing left to prove about connectivity.
5. Make one call. The next section covers which one and why.

If the server does not appear at all, the usual cause is that the file was never successfully parsed — a trailing comma, or a curly quote pasted out of a web page. Invalid JSON tends to produce a missing server rather than a helpful error, so validate the file before theorising about the network.

Testing the key independently of Cursor

Because Cursor is in the compatible band, it is worth having a second opinion available before you spend time on a config that may be fine. Claude Code is verified, takes the same Bearer key, and installs in one command:

claude mcp add --transport http clipspeed https://api.clipspeed.ai/mcp \ --header "Authorization: Bearer <API_KEY>"

That is the one piece of configuration on this page reproduced verbatim, and it exists here as a diagnostic. If the key works there and not in Cursor, the key is good and the editor's config is wrong. If it fails in both, the key is the problem and you can stop reading Cursor's docs. ClipSpeedAI MCP for Claude Code: Complete Setup Guide has the full walkthrough for that side.

One aside for completeness: a package named clipspeed-mcp, version 1.0.0, was published to npm on 2026-07-10. Cursor does not need it — it talks to the HTTP endpoint directly.

First call: list_templates, and the six caption styles it returns

Ask the agent something like "list the ClipSpeedAI caption templates". That triggers list_templates, which is read-only, takes no video, and returns the caption-style templates the engine can burn in. It is the right first call precisely because it exercises the whole path — session, discovery, authentication, a real response — without submitting anything.

The template ids are a fixed, short list, and they are exact strings:

karaoke
hormozi
beasty
fire
youshaei
cinematic

Whichever one you settle on gets passed as captionStyle. This is the single most useful thing to pin down early in an editor workflow, for a reason that has nothing to do with aesthetics: a back catalogue processed across several sessions with several different styles looks like three people's work. Choose one, write it into whatever config or runbook file your repository already has, and tell the agent to read the choice from there rather than picking per run. A one-line captionStyle: hormozi in a project file is the difference between a consistent channel and a patchwork.

If list_templates returns those six ids, the integration is live. Every remaining failure mode in this guide is about a specific tool or a specific input, not about the connection.

The ten tools, grouped by the order you actually call them

The server advertises ten tools. What follows is what each one is for. Argument schemas are published at connect time and read by the agent directly — treat the names below as orientation, not as a spec to hard-code against.

Finding and submitting

Collecting the output

Publishing

The live quartet

Two structural notes worth carrying into your prompts. First, submission and retrieval are separate tools because the work is asynchronous; an agent that submits and immediately reports "no clips" has not failed, it has been impatient. Second, the live tools form a four-state lifecycle, and an agent that knows how to start a session but was never told to stop one will leave it open. MCP Tool Design: Writing Tools an Agent Can Actually Use explains why splitting the work this way is the correct shape for a long-running job.

Pipeline 1: from a niche to a private YouTube upload, in two turns

The first pipeline chains discovery, clipping, the creator assets and a publish — deliberately split across two turns, because one of those steps is public and the rest are not.

Use ClipSpeedAI. Find a fast-growing recent video in the
speedrunning niche, submit it for clipping with captionStyle
"hormozi", then poll until clips exist and show me each clip's
title and viral score with its download URL. Publish nothing.

What the agent does, step by step:

1. Calls discover_trending for the niche. Remember the window: this searches roughly the last three weeks, so it surfaces something with momentum, not the best video of the year. Prompts that ask for all-time bests fight the tool.
2. Calls submit_to_clipspeed on the chosen URL with your captionStyle. A project reference comes back quickly; no clips exist yet.
3. Calls check_clips against that projectId. Early calls may report nothing ready. The agent waits and re-checks.
4. Once clips exist, it reads the title, viral score and download URL off each one and presents the ranked list.

Then, having actually looked at them, you take the second turn:

Get the creator pack for that project, then publish only the
top-scoring clip to YouTube using its suggested title. Leave
privacyStatus at the default.

Now creator_pack returns per-clip suggested titles, hooks and posting times for the same projectId, and publish_to_youtube pushes one clip — privately, since that is the default. That two-turn split is not ceremony. publish_to_youtube is the only tool here that produces an effect outside your account, and the private default gives you a third checkpoint: the upload exists, you can watch it, and flipping it public is a human decision made afterwards. AI Agent Video Automation: End-to-End Workflows takes this further into scheduled pipelines.

Pipeline 2: a live session you check on rather than sit through

Live clipping has a hard constraint: the decisions have to be made while the stream is running. An agent that can start a session, poll it on a cadence and report back turns that into something you can leave running.

Start a ClipSpeedAI live session on this stream:
https://www.twitch.tv/EXAMPLE_CHANNEL
Check the session every 15 minutes, tell me when clips land,
and tell me the moment the status stops being "monitoring".

1. clip_livestream starts the session against the live feed and returns a subscriptionId. Hold onto it — every other live call keys off it.
2. On your cadence the agent calls check_livestream with that id. While the status reads monitoring, the stream is still live and still being clipped. That single word is the entire health check.
3. When the stream runs longer than planned, "give it another ninety minutes" triggers extend_livestream on the same session.
4. When you have what you need, "stop the ClipSpeedAI session" triggers stop_livestream.

Close the loop explicitly and ask the agent to confirm the stop returned. A live session is long-running by design; it does not interpret "thanks, that's everything" as an instruction to end. The reassuring half of that is that stopping costs you nothing: clips already produced are kept and remain downloadable after the session ends, so there is no reason to leave one open out of caution. Livestream Clipping API: Clip While You Stream covers the pattern in more depth.

Asking for the status word rather than a summary is a small prompting trick that pays off. monitoring is a specific value with a specific meaning; "it seems to still be going" is the agent paraphrasing, and paraphrases are where a finished session gets reported as a healthy one.

Pipeline 3: a back catalogue run that leaves a manifest in the repo

This is the pipeline that justifies doing any of it inside an editor rather than a chat window. The inputs live in your repository, the outputs get written back to it, and the media work happens somewhere else entirely.

Read urls.txt. Confirm "cinematic" is a real ClipSpeedAI caption
template first. Then submit each URL with captionStyle
"cinematic", write the returned projectIds into clips.json as
you go, poll check_clips for each until clips exist, and fill
out a markdown table of title, score and download URL in
CLIPS.md. Do not publish anything.

1. The agent calls list_templates and verifies cinematic against the returned ids rather than trusting the string in your prompt. Cheap, and it catches a typo before eleven jobs go out under a style that does not exist.
2. It calls submit_to_clipspeed once per URL and writes each projectId into clips.json immediately. Writing the ids down as they arrive matters more than it sounds: a project reference that only ever existed in the agent's context is gone when the session is.
3. It polls check_clips per project and fills the table in as results land.
4. Optionally it runs creator_pack on the strongest project for suggested titles, hooks and posting times.

The manifest is the point. It survives the conversation, it can be committed, and it gives a later session — or a colleague — a list of project references to resume from without re-submitting anything. It also turns the async split from an inconvenience into a feature: submission and collection can happen hours apart, in different sessions, because the ids are on disk. MCP for Video Editing and Clipping Workflows looks at the same problem from the editing side, and MCP for Creators: Automating Video Without Code covers it for people who would rather not have a repository involved at all.

When it misbehaves: a diagnostic order that narrows fast

Work through these in sequence. Each step splits the remaining possibilities roughly in half, which beats guessing. Confirm against Cursor's own MCP documentation that you edited the file that build reads, and restart the editor rather than assuming a live re-read.

Does it appear, but with no tools? Then the transport reached ClipSpeedAI and discovery did not complete. Confirm the URL is exactly https://api.clipspeed.ai/mcp, and confirm outbound HTTPS to that host is not being intercepted — a TLS-inspecting corporate proxy is a genuinely common cause and produces failures that look like nothing in particular.

Are the ten tools listed, but every call comes back unauthorized? Check the header value in this order. Is the literal word Bearer present, followed by exactly one space? Did a newline get captured when the key was copied out of a terminal? Does the key start with csai_live_ and run the full 48 hex characters after it, or was it truncated on paste? Was it revoked during an earlier rotation — a revoked key is inactive and will never authenticate again, so a fresh one is the fix, not a retry. Then check the key list: if requests_today and last_request_at are not moving, the requests are not arriving and the problem is on your side of the wire.

Are the tools listed but never invoked? This is a prompting problem, not a connection problem. "Make me some clips" gives the model nothing to bind to; "use ClipSpeedAI to clip <URL> and show me the scores" does. If the agent still declines, and your client offers per-server or per-tool toggles, confirm clipspeed and its tools are enabled for the current chat — a disabled tool is not visible to the model.

Is check_clips empty right after submitting? Working as intended. Submission returns when the job is accepted; the media work happens afterwards. Have the agent wait and re-check. Escalate only if a project stays empty for far longer than the source video's length would make plausible.

Did a live tool error immediately? Three likely causes: the stream is not live at that moment, the URL points at a channel page or a recording instead of the live broadcast, or the session already ended. Confirm it is live in a browser, and for a recording use submit_to_clipspeed instead — clip_livestream is not the tool for that.

Did publish_to_youtube fail while everything else worked? Publishing depends on your ClipSpeedAI account's YouTube authorization, not on the MCP session. Check that authorization in the product, then retry.

Did it work yesterday and not today? Three questions, in order: was the key rotated or revoked; did the subscription lapse (there is no free tier underneath to fall back to); is a proxy newly intercepting traffic to api.clipspeed.ai. Then run the same key through the claude mcp add command above. That single test separates a bad key from a bad Cursor config, and it is faster than any amount of reading.

Keeping a long-lived key out of your git history

The key is the account. Anyone holding it can submit jobs, read the clips your projects produced, and reach publish_to_youtube. It is a production credential that happens to be stored as configuration, and the storage format is the trap. away from a remote branch. If a project-scoped file is genuinely necessary, add it to .gitignore before you write the key into it, not after, and commit a redacted example alongside so the next person knows what shape to fill in. If a key reaches a remote branch, treat it as compromised and revoke it rather than rewriting history — DELETE /auth/api-keys/:id makes that a thirty-second job, and history rewrites on a shared branch cause their own problems.

Per-client keys are worth the small extra effort. Because keys are revoked individually and each carries its own counters, a key named cursor-laptop can be killed the moment that laptop leaves your control without disturbing the one your CI job uses, and last_request_at tells you which keys are still doing anything before you clean house.

On exposure in the other direction: the server receives the arguments the agent sends to its tools — video URLs, project references, template choices, publishing details — and nothing more. It has no view of your filesystem, your repository, other MCP servers connected to the same editor, or the rest of your conversation. When the agent reads urls.txt and submits eleven URLs, eleven URLs cross the wire.

The inverse deserves attention too, and it is sharper in an editor than in a chat window. Your agent acts on what tools return, and discover_trending returns videos found on the open internet, with titles and metadata written by strangers. Treat that text as data, not as instruction. Do not build an unattended pipeline that publishes based on text it discovered rather than text you approved — the private default on publish_to_youtube is a useful backstop precisely because it makes the automated outcome the reversible one. MCP Security: Scopes, Keys and Safe Tool Design covers the threat model in full, and How to Build an MCP Server (Practical Guide) is the same problem viewed from the server's side.

What this setup will not do for you

The verification gap is real but narrow. Cursor uses the same protocol and the same HTTP-plus-Bearer transport as the verified clients. ClipSpeedAI has not run end-to-end verification on it, so on an unusual failure you have less certainty than you would elsewhere. The mitigation is one command away, and it is the reason ClipSpeedAI MCP for Claude Desktop: Complete Setup Guide is worth having bookmarked even if you never use that client daily.

The processing is not local. ClipSpeedAI is a remote server, not a subprocess on your machine: clipping runs on ClipSpeedAI's infrastructure, and nothing about it is tied to your editor process. That is why there is nothing to install or update, and why every client you connect with the same key sees the same projects and the same clips. Your key, not your machine, is the unit of access. Remote MCP vs Local MCP Servers covers what changes when a server runs on the other side of a network boundary.

Ten tools, and only ten. There is no frame-by-frame editing of an existing clip, no publishing target other than YouTube, no account or billing management. If you need something outside that surface, you need the product UI or a different tool.

Discovery is a recency instrument. discover_trending looks at videos published in roughly the last three weeks. It is built to catch something on the way up, not to search an archive, and prompts written as archive searches will disappoint.

Live clipping cannot look backwards. clip_livestream attaches to a stream that is live at the moment you call it. It cannot recover the hour that ran before you started the session; for anything already finished, the recording goes through submit_to_clipspeed.

No timings are quoted here. Processing takes time proportional to the source, and a number that depends on video length, resolution and queue depth is not something you can plan against. Measure it on your own material and design your polling around what you observe.

Billing. Subscription only — there is no free plan sitting underneath to fall back on. The cheapest entry is the $1 trial: one dollar charged today, three days of access, converting to a full subscription on the fourth day unless you cancel first. Monthly rates are $15 for Starter, $29 for Pro and $49 for Ultra, halved if you pay annually. A free demo also exists, but it is one demo, on a source under thirty minutes — enough to judge output quality, not enough to drive a pipeline. If you want to compare this route against calling an HTTP API directly, MCP vs REST API: When to Use Each makes that argument properly.

Frequently asked questions

Is Cursor officially supported by the ClipSpeedAI MCP server?

Cursor sits in the compatible band. It uses the same MCP protocol and the same HTTP-plus-Bearer transport as the verified clients, but ClipSpeedAI has not run end-to-end verification on it, so on an unusual failure you have less certainty than on Claude Code, Claude Desktop, Windsurf or Claude on the web.

Where exactly does the Cursor MCP config live, and what are the field names?

That is Cursor's to define, and it has changed across releases, so this guide does not print a filename or a key name it cannot vouch for. Follow Cursor's own MCP documentation to add a remote HTTP MCP server. The two values that come from ClipSpeedAI and never change are the URL, https://api.clipspeed.ai/mcp, and the header Authorization: Bearer <key>.

What does a valid ClipSpeedAI API key look like?

The literal prefix csai_live_ followed by 48 hexadecimal characters. Anything shorter is a truncated paste and will be rejected as unauthorized rather than as malformed.

I lost my key. Can I read it back out of the account?

No. The full key is shown once, at creation. Only the first eighteen characters — csai_live_ plus eight hex characters — are stored for display, which is enough to identify a key in a list and useless for authenticating. Generate a replacement and revoke the old one.

Does revoking a key actually stop it working?

Yes. Revocation marks the key inactive and stamps a revocation time; it stops authenticating from that point. Because keys are revoked individually, issuing one per client means you can kill a leaked key without disturbing the others.

How do I rotate a key without breaking anything mid-flight?

Create the new key first, update every client and CI secret that used the old one, confirm each still works, and revoke the old key last. Revoking first leaves a window where nothing authenticates.

Which caption styles can I pass as captionStyle?

Six: karaoke, hormozi, beasty, fire, youshaei and cinematic. Call list_templates to confirm the ids rather than trusting a string typed into a prompt, then pass the chosen one as captionStyle.

Will publish_to_youtube make my clip public?

Not unless you ask it to. publish_to_youtube defaults to private. It takes a projectId with optional clipId, title and privacyStatus — leave the last one alone and the upload lands privately, which is why it is safe to let an agent run the publish step and make the public decision yourself afterwards.

Why does check_clips come back with nothing right after I submit?

Clipping is asynchronous. submit_to_clipspeed returns once the job is accepted, not once the work is finished; the clips appear on a later check_clips call against the same projectId. Investigate only if a project stays empty far longer than the source video's length would make plausible.

Can I clip a stream that has already ended?

Not with clip_livestream, which attaches to a feed that is live at the moment you call it and cannot reach backwards into the part you missed. Point submit_to_clipspeed at the recording instead.

If I stop a live session, do I lose the clips it already made?

No. stop_livestream ends the session by subscriptionId, and clips already produced are kept and remain downloadable. There is no reason to leave a session open out of caution.

Is there a free way to test the MCP server before subscribing?

There is one free demo, limited to a source under thirty minutes — useful for judging output, not for running a pipeline. Beyond that it is subscription only: $1 buys a three-day trial that converts on day four unless cancelled, and the plans are $15, $29 and $49 per month, halved annually.

Related reading