ClipSpeedAI MCP for OpenClaw: Complete Setup Guide

Everything OpenClaw needs in order to reach ClipSpeedAI fits on two lines: the endpoint https://api.clipspeed.ai/mcp, and a header reading Authorization: Bearer <API_KEY>. There is no OpenClaw-specific endpoint, no forked build, and nothing you have to install locally first. The transport is streamable HTTP. GUI clients that can open a browser may authenticate through OAuth instead; OpenClaw sits in the header-and-key group, along with every other terminal-shaped agent runtime.

ClipSpeedAI files OpenClaw under COMPATIBLE rather than fully supported, and the word carries a specific meaning: identical protocol, verification still in progress. The clients walked through end to end are Claude on claude.ai, Claude Code, Claude Desktop and Windsurf. Nothing on OpenClaw is known to be broken — it has simply not been exercised tool by tool by the ClipSpeedAI team. That changes where you look when something misfires, which is why this guide runs backwards compared with most setup pages. It opens with a raw HTTP call that proves the server independently of any client, so that every later symptom can be pinned on exactly one component instead of two.

After the handshake lands you have ten tools. They cover recorded video (submit a URL, get scored and captioned 9:16 clips back), live broadcasts (open a session, poll it, extend it, stop it), packaging (suggested titles, hooks and posting windows) and one outward action (publish a finished clip to YouTube, private by default). Below, in this order: the wire-level smoke test, what your agent actually reads at connect time, what the compatible tier does and does not restrict, key minting and rotation, the OpenClaw config, three checks that localise a fault, the full tool reference, three worked runs, eight failure modes, and the things this page deliberately refuses to promise.

Start at the Wire, Before You Touch Any Config File

Most connection problems are diagnosed backwards. Someone edits a config, restarts, sees nothing, and then spends an hour guessing whether the fault is the file, the key, the network or the server. Reverse it. One curl settles the server, the key and the network path in a single request, and it costs nothing — the protocol handshake methods (initialize, tools/list, notifications, ping) are not metered against your key.

Set the key in your shell first, so it never lands in a file:

export CLIPSPEED_API_KEY="csai_live_..."

Then ask the server to enumerate its own tools:

curl -i https://api.clipspeed.ai/mcp \ -H "Authorization: Bearer $CLIPSPEED_API_KEY" \ -H "Content-Type: application/json" \ -H "Accept: application/json, text/event-stream" \ -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Read the reply carefully, because it does not look like ordinary JSON. The response comes back with Content-Type: text/event-stream and is framed as a server-sent event: a line reading event: message, then a line beginning data: that carries the JSON-RPC payload. Under curl -i that framing is easy to mistake for a malformed response. It is not. The pass condition is simple — find the ten tool names inside that data: line. If the ten names come back, the server is reachable, your key is valid and nothing between you and api.clipspeed.ai is mangling the Authorization header. Every problem after this point lives inside OpenClaw. Keep the command in your shell history; you will run it again the first time something looks wrong.

What Your Agent Actually Reads at Connect Time

That tools/list payload is the whole of the Model Context Protocol in one artifact, and looking at it teaches the protocol faster than any diagram. Inside the data: line is an array. Each element has three things: a name, a description written in plain English, and an inputSchema in JSON Schema describing the arguments.

The consequence worth absorbing is that the descriptions are the documentation, and the model is the reader. When ClipSpeedAI's discover_trending describes itself as finding the fastest-growing recent video in a niche, and notes that it only searches videos published in roughly the last three weeks, that sentence is not marketing copy sitting on a website — it is shipped to your agent at connect time. Ask OpenClaw for "the biggest video of all time in this niche" and a well-behaved model will tell you the tool cannot do that, because it read the constraint. Nobody hard-coded that refusal.

The same applies to shape. submit_to_clipspeed describes itself as the clip button — you drop a video URL or a file into it. check_clips describes what it hands back for a given projectId: finished, scored, captioned vertical clips, each with a title, a viral score and a download URL. Your agent chains those two without being taught the sequence, because the second tool's description names the identifier the first one returns.

This is why an MCP integration behaves differently from a hand-rolled HTTP wrapper. With a wrapper you write glue code for every call site. Here you publish one description layer and any conforming client can consume it. What Is MCP? Model Context Protocol Explained is the place to start if the concept is new, and How MCP Servers Work: Architecture and Request Flow traces a single call from client to server and back. If you are weighing this against simply calling the platform over HTTP, MCP vs REST API: When to Use Each is the fair comparison, and MCP vs Function Calling: What Actually Differs places it against the older provider-specific pattern.

The Compatible Tier, Read Literally

ClipSpeedAI sorts clients into three buckets, and precision here saves you from chasing phantom limits.

• Fully supported, verified end to end: Claude on claude.ai, Claude Code, Claude Desktop, Windsurf.
• Compatible, same protocol with verification in progress: Cursor, Codex, OpenClaw, Hermes.
• Rolling out, gated by the vendor and unverified: ChatGPT.

The tier says nothing about your account. It does not cap your tools, gate any feature, or change what the server will do for you. What has not happened is a ClipSpeedAI engineer sitting inside OpenClaw and confirming that each of the ten tools round-trips cleanly through that particular runtime's transport handling.

The practical rule that falls out: treat any oddity as client-side until the wire test says otherwise. And keep one verified client installed as a control. ClipSpeedAI MCP for Claude Code: Complete Setup Guide is a single command against the same server with the same key, which makes it the cleanest reference implementation to compare behaviour against when you need a second data point. The sibling pages at this same tier — ClipSpeedAI MCP for Cursor: Complete Setup Guide and ClipSpeedAI MCP for Codex CLI: Complete Setup Guide — describe the identical server from their own clients' angles.

What You Need Before Editing Anything

An account with an active plan or trial. Starter runs $15/mo, Pro $29/mo, Ultra $49/mo, and annual billing takes half off those figures. A one-time $1 opens a three-day trial that rolls into whichever plan you selected unless you cancel inside the window. A free demo exists — one demo, on a video shorter than 30 minutes — which is enough to judge the output quality but not enough to drive any of the runs described later on this page. There is no permanently free plan.

An API key. Minting one is the next section.

An OpenClaw install that can register a remote MCP server over HTTP and attach a custom header. Both halves matter — a client that can reach a URL but cannot set Authorization is useless here. The config file location and the exact field names belong to OpenClaw, so read OpenClaw's own MCP documentation for those. This guide will not invent them for you, and you should distrust any page that prints them confidently without linking a source.

Outbound HTTPS to api.clipspeed.ai. Corporate proxies that rewrite or strip Authorization headers are a real failure mode and get their own entry in the troubleshooting list.

curl. Not optional in spirit, whatever your package manager thinks. It is the only tool on this page that can prove the server without involving the client.

Optionally, a YouTube account connected inside ClipSpeedAI, if you intend to use publish_to_youtube. Without it that one tool errors and no amount of OpenClaw configuration will fix it.

Minting a Key: csai_live_, 48 Hex Characters, Shown Once

Sign in, open Account → API & Integrations, and click Generate API Key. Under the hood that is a POST /auth/api-keys. What comes back is a string beginning csai_live_ followed by 48 hexadecimal characters — 24 random bytes rendered as hex.

Copy it in that moment. ClipSpeedAI stores only the prefix for display purposes — the first 18 characters followed by an ellipsis — so the full secret exists in your clipboard and nowhere else. There is no "reveal" button waiting for you tomorrow. If you lose it, you mint a new one; that is the entire recovery path.

A key is more than an opaque string. GET /auth/api-keys lists what the platform tracks per key: an id, the name you gave it, the stored prefix, the plan it is attached to, its rate_limit, requests_today, total_requests, last_request_at, whether it is active, and when it was created. Two of those are worth watching. requests_today against rate_limit tells you how much of the key's daily tool-call budget you have spent — useful when an agent starts looping. last_request_at tells you whether a key you thought was retired is still being used by something.

Revoking

Revocation is real and immediate: DELETE /auth/api-keys/:id flips is_active to false and stamps revoked_at. The same Account screen exposes it. A revoked key stops working; there is no grace window and no undo.

Because of that, rotate in this order and no other: mint the new key, update the environment variable or config OpenClaw reads, restart OpenClaw, confirm the tools still enumerate, then revoke the old one. Reverse those last two steps and you have taken yourself offline for however long the restart takes.

Revoke without hesitation if a key ever appears in a commit, a screenshot, a support ticket, a pasted log or a shared terminal. It authenticates as you.

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.

Pointing OpenClaw at the Endpoint

Two values come from ClipSpeedAI and are fixed:

• URL: https://api.clipspeed.ai/mcp
• Header: Authorization: Bearer <API_KEY>

Everything else — where the config file lives, whether the transport field is called type or transport, whether the value is spelled http or streamable-http, how headers are expressed — is OpenClaw's surface, and OpenClaw's documentation is the authority. Add ClipSpeedAI as a remote HTTP MCP server, set that URL, and attach your key in the Authorization header, following whatever shape OpenClaw's docs specify for those three things. If OpenClaw supports environment-variable interpolation in its config, use it and keep the literal key out of the file entirely.

The one config this guide will print verbatim is the canonical CLI form on a fully supported client, because it is documented by the product itself and makes a useful control:

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

Read that as a specification rather than a command to translate mechanically: transport is HTTP, target is that URL, credential rides in a header. Any client that can express those three facts can connect.

An npm package, clipspeed-mcp v1.0.0, was published on 2026-07-10 and also exists. If OpenClaw can speak HTTP with custom headers — and this page assumes it can — you have no reason to involve it. Fewer moving parts is the whole argument.

Three Checks That Localise a Fault

Restart OpenClaw after editing the config. MCP configuration is read at process start in essentially every client, so a stale process explaining that nothing happened is the single most common false alarm in this whole exercise. Restart the runtime, not merely the conversation.

Then run three checks in order and stop at the first one that fails. Each one narrows the search space to a different component.

1. Is the server listed at all? Enumerate OpenClaw's connected MCP servers. If clipspeed is missing, OpenClaw never read your config — wrong file, invalid syntax, or a process that did not restart. Nothing to do with ClipSpeedAI.
2. Does it expose ten tools? A server listed with zero tools means the connection opened and the handshake did not complete. Since your curl already proved the server answers tools/list, this is a transport or header mismatch inside OpenClaw.
3. Does a call actually round-trip? Ask the agent to list the caption templates. list_templates takes no arguments and renders no video, which makes it the cheapest real call in the set. It should return exactly six ids: karaoke, hormozi, beasty, fire, youshaei and cinematic. Seeing those six names is proof of a working end-to-end path.

One correction to a claim you will find on other pages, including an earlier version of this one: list_templates is not free. It renders nothing, but the server meters tools/call generally, so it increments requests_today against your key's daily rate_limit like any other tool. The genuinely unmetered check is the curl handshake from the first section, which uses tools/list rather than tools/call. Use the curl when you want a free probe; use list_templates when you specifically need to prove that OpenClaw can invoke a tool.

Only once step three passes should you submit real video.

Bearer Keys and OAuth: Why OpenClaw Takes the First Path

The server accepts both, and the split is about what the client can do rather than about security posture.

OAuth suits clients that can open a browser, walk you through a consent screen and hold the resulting token themselves. That is the path described in ClipSpeedAI MCP for Claude (claude.ai): Complete Setup Guide, where you never handle a credential at all. Tokens obtained that way expire and are scoped, and nothing long-lived ends up in a file on disk.

Bearer keys suit everything else: terminals, headless boxes, CI runners, scheduled jobs, agent runtimes. OpenClaw is in this category. The tradeoff is honest — a Bearer key is a static secret that keeps working until you explicitly revoke it. That property is exactly what makes it scriptable and exactly what makes a leak dangerous. There is no clock quietly limiting the blast radius; revoked_at is the only thing that stops it.

Two habits offset most of the risk. Use a distinct key per environment, so revoking your laptop's key does not take down a cron job. And read last_request_at on your key list occasionally — a key you retired months ago that shows recent traffic is telling you something. MCP Authentication: OAuth and Bearer Keys covers the mechanics of both flows in more depth.

Why This Particular Server Cannot Run on Your Laptop

MCP servers come in two physical shapes. A local server is a process the client spawns and talks to over stdio, which is the right design when the tool needs your filesystem or must not send data anywhere. A remote server is an HTTP service the client dials over the network and authenticates against.

ClipSpeedAI is remote by necessity, not by preference. The work behind a single submit_to_clipspeed call is transcription, moment scoring, face tracking, reframing to 9:16 and caption burn-in — rendering work that needs machines you do not have and would not want running while you use your laptop for anything else. There is no version of this that becomes a local process without becoming a much worse product.

Two things follow. Availability and speed are ClipSpeedAI's responsibility; your client's job is to hold a connection and poll. And your agent's context stays small, because what crosses the wire is arguments and identifiers rather than video. Remote MCP vs Local MCP Servers works through where each shape earns its place.

Ten Tools and What Each Hands Back

The names are exact. An agent that guesses at a name receives an error rather than a near-miss, which is a feature.

For arguments beyond the ones named above, read the inputSchema in your own tools/list response rather than trusting a table on the internet — that payload is authoritative for the version of the server you are actually talking to, and it is one curl away.

The seam that trips up agent prompts is the asynchronous one: submit_to_clipspeed returns an identifier, not clips, and clip_livestream returns a subscription, not footage. A prompt written as though output arrives in the same turn will look broken when it is merely early. MCP Tool Design: Writing Tools an Agent Can Actually Use is a good read if you are designing a server with a similar shape and want the async contract to be legible to a model.

Worked Run 1: A Back Catalogue, One Prompt

Starting with the batch case is deliberate — it is where an agent runtime beats a web app most decisively, and it is the run that most obviously belongs in something like OpenClaw rather than a browser tab.

Read urls.txt. For each entry, submit it to ClipSpeed with the
hormozi caption style. Record the projectId per URL as you go.
Then poll each project until clips land, and write one CSV row
per clip: source URL, projectId, clip title, viral score,
download URL.

The sequence the agent runs: list_templates once to confirm hormozi is a live id, then submit_to_clipspeed per URL, collecting projectIds, then check_clips per project until each returns, with the agent's own file tools writing the CSV. Only two of those steps are ClipSpeedAI's. Everything else is capability OpenClaw already had, which is the entire point of exposing the engine as tools rather than as a website.

Three operational notes earned the hard way.

Instruct the agent to persist projectId before doing anything else with it. That identifier is the only handle for check_clips, creator_pack and publish_to_youtube. An agent that submits fifty videos and then loses track of which id belongs to which source has done fifty jobs and can retrieve none of them coherently.

<strong>Submit in waves.</strong> Every tool call increments requests_today against your key's rate_limit, and a polling loop across many projects burns through that budget faster than the submissions themselves did. Small batches keep both the rate budget and your own attention manageable.

Score-based filtering needs a stated rule. check_clips returns a viral score per clip; ClipSpeedAI does not publish a fixed scale or a documented cut-off, so do not write a prompt that assumes one. Rank within a batch and keep the top n, which is meaningful without pretending to know what any absolute number means.

MCP for Creators: Automating Video Without Code walks the same pattern for people who would rather not specify the CSV step themselves.

Worked Run 2: Riding a Broadcast While It Happens

Live is a separate mode with a separate lifecycle, not a hurried version of the recorded path. Clips are cut from the broadcast as it runs, so the session is a thing you open, watch and close.

Start clipping <live-stream-url>. Poll the session every few
minutes and show me each clip as it lands, with its title and
score. Tell me when the stream ends. Do not extend the session
without asking me.

clip_livestream opens the session and returns a subscriptionId. That value is the handle for the remaining three live tools, so it belongs in whatever the agent treats as durable memory rather than in a message it might lose track of.

check_livestream polls it. The status field is the one to read: monitoring means the broadcast is still live and still being clipped, so an empty or short clip list at that point is normal rather than a failure. Have the agent poll on a stated interval and report incrementally; do not have it poll in a tight loop, because every poll is a metered tool call.

extend_livestream lengthens an active session. The instruction "do not extend without asking" in the prompt above is doing real work — extending is the one live action that quietly consumes more of your plan while you are not watching, and an agent that decides on its own to keep going is an agent spending your money on a stream that got boring.

stop_livestream closes the session early. Anything already produced is kept and stays downloadable, so stopping is not destructive; there is no reason to leave a session running out of caution.

Livestream Clipping API: Clip While You Stream goes further into the live path.

Worked Run 3: From a Trend to a Private YouTube Upload

The third run is the one people picture when they hear "agent", and it is worth doing last, after you trust the pieces.

Find the fastest-growing recent video in the chess niche.
Clip it with karaoke captions. When the clips are ready,
rank them by viral score and show me the top three with
suggested titles and posting times. Then stop and wait for me.

Step by step: discover_trending on the niche returns recent, fast-growing candidates — recent being the operative constraint, since the tool searches only the last few weeks and will not surface an all-time hit no matter how the prompt is phrased. The agent feeds the winner's URL to submit_to_clipspeed with captionStyle: "karaoke" and holds the returned projectId. It polls check_clips, ranks what comes back by score, and calls creator_pack on the same projectId for titles, hooks and posting windows.

Then it stops. That last sentence in the prompt is the important one. Everything up to this point is reversible — a clip you dislike costs you nothing but the render. Publishing is not reversible in the same way, and it is the only tool in the set that reaches outside ClipSpeedAI.

When you do publish, publish_to_youtube takes the projectId, the clipId you chose, and optionally a title and privacyStatus. It defaults to private, and that default exists precisely because an agent holding a YouTube connection is one bad prompt away from an embarrassing public upload. Leave it private, look at the result on YouTube, and flip it yourself. AI Agent Video Automation: End-to-End Workflows and MCP for Video Editing and Clipping Workflows both extend this pattern.

Eight Ways This Breaks

Ordered roughly by how often each one is the actual cause.

1. OpenClaw does not list the server at all. The config was never read. Validate the file's syntax — a trailing comma is enough — confirm you edited the file OpenClaw actually loads rather than one that merely looks plausible, and restart the process. This has nothing to do with ClipSpeedAI and no key change will help.

2. The server is listed but exposes zero tools. The connection opened; the handshake did not finish. This is almost always the transport field: if OpenClaw wanted streamable-http and got http, or the reverse, you land here. Vary that field first. Your curl already proved the server answers, so the fault is local by elimination.

3. 401 Unauthorized. Either the header is malformed or the key is dead. The value must be the literal word Bearer, one space, then the key — no surrounding quotes, no Basic, no missing prefix. Check for a trailing newline if you pasted from a terminal. And check that the key still exists: a revoked key has is_active false permanently, and rotation is one-way.

4. Tools list fine but every call fails, while curl from the same machine works. Something is dropping the Authorization header between OpenClaw and the API — a corporate proxy, a VPN, or a client that attaches headers on the initial connection but not on subsequent requests. Try a different network to confirm before filing anything.

5. Calls start returning rate-limit errors. Every tools/call counts. Polling loops are the usual culprit: an agent checking six projects every thirty seconds spends a lot of budget doing nothing. Compare requests_today against rate_limit on GET /auth/api-keys to confirm, then lengthen the poll interval.

6. check_clips comes back empty right after submitting. Nearly always impatience. Submission is asynchronous; the render is still running. Poll again. If it stays empty far longer than a comparable job, check that the source URL is reachable and not private, member-only or geo-restricted.

7. publish_to_youtube errors. It needs a YouTube account connected inside ClipSpeedAI. Connect it in the web app and retry. No OpenClaw-side configuration can substitute for a missing account link.

8. It works in another client but not in OpenClaw. This is the compatible tier showing itself, and it is genuinely useful information. Reproduce against Claude Code as a control, then report the difference to ClipSpeedAI with the exact config block you used and the exact symptom. That is how a client moves tiers.

Key Hygiene for an Agent Runtime

A Bearer key is a bearer credential in the literal sense: possession is authorisation. Keep it in an environment variable or a secret store, never in a config file tracked by git, never in a screenshot, never pasted into a log you are about to attach to an issue.

If you share your OpenClaw configuration with a teammate, strip the key and have them mint their own. Separate keys are not bureaucracy — they are the difference between revoking one credential and taking down everyone's automation at once. The per-key counters make this pay off twice: with one key per person and per job, last_request_at and total_requests actually tell you who is doing what.

On what the server can observe: it receives the arguments your agent sends — video and stream URLs, a caption style, project and subscription identifiers. MCP tool calls carry their declared arguments and nothing else, so the server does not see your filesystem, your repository, your other MCP servers or the rest of your conversation. The flow in the other direction deserves a moment's thought though: check_clips returns download URLs into your agent's context, and an agent that helpfully pastes those into a public channel has published your clips earlier than you meant to. Treat them as semi-private by default.

The agent-specific rule is the one from Worked Run 3, restated: keep irreversible actions behind a human. publish_to_youtube is the only tool here that touches the outside world, and its private default is the product agreeing with you about that. MCP Security: Scopes, Keys and Safe Tool Design covers the general principles.

Operating Rules Worth Adopting

• Keep the curl in your shell history. It is the only diagnostic on this page that excludes the client, and it costs nothing.
• One key per environment. Laptop, scheduled job, teammate. Rotation then costs a restart rather than an outage.
• Name your keys meaningfully. The name is returned by the list endpoint alongside the counters, and "key 3" tells you nothing when you are deciding which one to revoke.
• Pin the caption style. Pick one of karaoke, hormozi, beasty, fire, youshaei or cinematic and put the id in the prompt. A channel with a consistent caption look reads as deliberate; one that rotates styles reads as accidental.
• Let the agent poll, and tell it how often. "Check every few minutes" beats both asking repeatedly yourself and letting a model invent a tight loop that eats your request budget.
• Persist every identifier. projectId and subscriptionId are the only handles into work already in flight.
• Keep a verified client installed. One command, same server, same key, and "is it broken?" becomes answerable rather than debatable.
• Rank scores within a batch. Never against an absolute threshold you assumed.
• Confirm before anything publishes. Private first, review on YouTube, flip it yourself.

What This Page Refuses to Promise

On verification. OpenClaw is compatible, not verified end to end. Nothing here is known to be broken; it is untested on this specific client by ClipSpeedAI, and that distinction is the whole reason the wire test comes first.

On billing. Rendering work is governed by your plan — Starter, Pro or Ultra, or a trial. Separately, your API key carries its own rate_limit and daily requests_today counter for tool calls. Those are two different meters, and this page will not claim a relationship between them beyond what the key list endpoint plainly reports.

On live sessions. They are opened with clip_livestream, extended with extend_livestream and closed with stop_livestream. Any specific ceiling on session length is a plan and product detail rather than something to memorise from a guide; check your own account. Clips made before a stop are kept.

On publishing. publish_to_youtube is the only publish target in this tool set. Whatever the web app offers elsewhere is not part of the MCP surface.

On sources. The engine needs something it can actually fetch. Private, paywalled and geo-restricted videos will not process.

On discovery. discover_trending looks at recently published videos — roughly the last three weeks — and ranks by growth. It will not surface evergreen or all-time material, by design rather than by limitation.

On scoring. check_clips returns a viral score. This page does not tell you its range or what number is "good", because that has not been published, and inventing a threshold would be worse than leaving you to rank relatively.

Further Reading, Sorted by What You Are Trying to Do

If OpenClaw is fighting you and you need clips today. ClipSpeedAI MCP for Claude Code: Complete Setup Guide is one command against the same endpoint with the same key. ClipSpeedAI MCP for Claude Desktop: Complete Setup Guide and ClipSpeedAI MCP for Windsurf: Complete Setup Guide are the other fully verified routes, and ClipSpeedAI MCP for Claude (claude.ai): Complete Setup Guide is the OAuth path if you would rather never hold a key.

If you are evaluating several runtimes at once. The other compatible-tier clients have their own pages — ClipSpeedAI MCP for Cursor: Complete Setup Guide, ClipSpeedAI MCP for Codex CLI: Complete Setup Guide and ClipSpeedAI MCP for Hermes Agent: Complete Setup Guide — while ClipSpeedAI MCP for ChatGPT: Complete Setup Guide tracks a rollout gated by that vendor. Claude Code vs Cursor for MCP Workflows compares two of them head on.

If you want to build something with the same shape. How to Build an MCP Server (Practical Guide) covers exposing your own tools, and Best MCP Servers for Video and Content Workflows is useful for deciding what else belongs in the same agent.

If MCP turns out to be the wrong layer for you. That is a legitimate conclusion, and Video Clipping API for Developers and AI Clipping API: Programmatic Short-Form Video describe calling the platform directly instead.

Frequently asked questions

Is ClipSpeedAI officially supported in OpenClaw?

OpenClaw is listed as COMPATIBLE, not fully supported. It uses the same streamable HTTP transport and the same Bearer key pattern as Claude Code, which is verified end to end, but ClipSpeedAI has not walked every tool through OpenClaw specifically. th a header. The unverified surface is OpenClaw's config loading and header handling, which is why proving the server with curl first is worth the sixty seconds.

What is the cheapest way to test the connection without spending anything?

The curl handshake in the first section. Protocol methods — initialize, tools/list, notifications and ping — are not metered against your key, so a bare tools/list POST costs nothing and still proves the endpoint, your key and the network path. Note that list_templates, while it renders no video, is a tool call and does increment requests_today against your key's rate_limit like any other. Use curl for a free probe; use list_templates when you specifically need to prove OpenClaw can invoke a tool.

Why does my curl response look like it failed?

Because the server responds with Content-Type: text/event-stream rather than plain JSON. Under curl -i you will see a line reading event: message followed by a line beginning data: that carries the JSON-RPC payload. That framing is normal. The pass condition is finding the ten tool names inside the data: line — not the response looking like a tidy JSON object.

What does a ClipSpeedAI API key look like, and can I retrieve one later?

A key is the literal string csai_live_ followed by 48 hexadecimal characters — 24 random bytes rendered as hex. You cannot retrieve it later. ClipSpeedAI stores only the prefix for display, the first 18 characters plus an ellipsis, so the complete secret is visible exactly once at creation. If you lose it, mint a replacement and revoke the old one.

How do I revoke a key, and does revocation actually work?

Yes, it is real. Revoking sets the key's is_active flag to false and stamps revoked_at, and the key stops working immediately with no grace period. You can do it from Account → API & Integrations, which maps to DELETE /auth/api-keys/:id. Rotate in this order: mint the new key, update what OpenClaw reads, restart OpenClaw, confirm the tools still enumerate, then revoke the old one.

How do I tell whether a rate limit is what is failing?

Every tools/call counts against a per-key daily budget. Listing your keys returns rate_limit alongside requests_today, total_requests and last_request_at, so comparing those two numbers answers the question directly. Polling loops are the usual cause — an agent checking several projects every thirty seconds spends a surprising amount of budget on empty responses. Lengthen the interval rather than minting more keys.

Why does check_clips come back empty immediately after I submit?

Because submit_to_clipspeed is asynchronous by design. It hands back a projectId straight away while transcription, scoring, reframing and caption burn-in run server-side. An empty result shortly after submitting means the work is not finished, not that it failed. Poll again. If it stays empty far longer than a comparable job, check the source URL is reachable and not private, member-only or region-locked.

Can the agent clip a stream while it is still broadcasting?

Yes. clip_livestream opens a live session and returns a subscriptionId, and check_livestream polls it — a status of monitoring means the broadcast is still live and still being clipped, so a short clip list at that point is expected. extend_livestream lengthens an active session and stop_livestream closes it; clips already produced are kept and stay downloadable either way. Tell your agent not to extend without asking, since that is the one live action that quietly consumes more of your plan.

Do I need the clipspeed-mcp npm package?

Not for OpenClaw, assuming it can register a remote HTTP MCP server with a custom header. The package exists — v1.0.0, published 2026-07-10 — but connecting directly to https://api.clipspeed.ai/mcp is fewer moving parts and one less thing to debug when a tool call misbehaves.

What can the ClipSpeedAI server see from my machine?

Only the arguments your agent explicitly sends: video or stream URLs, a caption style id, and project or subscription identifiers. MCP tool calls carry their declared arguments and nothing more, so the server has no view of your filesystem, your repository, your other MCP servers or the rest of your conversation. Watch the return direction too — check_clips puts download URLs into your agent's context, so treat those links as semi-private.

Related reading