ClipSpeedAI MCP for ChatGPT: Setup, Auth and What's Actually Verified

Everything on ClipSpeedAI's side of this integration is fixed and knowable. One endpoint, https://api.clipspeed.ai/mcp. One transport, streamable HTTP. Ten tools. A credential that is either an OAuth token the client manages for you or an API key that begins csai_live_. None of that shifts depending on which client dials in.

ChatGPT's side is the part nobody here controls. ClipSpeedAI classifies ChatGPT as ROLLING OUT. Whether a custom MCP connector can be added at all is decided by OpenAI and may not be present in your account. ClipSpeedAI has not verified a ChatGPT run from connection through to a published clip, so nothing below should be read as "confirmed working in your account today".

This page is therefore ordered around that uncertainty rather than around a happy path. It opens with the thirty-second check that tells you whether to keep going, hands you the connector values, then gives you two independent ways to prove that a failure belongs to the client rather than to your key. Everything after that — the tool reference, the six real caption template ids, the three walkthroughs — is client-agnostic and works unchanged the moment you point a different client at the same server.

First: Does Your ChatGPT Account Even Offer Custom Connectors?

Do this before generating a key, before reading the tool table, before anything. Open ChatGPT's settings and look for the area that manages connectors or integrations. You are looking for one specific capability: the ability to add a server by typing in a URL. Picking from a catalogue of pre-approved integrations is not the same thing and will not get you here.

If that field does not exist, stop. That is the entire rolling-out condition, and no value you enter, no key you generate and no support ticket changes it. Skip to the closing section and use a client that is verified today with the same credential.

If the field does exist, the rest of this page applies and the four values in the next section are all you need.

ClipSpeedAI sorts clients into three tiers, and the tier describes how much verification has happened rather than how much protocol support exists:

Read the middle tier carefully, because it is a useful reference point. Cursor, Codex, OpenClaw and Hermes sit there for a reason that has nothing to do with breakage — they accept an HTTP MCP server and a credential header, that arrangement is expected to work, and ClipSpeedAI simply has not run the full loop on each of them yet. ChatGPT is one tier further out because there is an additional question in front of the protocol question: can you add the server at all.

The Four Values the Connector Form Needs

Whatever ChatGPT's connector dialog looks like on the day you open it, it is asking for some arrangement of these four things. Find the fields that accept them and ignore the labels.

1. Generate a key first if you expect to need one. In the ClipSpeedAI app, go to Account → API & Integrations → Generate API Key. The full key is displayed once, at creation. Copy it into a password manager at that moment — the server keeps only the prefix for display, so there is no screen anywhere that will show you the whole thing again.
2. Enter the URL exactly. https://api.clipspeed.ai/mcp — no trailing slash, no extra path segment, no version suffix. A URL that is nearly right fails in a way that looks like an authentication problem.
3. Choose the transport. HTTP. If the dialog offers stdio or a command to run, that option is for local servers and is not applicable here.
4. Attach the credential. If an OAuth flow is offered, take it. If only a custom header field is offered, the header name is Authorization and the value is the word Bearer, one space, then the key. No quotes, no angle brackets, and watch for a trailing space or newline riding along with a pasted key.
5. Confirm the tool list loads. A healthy connection shows ten tools by name. Zero tools means the handshake never completed, which is an authentication or reachability failure rather than a permissions one.
6. Smoke-test with something read-only. Ask the assistant: "List the ClipSpeedAI caption templates." That routes to list_templates, touches nothing, and proves the whole path — client, transport, credential, server — in one call. You should get back six template ids, and you can check them against the list further down this page.

Nothing here is ChatGPT-specific except which dialog you type it into. That is the point of a remote server: adding a client is data entry, not engineering.

OAuth in a Browser Client, Bearer Keys Everywhere Else

The server accepts two credential styles, aimed at two different kinds of client.

OAuth is for graphical clients. The client sends you through an authorization flow with ClipSpeedAI, and once you approve it, the client holds and refreshes the resulting token. You never see a secret and never paste one. If ChatGPT's connector dialog presents an OAuth option, that is the one to take, purely because a credential you never handle is a credential you cannot leak into a screenshot or a chat transcript.

Bearer keys are for anything driven by a config file or a command line, and for graphical clients that only offer a custom-header field. You generate a long-lived key and the client attaches it to every request.

Neither choice changes what the tools can do. The difference is entirely in who holds the secret and how you take it away later.

The clearest illustration of the header shape is the one command ClipSpeedAI documents verbatim, for Claude Code:

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

That is worth keeping in view even if you never run it, because the string after --header is character-for-character what a connector UI wants when it asks for a custom header. If you are wiring up a terminal agent as well, ClipSpeedAI MCP for Codex CLI: Complete Setup Guide covers the same header in that client's own configuration idiom, and the underlying trade-off between the two credential styles is worked through in 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.

What a ClipSpeedAI Key Looks Like, and What the Server Remembers

Key format is exact and checkable: the prefix csai_live_ followed by 48 hexadecimal characters. If the string you are about to paste does not start with csai_live_, or the tail contains anything outside 0-9a-f, you have grabbed the wrong text — a truncated copy, a prefix from a list view, or something else entirely. That check costs a second and eliminates a whole class of confusing failures.

The management routes behind the Account → API & Integrations screen are ordinary REST:

The list route is more informative than most key screens. Each record carries an id, a name, the key prefix, the plan, a per-key rate_limit, requests_today, total_requests, last_request_at, is_active and created_at. Two of those fields are worth watching when a connector misbehaves. If last_request_at never advances while you are pushing a client to make calls, that client is not reaching the server with that key — the problem is upstream of ClipSpeedAI entirely. And requests_today against rate_limit tells you whether an agent has been chattier than you assumed, which matters more with an autonomous caller than with a human clicking buttons.

Only the prefix is stored for display — the first 18 characters followed by an ellipsis. This is why the full value appears once and why "just look it up again" is not available. It is also why the list view is safe to screenshot in a way the creation screen is not.

Because keys are named and individually addressable, a key per client is practical: one for ChatGPT, one for whatever you keep configured as a control. Revoking the ChatGPT key then costs you exactly one integration instead of all of them. When you replace a key, create the new one, update every client that used the old one, confirm each still lists tools, and only then issue the DELETE against the old key's id. Revoking first turns a routine swap into an outage that lasts as long as your editing does.

A browser-resident client deserves one extra note: paste keys into credential fields, never into the message box. A key typed into a conversation is in that conversation's history, and no amount of deleting the message afterwards is worth relying on. If that has already happened, revoke that key and generate another.

Isolating the Fault: Key, Network, or Client?

When a connector will not work, the only question worth answering first is which of the three layers is broken. Two checks separate them without touching ChatGPT at all.

Check one: does the credential authenticate? Ask the REST management route, not the MCP endpoint:

curl -s https://api.clipspeed.ai/auth/api-keys \ -H "Authorization: Bearer csai_live_<your key>"

A JSON list of your key records comes back when the credential is accepted, and that answers the question cleanly: the key is live, the host is reachable, and DNS and TLS are fine from this network. It also shows you is_active for each key, which settles any doubt about whether the one you are using was revoked.

Do not run the equivalent bare GET against https://api.clipspeed.ai/mcp and try to read the result as a verdict on your key. A streamable HTTP MCP endpoint expects a protocol handshake with particular headers, and a plain browser-style GET can be refused on those grounds whether or not your credential is perfect. People regenerate healthy keys over exactly this misreading.

Check two: does another client work? Add the same server with the same key to a client in the fully supported tier and see whether the tool list appears. If it does, the server and credential are both fine and the fault lives in ChatGPT — which, given the rolling-out status, is where it usually lives. ClipSpeedAI MCP for Claude Code: Complete Setup Guide is the fastest control to stand up, since it is the single command shown above.

Running these in order turns a vague "it does not work" into one of three specific statements, and only one of the three is something you can act on.

One Endpoint, Nothing Installed Locally

MCP servers exist in two shapes. Some run as a process on your own machine and talk over stdio, launched by the client. Others run on the provider's infrastructure and are reached over HTTP with a URL and a credential. ClipSpeedAI is the second kind, and there is exactly one address:

https://api.clipspeed.ai/mcp

For a browser-based client this is not a preference, it is the only workable arrangement — a web app cannot launch a process on your laptop. That constraint happens to line up with how ClipSpeedAI is built, so nothing is being worked around. An npm package named clipspeed-mcp (v1.0.0, published 2026-07-10) also exists; regardless, the clipping itself runs on the remote server.

Three consequences follow. Your source video never transits your machine, so a laptop that goes to sleep mid-job is irrelevant. Server-side changes reach you without any reinstall, which also means the tool schemas the client reads are always current and a parameter list copied off a web page may not be. And the only network requirement is outbound HTTPS to api.clipspeed.ai from wherever the client actually runs — for ChatGPT that is OpenAI's infrastructure rather than your office network, which quietly removes corporate-firewall theories from your list of suspects. Remote MCP vs Local MCP Servers works through the wider trade-offs, and How MCP Servers Work: Architecture and Request Flow covers what the handshake is doing when a tool list appears.

The Ten Tools, Split Into Two Lifecycles

These are the real names. An agent that proposes anything else is inventing it, and the call will fail.

The recorded-video lifecycle revolves around a projectId. You submit something, you get a project, and every later question is asked about that project.

The live lifecycle revolves around a subscriptionId instead, and does not interchange with the one above. A subscription id is not a project id.

For exact parameter names and which fields are required, ask the connected assistant rather than trusting any page, including this one: "Read back the input schema for submit_to_clipspeed, field by field, and say which are optional." The client already holds that schema; it will recite it accurately, and it will be current. MCP Tool Design: Writing Tools an Agent Can Actually Use explains why schema-as-documentation beats a hand-maintained parameter table.

Notice what the shape of these tools implies for prompting. The two-step recorded flow means you submit, then check — plan for a follow-up call rather than expecting finished clips to arrive in the first response. And publish_to_youtube defaulting to private is a deliberate safety property: the failure mode of a confused agent is an unlisted video on your channel rather than a public one.

The Six Caption Template Ids

Caption style is the one place where guessing a value costs you a run, so it gets its own section. The template ids are exactly:

karaoke
hormozi
beasty
fire
youshaei
cinematic

You pass the chosen id as captionStyle. Call list_templates first if you want the assistant to have the list in context, then name your choice explicitly — "use hormozi" rather than "use the bold caption style". Descriptive requests invite an agent to invent a plausible-sounding id, and an invented id is a failure that surfaces halfway through a batch rather than at the start of it.

Fixing the caption style is also what makes a multi-video batch look like one body of work instead of six unrelated uploads, which is the whole reason the third walkthrough below starts there.

Walkthrough One: From a Climbing Video to a Private Upload

The full loop, with a human checkpoint before anything leaves your account. Note that discovery here is deliberately narrow — discover_trending looks at roughly the last three weeks, so this is a workflow for catching something on the way up, not for mining a back catalogue.

Find the fastest-growing recent video in the GTA niche. Tell me
which one you picked and what made it the best short-form
candidate. Then clip it. Check for results, and when they are
ready show me every clip with its title and viral score, sorted
best first. Do not publish anything.

What the assistant does. It calls discover_trending for the niche and states its pick with reasoning, which is your first and cheapest chance to catch a bad candidate. It calls submit_to_clipspeed with that video's URL, which gives it a projectId. It then calls check_clips against that id. If the first check comes back without finished clips, a well-behaved assistant says the project is not ready and checks again rather than announcing failure; if yours declares defeat on the first attempt, tell it plainly to check that project id again in two minutes.

When the clips arrive they carry a title, a viral score and a download URL each. Rank them, then apply your own judgement. A viral score orders candidates against each other; it does not know your channel, your audience or what you already posted last week. Treat it as a sort key rather than a verdict.

Publishing goes in a separate turn, on purpose:

Publish the second clip to YouTube. Read the exact title back to
me first and wait for my confirmation before calling the tool.
Leave the privacy status at the default.

That routes to publish_to_youtube with the project id and the clip id. Leaving privacyStatus alone means the upload lands private, so you can watch it on YouTube itself, confirm the captions and framing survived the round trip, and flip it public by hand. The read-back is not ceremony. Every other tool on this server produces something only you can see; this one touches an account other people can look at.

Walkthrough Two: A Live Session You Can Stop Without Losing Anything

Live clipping has a different rhythm. There is no submit-and-wait; there is a session that runs alongside the stream and produces clips while it goes.

Start clipping this live stream: <stream URL>
Give me the subscription id. Then check the session every few
minutes and tell me each time new clips land, with their scores.
Tell me before the session lapses so I can decide whether to
extend it.

What the assistant does. clip_livestream opens the session and returns a subscriptionId. Ask for that id out loud in the prompt — it is the handle for everything that follows, and having it visible means you can hand it to a fresh conversation later instead of losing the session to a closed tab. From then on the assistant polls check_livestream with that id. A status of monitoring is the healthy steady state: the stream is still live and still being clipped. Anything else is worth reading carefully rather than skimming past.

Extending is a decision you should own. If the stream is still producing material worth keeping, say so and the assistant calls extend_livestream against the same subscription id. When you have what you need:

Stop the live session, then list every clip it produced with
scores and download links.

stop_livestream ends the session and the clips already made are kept — stopping does not discard them, and they stay downloadable afterwards. That is worth knowing because it removes the incentive to leave a session running "just in case", which is the main way an unattended live session becomes a problem. Stop sessions you are not watching, and check your plan's limits in the ClipSpeedAI app before you start several at once. Livestream Clipping API: Clip While You Stream goes deeper into the timing model.

Walkthrough Three: One Caption Style Across a Back Catalogue

The third pattern is throughput with a consistent look, and it starts by pinning the caption style so the batch is coherent.

List the caption templates, then use "hormozi" for everything
below. Clip these four videos, keep every project id, and check
each project until it is done:
<url 1>
<url 2>
<url 3>
<url 4>
When all four are finished give me one table: source video,
clip title, viral score, download URL. Flag the lowest scorers
as probably not worth posting. Publish nothing.

What the assistant does. One list_templates call, then four submit_to_clipspeed calls carrying captionStyle: "hormozi", then four project ids held in context while it polls check_clips for each. Tracking four project ids by hand across browser tabs is where this workflow usually goes wrong when a human does it; an assistant that holds them and reports back in one table is doing the part that is genuinely tedious.

Ask for the ids in the table too. If the conversation is interrupted, a list of project ids lets you resume with a bare check_clips call instead of resubmitting anything.

Once you know which source performed best, there is a second call worth making:

For the best-scoring project in that batch, pull the creator pack
and lay it out per clip.

creator_pack returns per-clip suggested titles, hooks and best posting times for that project. Asking for it laid out per clip matters, because the value is in the pairing — this hook with this clip at this time — and a flattened summary loses that. This is also the natural place to hand off to a scheduler. AI Agent Video Automation: End-to-End Workflows and MCP for Video Editing and Clipping Workflows take the pattern further, and if you would rather script the batch than prompt it, Video Clipping API for Developers and AI Clipping API: Programmatic Short-Form Video approach the same shape from code.

When It Breaks: Symptom, Cause, Next Move

1. No way to add a custom MCP server by URL. Availability of custom connectors in ChatGPT is controlled by OpenAI and may not be present in every account. There is no fix on ClipSpeedAI's side and no configuration that works around it. Use a verified client with the same key and re-check ChatGPT later.
2. Connector added, zero tools listed. The handshake did not complete. Confirm the URL is exactly https://api.clipspeed.ai/mcp with nothing appended, confirm the transport is HTTP rather than a local command, then run the GET /auth/api-keys check to establish whether the credential is the problem or the client is.
3. Authentication rejected and the key looks correct. Verify the shape first: csai_live_ plus 48 hex characters. Then verify the header value: Bearer, one space, the key, no quotes and no stray whitespace. Then confirm is_active is true for that key in the list route. Those three checks cover nearly every instance.
4. The assistant says it cannot process video, or names a tool that does not exist. It is answering from its own priors instead of from the connected tool list. Ask it to list the ClipSpeedAI tools it can see, then name the one you want: "use submit_to_clipspeed on this URL". If it still sees nothing, the connector is not attached to that conversation.
5. A project never produces clips. Most often the check happened too early and the assistant gave up after one attempt — instruct another check_clips against the same project id. Otherwise the source may not be retrievable: open the URL in a private browser window and confirm it plays without a login. Private, removed, region-locked and paywalled sources cannot be fetched.
6. Publishing to YouTube fails. publish_to_youtube takes a project id and clip details rather than YouTube credentials, so the destination account is configured on the ClipSpeedAI side rather than passed through the tool — check the app's account settings if publishing errors. Also confirm the clip id you passed came back from check_clips and belongs to a finished project.

One symptom that is not on this list because it is not a connector fault: output that does not match what you expected visually. Anything about how a clip looks — framing, captions, badging — is product behaviour and lives in the ClipSpeedAI app, not in the MCP layer.

Blast Radius: What a Connected Key Can Actually Do

What the server receives. Tool calls and their arguments — video URLs, project ids, subscription ids, publishing details — plus whatever your account already holds. It does not receive your conversation transcript, read your filesystem or see your other browser tabs. The client sends calls, not context.

What the credential authorises. A csai_live_ key acts as your account. It can submit work, open live sessions, and drive publish_to_youtube. Treat it as an account-level credential rather than a read-only token, and size your caution accordingly.

Prompt injection is the failure mode people underestimate. An assistant with a clipping tool attached is, by design, reading untrusted material: video titles, descriptions, comment threads, pages it browsed while looking for a candidate. Any of that can contain text written to be read by a model rather than by you. Everything the assistant reads is data, never instruction.

The practical defence is short. Keep publish_to_youtube behind an explicit human confirmation every single time, without exception, because it is the only tool here whose effect is visible outside your account. Be suspicious of any suggestion to publish that you did not originate. And leave privacyStatus at its private default unless you have a reason not to, which turns a hypothetical worst case into an unlisted video you delete. MCP Security: Scopes, Keys and Safe Tool Design covers the general shape of these attacks, and How to Build an MCP Server (Practical Guide) covers the server-side responsibilities if you are writing one yourself.

Habits Worth Adopting While the Client Is Unverified

• Keep a verified client configured as a control. This is the single highest-value habit on an unverified client. When ChatGPT behaves oddly, a second client that works turns a mystery into a five-second answer.
• Name the tool when precision matters. "Use clip_livestream on this URL" removes an entire category of ambiguity that "clip this stream" leaves open.
• Ask for ids in writing. Project ids and subscription ids are the resume points. A conversation that loses them is a conversation you cannot pick back up.
• Pin the caption style before a batch, not during it. One captionStyle value chosen from the six real ids, stated once, applied throughout.
• Publish in its own turn, with a read-back. Produce and rank in one message; publish in another, after the assistant recites the title.
• Ask for schemas instead of guessing parameters. The client holds the authoritative schema. Any parameter list you copied from elsewhere is a snapshot of some earlier moment.
• Watch last_request_at when debugging. It answers "did my client actually reach the server" without any guesswork.
• Stop live sessions deliberately. Build the stop into the plan rather than leaving a session to lapse on its own.

What This Page Deliberately Does Not Claim

That ChatGPT works. Stated once more because it outranks everything else here: ClipSpeedAI has not confirmed an end-to-end run through ChatGPT, and whether the connector surface exists is OpenAI's to decide. The server description on this page is accurate; the client half carries a real asterisk.

That there is a free path to agent use. Billing is paid-only. A one-time $1 charge opens a three-day trial that converts to your chosen plan afterwards unless you cancel within it. From there: Starter at $15/mo, Pro at $29/mo, Ultra at $49/mo, with annual billing cutting those in half. A free demo exists — one demo, on a video shorter than 30 minutes — which is enough to judge output quality and not enough to drive an agent.

That clips arrive instantly. Expect a submit-then-check rhythm rather than an immediate return. Write prompts that plan for a follow-up call.

That viral scores sit on a documented scale. check_clips returns a viral score per clip. This page does not assert a range, a threshold or a number above which a clip is good, because no such scale is documented. Rank with it; do not build rules on numeric cutoffs you inferred.

That publishing reaches anywhere but YouTube. publish_to_youtube is the only distribution tool in the set. Every other destination is a download and a manual upload, using the download URLs check_clips hands back.

That the tool list extends past ten. If a capability is not one of the ten tools above, this server does not do it — however confidently a model asserts otherwise. Ask it to list its tools and the claim collapses.

Verified Clients That Work Today With the Same Key

One server, one credential, so switching clients is data entry rather than a migration. Nothing in the walkthroughs above changes.

The quickest path from here is ClipSpeedAI MCP for Claude Code: Complete Setup Guide — the single command shown earlier, and you are running these workflows in a terminal. If a terminal is not what you wanted, ClipSpeedAI MCP for Claude (claude.ai): Complete Setup Guide is the closest analogue to the browser experience you were trying to build in ChatGPT, with OAuth rather than a pasted key. ClipSpeedAI MCP for Claude Desktop: Complete Setup Guide covers the desktop app, and ClipSpeedAI MCP for Windsurf: Complete Setup Guide is fully verified if you would rather work in an editor; ClipSpeedAI MCP for Cursor: Complete Setup Guide sits in the compatible tier alongside it, and Claude Code vs Cursor for MCP Workflows compares those two directly.

Among the other terminal agents, ClipSpeedAI MCP for OpenClaw: Complete Setup Guide and ClipSpeedAI MCP for Hermes Agent: Complete Setup Guide are configured the same way as the Codex guide mentioned earlier — an HTTP MCP server plus your key in an Authorization header, following each client's own documentation for where that goes. Their compatible tier reflects pending verification, not a known defect.

If you are new to the protocol itself, What Is MCP? Model Context Protocol Explained is the place to start, with MCP vs REST API: When to Use Each and MCP vs Function Calling: What Actually Differs for the comparisons people usually want next. MCP for Creators: Automating Video Without Code is the version written for people who never open a terminal, and Best MCP Servers for Video and Content Workflows places ClipSpeedAI alongside other servers you might attach at the same time.

Re-check ChatGPT's connector settings every so often. If the field appears, connecting is the four values in the table near the top of this page, and everything else here already applies.

Frequently asked questions

Can I add ClipSpeedAI to ChatGPT right now?

Maybe — it depends on your ChatGPT account, not on ClipSpeedAI. The support tier is ROLLING OUT: availability of custom MCP connectors in ChatGPT is controlled by OpenAI and may not be present in every account, and ClipSpeedAI has not verified the ChatGPT path end to end. Check your connector settings for the ability to add a server by URL. If that field exists, the four values on this page are everything you need. If it does not, no configuration changes that.

What does a ClipSpeedAI API key look like?

The prefix csai_live_ followed by 48 hexadecimal characters. The full key is shown once, at creation, under Account then API & Integrations then Generate API Key. Only the prefix is stored for display — the first 18 characters plus an ellipsis — so there is no way to retrieve the whole value later. Copy it into a password manager immediately, and check the shape before pasting: a string that does not start with csai_live_ is the wrong text.

Can I revoke a key, and how do I tell if one is already revoked?

Yes. Revocation is a real operation: DELETE /auth/api-keys/:id sets is_active to false and stamps revoked_at. To check the current state of every key on your account, call GET /auth/api-keys, which returns the id, name, key prefix, plan, rate limit, requests today, total requests, last request time, is_active flag and creation date for each one. Keys are named and individually addressable, so a key per client is practical and revoking one does not disturb the others.

Which caption template ids actually exist?

Six: karaoke, hormozi, beasty, fire, youshaei and cinematic. You pass the chosen id as captionStyle. Call list_templates if you want the assistant to hold the list in context, then name your choice explicitly rather than describing it — a descriptive request invites the model to invent a plausible-sounding id, and that failure surfaces partway through a batch instead of at the start.

Will publishing put a clip straight onto my public channel?

publish_to_youtube defaults to private. It takes a projectId plus optional clipId, title and privacyStatus, so leaving privacyStatus alone lands the upload private and you flip it public by hand after checking it on YouTube. Keep the tool behind an explicit human confirmation regardless — it is the only tool in the set whose effect is visible outside your account.

How far back does discover_trending look?

Roughly the last three weeks. It finds the fastest-growing recent video in a niche, which makes it a tool for catching something while it is climbing rather than a way to search an archive. If you want to work through older material, feed URLs to submit_to_clipspeed directly instead.

Do I have to install anything on my machine?

No. ClipSpeedAI runs a remote MCP server at https://api.clipspeed.ai/mcp over streamable HTTP, so a client needs a URL and a credential and nothing else. This is also why a browser-based client can work at all — it cannot launch a local process. An npm package named clipspeed-mcp v1.0.0 was published on 2026-07-10; either way, the clipping runs on the remote server.

Why did check_clips come back with nothing right after I submitted?

Because the project was not finished yet. Expect a submit-then-check rhythm rather than an immediate return: submit_to_clipspeed gives you a projectId, and check_clips is asked about that id afterwards, often more than once. Tell the assistant explicitly to check the same project id again in a couple of minutes. If repeated checks still return nothing, confirm the source URL plays in a private browser window without a login — private, removed, region-locked and paywalled videos cannot be fetched.

What does this cost, and is there a free option?

Billing is paid-only. A one-time $1 charge opens a three-day trial that converts to your chosen plan afterwards unless you cancel within it. Plans run Starter $15/mo, Pro $29/mo and Ultra $49/mo, with annual billing cutting those in half. A free demo exists — one demo, on a video shorter than 30 minutes — which is enough to judge output quality and not enough to drive an agent workflow.

Which curl command actually tests my key?

Send a GET to /auth/api-keys with the Authorization header. A JSON list of your key records means the credential is accepted and the host is reachable. Do not run a bare GET against the /mcp endpoint and read the result as a verdict on your key — a streamable HTTP MCP endpoint expects a protocol handshake with specific headers and can refuse a plain GET whether or not your credential is valid.

Related reading