ClipSpeedAI MCP on claude.ai: The No-Config Connector

Claude at claude.ai is the one ClipSpeedAI client with no configuration file anywhere in the story. Nothing gets pasted into JSON. No Node runtime, no terminal, no daemon sitting in your menu bar. You put one URL into the connector settings, approve a browser prompt, and ten clipping tools appear in your chats.

Behind that URL is the rendering engine that runs clipspeed.ai: hand it a long video and it returns vertical 9:16 clips that are scored, captioned and reframed. The endpoint is https://api.clipspeed.ai/mcp and it speaks streamable HTTP. Support tier for this client: Claude (claude.ai) is FULLY SUPPORTED — the connector flow, the OAuth handshake and the tool calls have all been exercised end to end.

Because the install is so short, this page runs in an unusual order. Setup comes first and takes a minute. Then a bottom-up explanation of what Claude actually downloads when you connect, the tool set and the one identifier that ties it together, three runs written as prompts you can paste, the credential model, and the parts that break.

Adding the Connector: What You Need, Then Nine Clicks

Four things have to be true before the connector will be useful, and only one of them takes any effort.

• A ClipSpeedAI account. There is no free plan. $1 starts a 3-day trial — a one-time $1 charge today, converting after three days unless you cancel. Paid plans are Starter $15/mo, Pro $29/mo and Ultra $49/mo, with annual billing at half price. A free demo exists, limited to one demo on a video under 30 minutes; it shows you output quality but it is not something to build a routine on.
• A Claude account on a plan that offers custom connectors. That availability is Anthropic's call, not ClipSpeedAI's. If the option is missing from your settings, the answer is in your Claude plan rather than anything on this page.
• A browser signed into both, with popups allowed. The authorization step opens a window. Blocked popups and blocked third-party cookies are the two most common reasons an otherwise correct setup ends up half-finished.
• A YouTube channel connected inside ClipSpeedAI — only if you plan to use publish_to_youtube. That authorization is granted in the ClipSpeedAI app and is completely separate from the connector.

Nothing is installed locally. No Node, no Python, no background process.

The flow itself:

1. Sign in at claude.ai.
2. Open Settings and find Connectors.
3. Choose Add custom connector.
4. Paste the endpoint exactly as written:

https://api.clipspeed.ai/mcp

5. Name it clipspeed. The name is arbitrary, but keeping the same one across every client means a prompt written in one place still reads correctly in another.
6. Save. Claude opens the ClipSpeedAI authorization window.
7. Sign in to ClipSpeedAI there if asked, and approve. No key is copied at any point — Claude ends up holding a scoped OAuth grant, not your password and not a long-lived secret.
8. Back in the connector list, confirm it reads as connected and that the ClipSpeedAI tools are listed under it.
9. Open a fresh chat, check the connector is switched on for that conversation, and ask for something read-only before spending a render.

The best first request is the caption template list, because the correct answer is short and you can recognise it on sight:

List the ClipSpeedAI caption templates on my account.

A healthy connection comes back with six ids: karaoke, hormozi, beasty, fire, youshaei and cinematic. If you see those, authentication worked, the transport works, and the account behind the grant is a real one. Every other tool is reachable from the same connection. Anthropic moves labels around in the connector interface from time to time; the endpoint is the part that does not move.

What Claude Downloads the Moment You Connect

Most write-ups of the Model Context Protocol start at the specification and work downward. Coming at it from this one connector is quicker, because you can point at the actual objects involved.

When the connector saves, Claude asks the ClipSpeedAI endpoint a single question: what can you do? Back comes a list of ten entries. Take one of them — check_clips. Claude keeps that list where the model can read it.

Later, mid-conversation, you say something like "are the clips done yet?". The model matches that against the entry it read at connect time, and Claude issues an authenticated HTTP request to the endpoint carrying the tool name and the projectId. ClipSpeedAI runs the lookup against your account and answers with data — clip titles, viral scores, download URLs — rather than a paragraph the model has to interpret. The result lands back in the conversation and the model reasons over it.

That round trip is the entire protocol in miniature: a list the client can discover, arguments with declared shapes, replies that arrive as structured values, and a transport that carries proof of who is asking. Everything else — sessions, error framing, streaming — is detail layered on that shape.

The payoff is that ClipSpeedAI wrote that list once. Any client implementing the protocol reads the same ten entries from the same endpoint. What varies between clients is where the credential is stored and what the setup screen looks like, not what the tools mean.

If you would rather have the standard explained from the top down instead of from one server upward, that treatment is What Is MCP? Model Context Protocol Explained. The full request path — transports, session lifecycle, how a call is framed on the wire — is diagrammed in How MCP Servers Work: Architecture and Request Flow. Anyone who suspects all of this is ordinary tool calling under a new name should read MCP vs Function Calling: What Actually Differs, and anyone who was otherwise about to write a plain HTTP client should weigh MCP vs REST API: When to Use Each first. Building one of these servers rather than consuming one is covered in How to Build an MCP Server (Practical Guide), with the design question — how to split capability across tools so a model picks the right one — in MCP Tool Design: Writing Tools an Agent Can Actually Use.

Verified, Compatible, Vendor-Gated: Where Each Client Sits

ClipSpeedAI keeps three separate labels for client support, because "we tested it" and "it speaks the same protocol" are not the same promise.

Claude on the web sits in the first row, which is why this page can describe the setup in specifics rather than in general terms. For a compatible-tier client the honest instruction is procedural rather than literal: add ClipSpeedAI as an HTTP MCP server pointing at https://api.clipspeed.ai/mcp, put your key in an Authorization: Bearer header, and follow that client's own MCP documentation for where those two values live. Guessing at another vendor's config field names would be worse than saying nothing.

Setup guides exist per client. In the terminal, that is ClipSpeedAI MCP for Claude Code: Complete Setup Guide; in the desktop app, ClipSpeedAI MCP for Claude Desktop: Complete Setup Guide, which is also where you should look for how Desktop stores its credential rather than assuming it matches the web. For the editors, see ClipSpeedAI MCP for Windsurf: Complete Setup Guide and ClipSpeedAI MCP for Cursor: Complete Setup Guide. The remaining clients each have their own page: ClipSpeedAI MCP for Codex CLI: Complete Setup Guide, ClipSpeedAI MCP for OpenClaw: Complete Setup Guide, ClipSpeedAI MCP for Hermes Agent: Complete Setup Guide and ClipSpeedAI MCP for ChatGPT: Complete Setup Guide.

Ten Tools, Grouped by the Job They Do

Claude reads these schemas at connect time and fills arguments in itself, so you will rarely type a parameter name. Knowing what each one takes is still worth the two minutes, because it tells you what a prompt has to contain for the model to be able to act at all.

Finding something to clip

• discover_trending — finds the fastest-growing recent video in a niche to turn into shorts. It deliberately searches only videos published in roughly the last three weeks, so it is a tool for catching momentum, not for mining an archive. If you already know which video you want, skip it.

The recorded path

• submit_to_clipspeed — drops a video URL, or a file, into ClipSpeed. This is the clip button. It starts the job.

Packaging what came back

• list_templates — takes nothing and lists the caption-style templates. Also the cheapest connectivity check you have.
• creator_pack — takes a projectId and returns per-clip suggested titles, hooks and best posting times.

The live path

• clip_livestream — clips a livestream in real time and returns a subscriptionId.
• check_livestream — polls a session by subscriptionId. A status of monitoring means the stream is still live and still being clipped.
• extend_livestream — extends an active session.
• stop_livestream — stops a session by subscriptionId. Clips already made are kept and stay downloadable.

Getting it out

• publish_to_youtube — publishes a finished clip to YouTube. Takes a projectId, optionally a clipId, a title and a privacyStatus. It defaults to private, which is a deliberate choice: the failure mode of an agent publishing something you had not read is a public one, and a private default turns that into a draft you can look at.

The identifier that ties it together

Three of the ten tools — check_clips, creator_pack and publish_to_youtube — all key off the same projectId that came out of a submission. The live tools key off a subscriptionId instead. That is worth holding onto, because it explains why a single conversation per project is the practical unit of work: the identifiers are the thread. Come back three hours later in the same chat and "pull the creator pack for the second episode" still resolves, because the projectId is sitting in the transcript. Start a new chat and it does not.

The Six Caption Templates and the captionStyle Argument

Captions are the part of a short-form clip people notice first, and ClipSpeedAI exposes the choice through a named list rather than a pile of styling knobs. Call list_templates and you get exactly six ids back:

karaoke
hormozi
beasty
fire
youshaei
cinematic

These are the real ids, spelled exactly that way. The chosen id is passed as captionStyle. Practically, that means the correct prompt shape is to name a template you have actually seen in the list rather than describing a look and hoping something matches — "clip this with the hormozi style" gives the model a value it can pass, while "make the captions bold and punchy" gives it a guess to make.

Two habits follow. First, run list_templates once at the start of any new setup: it confirms authentication and hands you the exact vocabulary in the same call. Second, pick one id and stay on it across a batch. Six templates across four episodes is four experiments; one template across four episodes is a channel with a look.

The template list is per-account, so what comes back is what your account actually has rather than what a documentation page claims. If a name in your head is not in the response, the response wins.

Run One: A Recent Trending Video Into a Private YouTube Upload

Four tools, one prompt, ending in a private upload you approve before making public.

Find the fastest-growing recent GTA video worth turning into shorts,
clip it, then show me the clips with their titles and viral scores.
When I pick one, publish it to my YouTube channel — keep it private
and draft me a title.

Sequence:

1. discover_trending goes first, and its three-week publication window is doing real work here. It is looking for momentum in a niche, not for the biggest video of all time. Claude will normally name the video it selected before proceeding, which is where you redirect it if the pick is wrong — cheaper than redirecting after a render.
2. submit_to_clipspeed takes that URL. That is genuine compute and it takes genuine time.
3. check_clips is how Claude learns it finished, using the projectId from the submission. Each clip comes back with a title, a viral score and a download URL.
4. Because those scores return as values rather than as a wall of thumbnails, filtering is something you can express in the prompt. "Only the two highest-scoring" is an instruction the model can execute against the returned list.
5. publish_to_youtube ships the one you chose. It defaults to private, so the natural rhythm is publish private, watch it on the channel, then flip it public yourself. If you want it live immediately you have to say so, which is the right amount of friction on the only irreversible tool in the set.

A useful variation: ask for creator_pack on the same projectId before publishing. You get suggested titles, hooks and posting times per clip, which means the title you approve is drawn from the clip's own content rather than invented at the last second.

Run Two: Holding a Live Session Open While the Stream Runs

The live path is where an assistant earns its place, because the difficulty is not the number of steps — it is that the steps are spread across hours and a person with a browser tab open will drift.

Start clipping this stream: <stream URL>
Check on it periodically and tell me what it catches.
Keep the session going while the stream is still live, and
stop it once the broadcast ends.

What each tool contributes:

1. clip_livestream opens the session against the live URL and returns a subscriptionId. Clips start being produced while the broadcast is still running; you are not waiting for a VOD to be posted.
2. check_livestream polls that subscriptionId. The status you want to see is monitoring, which means the stream is still live and still being clipped. This is the authoritative answer about session health, not the chat's memory of what it started.
3. extend_livestream extends a session that is currently active. The requirement worth remembering is exactly that: the session has to be active for an extension to apply, so a poll that comes back as anything other than monitoring is the signal to check the broadcast rather than to keep extending.
4. stop_livestream ends the session deliberately. Clips it already produced are kept and remain downloadable, so stopping is not destructive.
5. check_clips afterwards collects what the session produced, scored and titled the same way recorded clips are.

The constraint that catches people out is that a live session captures from the moment it starts. If the moment you wanted happened before you opened the session, it is not going to be in the session — that one belongs to the recorded path, once the VOD exists. Livestream Clipping API: Clip While You Stream goes further into the live model, and the broader question of what an assistant can be trusted to hold across hours is the subject of AI Agent Video Automation: End-to-End Workflows.

Run Three: Four Episodes, One Caption Style, One Ranked Table

Batch work, where the win is consistency and cross-job comparison rather than raw speed.

List my caption templates first. Then take these four podcast episodes,
clip each one using the hormozi style, and when they are all done give me
one table of every clip — score, title, and which episode it came from.
Then pull the creator pack for the highest-scoring clip.

Step by step:

1. list_templates returns the six ids so the style you name is one the account actually has, and confirms the connection is alive before you commit to four submissions.
2. submit_to_clipspeed runs once per episode. Each returns its own projectId; the caption style is the constant across all four.
3. check_clips runs per projectId. The assembly step is the interesting one: Claude holds four independent result sets in the same conversation and collates them into one ranked table. No per-video interface will do that for you, because each render is its own page.
4. creator_pack on the winning projectId returns suggested titles, hooks and posting times for its clips, so the strongest clip also gets the most thought-out packaging.

Keep a batch in its own conversation. Four jobs means four projectIds, and an hour later "re-check the second episode" only resolves if the identifier is still in the transcript. Related batching and editing patterns are collected in MCP for Video Editing and Clipping Workflows, and the no-code framing of the same idea is MCP for Creators: Automating Video Without Code.

Credentials: OAuth in the Browser, csai_live_ Keys in a Terminal

The server accepts two credential styles, and the client decides which one applies. This is not a preference setting.

On claude.ai the answer is OAuth, and it is the better arrangement anyway: there is no long-lived secret sitting in a file on disk to leak, get committed, or be forgotten about.

The Bearer form is still worth recognising, since every terminal client in this cluster uses it. This is the canonical command, exactly as ClipSpeedAI documents it:

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

Same endpoint, same transport, same ten tools — the credential is the only difference. An npm package also exists, but on claude.ai it is not part of the path: the connector talks to the hosted endpoint directly. The general trade-offs between the two credential models are the subject of MCP Authentication: OAuth and Bearer Keys.

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.

Key Hygiene: One Look at the Secret, and a Real Revoke

You do not need an API key for claude.ai. You will probably want one eventually — for a terminal client, a second machine, or a script — so here is what the key system actually does.

Format. A key is the prefix csai_live_ followed by 48 hexadecimal characters, generated from 24 random bytes. If a string you are holding does not look like that, it is not a ClipSpeedAI key.

Creating one. In the app: Account → API & Integrations → Generate API Key, which posts to POST /auth/api-keys.

Seeing them. GET /auth/api-keys lists what you have. Each record carries an id, a name, a key_prefix, the plan, a rate_limit, requests_today, total_requests, last_request_at, an is_active flag and a creation timestamp. Only the prefix is stored for display — the first 18 characters followed by an ellipsis — which is why the full key is shown once, at creation, and cannot be retrieved afterwards. Copy it then or generate a new one.

Revoking. DELETE /auth/api-keys/:id sets is_active to false and stamps revoked_at. Revocation is a real operation with a real record, not a cosmetic delete.

Two things that listing gives you which are easy to overlook. Keys carry a per-key rate_limit along with running request counters, so a key is a unit of accounting as well as a unit of access — one key per machine or per script makes last_request_at and total_requests tell you something useful, whereas one key shared everywhere tells you nothing. And because the counters are per key, a key that has gone quiet is visible as a key that has gone quiet, which is the cheapest audit available to you.

Handling rules, short version: store keys the way you would store a production credential, never paste one into a chat message or a screenshot, and if one has ever been somewhere it should not have been, revoke it and issue a new one rather than reasoning about whether it was really exposed.

Remote by Design: No Local Process, No Filesystem Access

MCP servers come in two shapes. A local server runs as a process on your machine, launched by the client and spoken to over stdio; it can see your files, and it stops when your machine does. A remote server is a hosted HTTP endpoint the client calls over the network; it sees only what a tool call carries, and it keeps working after your laptop closes.

ClipSpeedAI is remote, without qualification. One endpoint, streamable HTTP, and the rendering happens on ClipSpeedAI's infrastructure. That is the correct shape for this workload for an obvious reason — video encoding should not be competing with your browser for CPU — but the consequence that matters day to day is different: a submitted job does not depend on your session staying open. Submit, close the tab, come back tomorrow, ask Claude to check the clips for that projectId. The work carried on without you. Remote MCP vs Local MCP Servers works through the general comparison.

The security boundary falls out of that architecture rather than from any promise made about it:

• No filesystem access. There is no local process, so there are no files, environment variables or repositories in reach. This is the structural argument for remote servers over local ones.
• It sees the arguments, not the conversation. Video URLs, template ids, projectIds, titles — what a tool call carries. Not the surrounding chat.
• It acts as you. Calls run against your account, and publish_to_youtube posts to your channel. Give that tool the caution you would give any write to a public surface — which the private default already assumes.
• Two grants, two revocations. The web connector holds an OAuth grant; API keys are records you can revoke individually. Check both if you are cleaning up access, and confirm the state in the app rather than assuming one covers the other.

The wider threat model — why a small, explicit set of narrow tools is safer than one general-purpose tool that can do anything — is covered in MCP Security: Scopes, Keys and Safe Tool Design.

When It Breaks: Symptom, Cause, Fix

Claude talks about clipping instead of doing it. The connector is off for that conversation, or the request was vague enough that answering from general knowledge looked like a reasonable response. Check the connector toggle in the chat, and name the capability: "use ClipSpeedAI to clip this" leaves no room for interpretation.

The approval window finished but the connector shows disconnected. Usually a blocked popup, blocked third-party cookies, or an approval completed in a different browser profile than the one running Claude. Retry in a normal window rather than private browsing, allow popups for claude.ai, and finish in the same profile.

Tools start returning authorization errors mid-session. The OAuth grant expired or was revoked, possibly from another device. Remove the connector and add it again to trigger a fresh grant. Generating a new API key will not help here — the web connector does not use your API keys.

Claude Code works, claude.ai does not. Different credentials entirely. The CLI presents a csai_live_ key in an Authorization header; the web presents an OAuth grant. A working terminal setup tells you the account is fine and tells you nothing about the connector. Complete the browser flow on its own terms.

check_clips comes back with nothing. Almost always because the job is still running. Read an empty result as "not ready" and re-check. Do not resubmit — that starts a second, separate job against your plan and gives you two sets of clips to sort through.

The video URL is rejected. The engine has to be able to retrieve the source. Open the same URL in a signed-out browser window; if you cannot reach it without logging in, neither can the pipeline.

publish_to_youtube is the only tool failing. No YouTube channel is connected and authorized inside ClipSpeedAI, or that authorization lapsed. It is a separate grant by design: connecting the MCP server never gave anyone access to your YouTube account. Reconnect the channel in the app and retry.

The publish reported success but you cannot find the video. Look at your private uploads. publish_to_youtube defaults to private, so unless a privacyStatus was specified, the clip is on the channel and simply not public yet.

check_livestream is not reporting monitoring. The broadcast ended, or the session is no longer active. Poll first and read the status before acting; extension applies to an active session only. If the stream is still live, start a fresh session — remembering it captures forward from that moment, not backward.

Everything connects but the account looks empty. No templates, no plan, nothing familiar: the approval was completed while signed into a different ClipSpeedAI account than the one holding your subscription. Sign out of ClipSpeedAI, sign into the right account, then remove and re-add the connector.

Ceilings, and Things This Page Will Not Promise

• No free plan. $1 opens a 3-day trial that converts unless cancelled; then Starter $15/mo, Pro $29/mo or Ultra $49/mo, with annual billing at half price. The free demo is one demo, on a video under 30 minutes.
• Your subscription governs usage, not the protocol. Reaching the account through MCP does not change what the account is allowed to do. The limits are the same whichever client is calling; check them in the app.
• Rendering takes time. Write prompts that check back rather than prompts that assume an answer is waiting.
• Discovery has a time window. discover_trending looks at videos published in roughly the last three weeks. It is not an archive search, and it proposes candidates rather than guaranteeing any of them will clip well.
• Live capture is forward-only. A session covers from when it starts.
• YouTube is the only publishing destination in this tool set. Ten tools, one of them publishes, and it publishes to YouTube. Assume nothing beyond the ten exists.
• The viral score is a score. It comes back attached to each clip and it is useful for ranking one batch against itself. This page will not tell you what scale it uses or what number counts as good, because that is not documented — rank within your own results and judge from there.
• The connector interface belongs to Anthropic. Labels, placement and plan availability can change with no corresponding change at ClipSpeedAI. The endpoint is the stable half of this arrangement.

Adjacent Setups Worth Adding Once This One Works

If the browser is where you work, you are finished — the connector was the whole install. Two additions are worth the ten minutes once it is running.

The terminal is the first. ClipSpeedAI MCP for Claude Code: Complete Setup Guide is a single claude mcp add line with a Bearer key, and it is the better home for scripted batches and anything you want to repeat. The desktop app is the second: ClipSpeedAI MCP for Claude Desktop: Complete Setup Guide covers how that client is set up and where it keeps its credential.

For wider context, Best MCP Servers for Video and Content Workflows surveys what else is out there. If you are deciding between an agent integration and writing code against an API directly, AI Clipping API: Programmatic Short-Form Video and Video Clipping API for Developers cover the programmatic side, and Claude Code vs Cursor for MCP Workflows is useful if your work is split between a chat window and an editor. The rule of thumb underneath all of it: if a person or an agent is making the judgement calls, connect over MCP; if deterministic code is making them, write against the API.

Frequently asked questions

Do I need an API key to use ClipSpeedAI with Claude on the web?

No. claude.ai authenticates over OAuth, so no secret is ever pasted anywhere. You add https://api.clipspeed.ai/mcp as a custom connector and approve the browser prompt. API keys — created at Account → API & Integrations → Generate API Key — are for CLI clients, which send them in an Authorization: Bearer header instead.

What does a ClipSpeedAI API key look like, and can I get it back later?

A key is csai_live_ followed by 48 hexadecimal characters. Only the prefix is stored for display — the first 18 characters plus an ellipsis — so the full key is shown once when you create it and cannot be retrieved afterwards. Lost it, generate a new one. Keys can be revoked, which flips is_active to false and records a revoked_at timestamp.

How do I confirm the connector is actually working?

Ask Claude to list your ClipSpeedAI caption templates. A healthy connection returns six ids: karaoke, hormozi, beasty, fire, youshaei and cinematic. It is read-only, it does not start a render, and it proves authentication, transport and account identity in one call.

Which caption style will it use, and can I choose?

Yes. Run list_templates to see the six ids, then name one in your prompt — the chosen id is passed as captionStyle. Naming a real id beats describing a look, because it hands the model a value instead of a guess.

Will publishing put a clip on my channel publicly?

Not by default. publish_to_youtube defaults to private. It takes a projectId, and optionally a clipId, a title and a privacyStatus. The useful pattern is to publish private, watch it on the channel, then make it public yourself. Publishing also requires a YouTube channel connected and authorized inside ClipSpeedAI — connecting the MCP server does not grant access to your YouTube account.

Why is check_clips returning nothing right after I submitted a video?

The job is still rendering. acked 9:16 reframing take real compute. Treat empty as "not ready yet" and re-check with the same projectId. Resubmitting starts a second, separate job rather than speeding the first one up.

Can it clip something that already happened earlier in a livestream?

No. clip_livestream captures forward from the moment the session starts and returns a subscriptionId you poll with check_livestream; a status of monitoring means the stream is still live and still being clipped. For a moment that aired before you started, wait for the VOD and run it through submit_to_clipspeed on the recorded path.

Is this a remote server, and does a job survive closing the tab?

Remote, and yes. One hosted endpoint at https://api.clipspeed.ai/mcp over streamable HTTP, with rendering on ClipSpeedAI's infrastructure. Nothing runs on your machine, so a submitted job keeps going after you close the browser — return later and ask Claude to check the clips for that projectId.

Is Claude on the web fully supported, and what about other clients?

Claude (claude.ai) is in the fully supported tier alongside Claude Code, Claude Desktop and Windsurf — all verified end to end. Cursor, Codex, OpenClaw and Hermes are compatible: same protocol, verification in progress. ChatGPT is rolling out and gated by the vendor. For any compatible-tier client, add the endpoint as an HTTP MCP server with your key in an Authorization header and follow that client's own MCP documentation.

Is there a free way to test the integration first?

There is no free plan. A free demo exists — one demo, on a video under 30 minutes. To use the connector as an ongoing workflow you need an account: $1 starts a 3-day trial that converts to your chosen plan (Starter $15/mo, Pro $29/mo, Ultra $49/mo, annual at half price) unless you cancel.

Related reading