ClipSpeedAI MCP on Hermes Agent: Connect It, Then Prove It Works

Most setup guides assume the client on the other end has been tested. This one cannot. Hermes Agent sits in ClipSpeedAI's COMPATIBLE tier: it speaks the same Model Context Protocol, over the same streamable HTTP transport, with the same Authorization: Bearer credential as the clients ClipSpeedAI has driven end to end — but nobody has driven Hermes end to end. The clients that carry the verified label today are Claude (claude.ai), Claude Code, Claude Desktop and Windsurf. Cursor, Codex, OpenClaw and Hermes are compatible, with verification still in progress.

That gap changes what a useful page looks like. Rather than handing you a config file to paste and wishing you luck, this page is organised around evidence: the three values Hermes must send, the exact shape of the credential, a verification ladder that isolates failures one layer at a time, and a way to confirm from ClipSpeedAI's own side that your agent's request actually arrived. If you can prove each rung, the integration is real. If you cannot, you will know precisely which rung broke.

The server itself is fixed and shared: one endpoint at https://api.clipspeed.ai/mcp, ten tools, the same account behind every client you point at it. Nothing about Hermes changes the clipping engine. What varies is only how Hermes stores a URL and a header — and that, ClipSpeedAI does not control. Everything below separates the parts that are certain from the parts you have to confirm against Hermes's own documentation, and says which is which every time.

What Crosses the Wire During an MCP Handshake

Debugging an unverified client is much easier once you know what the two sides actually exchange, so start there rather than with a definition.

When Hermes registers an MCP server, the first useful thing it does is ask that server what it can do. The server replies with a list: every tool's name, a human-readable description written for the model to read, and a JSON schema describing the arguments. Hermes hands that list to the model as part of its available actions. Nothing has been invoked yet — this is a catalogue request, and it is the single most diagnostic moment in the whole integration. If the catalogue arrives, transport and authentication both worked. If it does not, nothing downstream can.

Later, when the model decides one of those tools fits what you asked for, the client sends a call: tool name plus an arguments object that must satisfy the schema. The server runs the work and returns structured output, which goes back into the conversation as context the model can reason over. That round trip is the whole protocol. Everything else — OAuth, streamable HTTP, header plumbing — exists to get those two message types safely between two processes that were written by different people.

Two properties of that design matter for ClipSpeedAI specifically. First, the descriptions are load-bearing. discover_trending is documented as searching only videos published in roughly the last three weeks; the model reads that sentence and, if it is behaving, stops asking the tool for last year's hits. A REST route carries no such note, which is a large part of why MCP vs REST API: When to Use Each exists as its own discussion. Second, the schema is authoritative and live — the server sends it at connection time, which means the parameter list in your agent's head is always fresher than any parameter list on a web page, this one included.

For the protocol from first principles rather than from the debugging end, What Is MCP? Model Context Protocol Explained is the primer, How MCP Servers Work: Architecture and Request Flow traces the full lifecycle, and MCP vs Function Calling: What Actually Differs settles the usual confusion between the model-side mechanism and the transport around it.

The Three Values Hermes Has to Send

Strip away client-specific naming and a ClipSpeedAI connection is three facts. Every working install, on every client, sends exactly these:

1. Transport: HTTP — specifically streamable HTTP. Not stdio. There is no local process to spawn, so a Hermes build that only supports stdio-launched MCP servers cannot reach this endpoint at all.
2. URL: https://api.clipspeed.ai/mcp — one endpoint, no per-account subdomain, no region variants, no trailing path.
3. Header: Authorization: Bearer <API_KEY> — the literal word Bearer, a single space, then your key.

Those three are not negotiable and not guessable. What is client-specific is where Hermes wants them written and what it calls the fields. ClipSpeedAI has no verified Hermes configuration schema, so this page will not print one. Inventing field names for a client nobody has tested would produce something that looks copy-pasteable and quietly is not, which is worse than prose.

So: open Hermes Agent's own MCP documentation, find how it registers a remote HTTP server, and supply those three values using whatever names it asks for. Some clients call the transport type, some call it transport, some infer it from the URL scheme; some accept a headers map, some want a single header string, some expose a command-line flag. Use Hermes's vocabulary. Keep the values byte-identical to the list above.

One capability is worth confirming before you spend time: can your Hermes build attach arbitrary headers to an HTTP MCP server at all? A client that accepts a URL but silently drops custom headers will connect to the endpoint and fail every request on authentication, which reads like a bad key and is not. If Hermes's docs do not clearly document a header mechanism for MCP servers, that is the question to resolve first, before you generate anything.

What You Need in Place Before Touching Hermes

Four things, and none of them is a local runtime.

A Hermes Agent install you can already inspect. Confirm the agent starts and can show you its current MCP server list — even an empty one. Adding a server to a client whose configuration you cannot read back is how people spend an hour debugging a file the agent never loaded.

Remote HTTP MCP support with custom headers, as covered above. This is the one hard client requirement.

A ClipSpeedAI account with billing active. Nothing here runs on a free tier. A single dollar opens a three-day trial; when the third day passes, the tier you selected starts billing unless you cancelled before then. Starter runs $15 a month, Pro $29, Ultra $49, and paying yearly halves the rate. Separately there is a free demo — one demo, on a video shorter than 30 minutes — which is enough to judge output quality but is not an API posture.

An API key, generated inside the app at Account → API & Integrations → Generate API Key. The next section covers what that key looks like and how it behaves, because on this integration the key is the entire security model.

Two things you explicitly do not need. You do not need Node, Python, Docker or any local runtime, because the server runs on ClipSpeedAI's infrastructure and Hermes only ever makes HTTPS requests to it. And you do not need a connected YouTube account unless you plan to call publish_to_youtube; the other nine tools are unaffected by it.

There is also an npm package called clipspeed-mcp, at version 1.0.0, for people who prefer a package-based install path on clients that expect one. Hermes talks plain HTTP to the hosted endpoint, so you can ignore it.

Reading a csai_live_ Key: Format, Storage, Revocation

ClipSpeedAI's API keys have a recognisable shape, and knowing it saves you from a category of silent mistakes.

A key is the prefix csai_live_ followed by 48 hexadecimal characters — 24 random bytes rendered as hex. That gives you a cheap eyeball test. If the string in your Hermes config is not csai_live_ plus 48 characters drawn from 0-9a-f, it is not a key: it is a truncated paste, a shell variable that never expanded, or the display prefix copied out of the key list.

That last one catches people. ClipSpeedAI stores only the key's prefix for display purposes — the first 18 characters followed by an ellipsis. The full secret is shown once, at creation, and cannot be retrieved afterwards. So the value sitting in the API & Integrations table is deliberately not usable; if you copy it into Hermes you will get a string that looks plausible, is exactly the wrong length, and fails authentication. Capture the key at creation time and put it somewhere durable.

The key list itself is genuinely useful, though, because of what it reports per key: an id, a name, the key prefix, the plan, a rate limit, requests_today, total_requests, last_request_at, whether the key is active, and when it was created. Keys carry their own rate limit and their own running counters. Those counters are the observability hook this whole page leans on later.

The lifecycle endpoints behind the UI are straightforward. POST /auth/api-keys creates a key. GET /auth/api-keys lists them with the fields above. DELETE /auth/api-keys/:id revokes one — it flips is_active to false and stamps a revoked_at timestamp. Revocation is real and immediate, which is the answer to the only question that matters after a key leaks.

Rotation, then, is a two-move operation and the order matters. Create the new key first, update every client that holds the old one, confirm each still works, and only then revoke the old key. Do it in the other order and you take down Windsurf while you were fixing Hermes, because one key authenticates every client pointed at your account. Keep an inventory of where you have installed it. The exception is a leak: if a key reaches a git commit, a screenshot, a support thread or a shared terminal, revoke immediately and repair the fallout afterwards.

The broader design question of when a service should hand out long-lived keys versus running an OAuth flow is covered 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.

Why Hermes Gets a Key and Claude.ai Gets a Browser Popup

The server accepts two credentials, and you do not choose between them — the client does.

OAuth is the path for graphical clients that implement the MCP authorisation flow. You click connect, a browser opens, you approve, and the client stores and refreshes tokens without you handling a secret. That is how Claude (claude.ai) works as a one-click custom connector, described in ClipSpeedAI MCP for Claude (claude.ai): Complete Setup Guide.

Bearer keys are the path for command-line and headless agents, which is what Hermes is. There is no browser step and no refresh cycle. You generate the credential once and send it on every request. The trade is convenience for exposure: a token that never expires on its own is a token that stays valid in whatever file you left it in, which is why the previous section spent so long on revocation.

One consequence specific to compatible-tier clients: because Bearer auth is stateless, there is no partial state to get stuck in. Either the header arrives correctly formed and every call works, or it does not and every call fails identically. You will not see a Hermes install where some tools authenticate and others do not. If you do see that, the problem is not authentication — it is the tool arguments or the account, and you should skip ahead to the bisect section.

Registering the Server When There Is No Config to Copy

Here is the sequence, written for a client whose file format this page will not pretend to know.

Step one: create the key. In ClipSpeedAI, go to Account → API & Integrations → Generate API Key. The full csai_live_ value appears once. Move it into a password manager or your secrets store before you close the dialog.

Step two: get it out of your shell history and into an environment variable, if Hermes can read one:

export CLIPSPEED_API_KEY="csai_live_..."

Be careful here, because this is where a lot of integrations quietly break. Many MCP clients treat their configuration as literal text and do not perform shell expansion. Writing Bearer $CLIPSPEED_API_KEY into such a file sends the server a header whose value is the literal string, dollar sign and all. Check whether Hermes documents an explicit substitution syntax for MCP server entries. If it does not, use the literal key and protect the file instead.

Step three: register the server using Hermes's documented mechanism for adding a remote MCP server, supplying transport HTTP, the URL https://api.clipspeed.ai/mcp, and the Authorization: Bearer <API_KEY> header. That is the whole registration. If Hermes offers both a config file and a CLI subcommand, prefer the CLI — it usually validates field names for you and fails loudly rather than writing an entry the agent silently ignores.

Step four: keep a control experiment on hand. This is the one command on this page that is canonical and verified, and it is worth running once even if you never intend to use Claude Code as your daily agent:

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

That command is a known-good configuration against a verified client. If your key works there and fails in Hermes, you have proven the credential and the server are fine and localised the fault to Hermes's configuration — a ten-second test that saves an afternoon of theorising. ClipSpeedAI MCP for Claude Code: Complete Setup Guide covers that client properly; here it is a measuring instrument.

A Four-Rung Ladder to Prove the Connection

A saved config file is not evidence. Climb these in order, because each rung fails for a different reason and testing them out of order makes the failures indistinguishable.

Rung one — the catalogue. Ask Hermes to list its available tools. You are looking for ten ClipSpeedAI entries by name: discover_trending, submit_to_clipspeed, check_clips, creator_pack, list_templates, publish_to_youtube, clip_livestream, check_livestream, stop_livestream and extend_livestream. An empty list means the server was never reached. A partial list means something is filtering or truncating on the Hermes side.

Rung two — the lightest call. Prompt: “List the ClipSpeedAI caption templates.” That routes to list_templates, which takes no arguments and starts no clipping job. A correct response names six template ids: karaoke, hormozi, beasty, fire, youshaei and cinematic. Those exact strings are the ones you later pass as captionStyle, so this rung doubles as reference material. If you get those six back, transport, authentication, invocation and response parsing all work.

Rung three — a call with arguments. Ask for something in a niche you care about via discover_trending. This proves the model can construct a valid arguments object against a live schema, which rung two does not test because rung two has no arguments. Expect recent material only — the tool searches roughly the last three weeks by design, so a request phrased as “the biggest video of the year” will come back looking wrong when it is actually correct.

Rung four — real work. Submit one video and retrieve its clips. Now you are testing the pipeline rather than the wiring, and any failure from here is about the input, the account or the source, not about Hermes.

Rungs one through three take under a minute combined. Skipping to rung four leaves you unable to say whether you have a client problem or a video problem.

Confirming From the Server Side That the Call Landed

There is one more check available, and on a compatible-tier client it is worth knowing about, because it answers a question the client cannot: did my request actually reach ClipSpeedAI?

Every API key carries its own counters — requests_today, total_requests and last_request_at — and they are returned by GET /auth/api-keys, the same data that backs the API & Integrations panel. So:

1. Look at the key's requests_today and last_request_at before you test.
2. Have Hermes call a tool.
3. Look again.

If the counters moved, the request arrived and was attributed to your key. Whatever went wrong after that is server-side or input-side. If the counters did not move, Hermes never successfully authenticated a request — the traffic either never left the client, never reached the endpoint, or was rejected before it counted. That single observation splits the entire problem space in half, and it does not depend on Hermes reporting anything honestly.

It is also the cleanest way to catch a config that silently drops headers. A client that connects to the URL but strips the Authorization header produces a symptom that looks like an invalid key from the outside; the counter on the key staying flat while you hammer the agent tells you the key was never presented at all.

The same fields make it easy to spot a key you forgot about. If last_request_at on an old key keeps advancing after you thought you had migrated everything, some client still holds it — find it before you revoke.

The Ten Tools, With Their Real Parameters

These are the names the server actually exposes. If your agent reaches for anything outside this list, it has invented a tool, and the resulting error will look like a server fault when it is a hallucination — worth recognising quickly.

Three identifiers do most of the work across the set. A projectId ties a submission to its clips and its creator pack. A clipId selects one clip out of a project. A subscriptionId identifies a live session for the duration of its life. An agent that loses track of which id belongs to which source video will produce output that is individually correct and collectively useless, which is a real failure mode on batch runs.

For the full argument list on any tool, read the schema the server sends at connection time rather than trusting a table — the schema is the contract, and it is the thing your model is actually reading. MCP Tool Design: Writing Tools an Agent Can Actually Use explains why those descriptions carry as much weight as the parameters do.

Run One: One Conference Talk, Six Clips, One Caption Style

Start with the workflow that has no irreversible step in it. A recorded talk is a good first subject: long, speech-dense, and something you own.

List the ClipSpeedAI caption templates first. Then submit
this talk with captionStyle set to cinematic:
<video url>
Poll check_clips until clips come back, then give me a table
of every clip with its title and viral score. Publish nothing.

What the agent does:

1. list_templates returns the six ids. Naming the style up front is what keeps a set visually consistent; leave it unspecified across several submissions and you can end up with different looks in what was meant to be one batch.
2. submit_to_clipspeed takes the URL and the captionStyle. Processing happens on ClipSpeedAI's machines, so your laptop is free the moment the call returns.
3. check_clips is polled with the returned projectId. This is video rendering, not a text API — an early poll returning nothing is normal progress, not a failure. Tell the agent explicitly to wait and re-check; agents are prone to declaring defeat on the first empty result.
4. The agent reads back titles, viral scores and download URLs and builds your table.

Add creator_pack against the same projectId when you want suggested titles, hooks and posting times per clip rather than just the clips themselves. It is the natural second call on any project you intend to actually post.

Two words carry weight in that prompt. “Publish nothing” is worth saying out loud on any run you are not supervising; agents resolve ambiguity generously, and while publish_to_youtube defaults to private, an unwanted upload is still manual cleanup. MCP for Creators: Automating Video Without Code is the version of this workflow written for people who would rather never see a JSON schema.

Run Two: Holding a Live Session You Are Not Watching

This is the run that is genuinely hard to do by hand, because the constraint is not skill — it is being awake at the right time.

Start clipping this live stream: <stream url>
Give me the subscriptionId. Check on it in twenty minutes and
tell me what it has caught so far.

The session lifecycle:

1. clip_livestream opens the session and returns a subscriptionId. Clipping starts against the live feed. Hold onto that id — every subsequent live call needs it.
2. check_livestream polls by that id. A status of monitoring means the stream is still live and still being clipped, which is the state you want to see and is easy to misread as “stuck”.
3. extend_livestream handles the good problem: the stream is better than you expected and you want more of it.
4. stop_livestream ends the session when the stream dies or turns dull. Clips already made are kept and remain downloadable, so stopping early costs you nothing you already captured.
5. check_clips retrieves finished output, exactly as on the recorded path.

The property that makes this work is that the session belongs to the server, not to your terminal. Quit Hermes, shut the laptop, lose your connection — the session is unaffected, and check_livestream will tell you where it got to when you come back. That decoupling is the practical argument for a remote MCP server over a locally launched one, and Remote MCP vs Local MCP Servers works through the general tradeoff. Livestream Clipping API: Clip While You Stream goes deeper on session mechanics than a client page usefully can.

Housekeeping worth doing anyway: close sessions you are finished with. stop_livestream is one call, it is immediate, and it leaves your captured clips intact. Leaving sessions open because stopping felt risky is a habit built on a misunderstanding.

Run Three: Letting the Agent Find the Subject

The third pattern hands the search step over too, and it comes with one constraint you should design around rather than fight.

Find the fastest-growing recent video about home espresso.
Tell me which one you picked and why before you submit it.
Then clip it and show me the clips with their viral scores.

discover_trending searches only videos published in roughly the last three weeks. That is a deliberate scope: the tool exists to find something with momentum right now, not to rank an archive. Prompts that ask for the best video of the year, or the classic explainer everyone links to, will either come back empty or come back with something recent that does not match your mental image — and the agent, reading the tool's own description, is behaving correctly when it does that. If you want an older video clipped, skip discovery and hand submit_to_clipspeed the URL yourself.

The instruction to state its pick before submitting is the useful habit here. Discovery is the one step where the agent makes an editorial choice on your behalf, and a veto is cheap before a render and annoying afterwards. Once you trust its taste on your niche, drop the confirmation.

For where this pattern goes when it is chained into something larger — scheduled discovery, multi-stage review, publishing gates — AI Agent Video Automation: End-to-End Workflows and MCP for Video Editing and Clipping Workflows cover the territory beyond a single client setup.

When It Breaks: Bisect Order for a Compatible-Tier Client

On an unverified client, the valuable move is not guessing the cause — it is cutting the problem in half. Work down this list; each entry assumes the ones above it passed.

• Hermes lists no ClipSpeedAI tools. The server was never reached, so the fault is in registration. The usual causes are a transport set to stdio rather than HTTP, field names that do not match what your Hermes build expects, or a typo in the URL. Re-read Hermes's MCP documentation for its exact naming, and confirm the URL is https://api.clipspeed.ai/mcp with nothing appended.
• Tools appear but every call returns an authorisation error. Check the header value character by character: the word Bearer, one space, then the key — not Bearer: abc, not the bare key. Then check the key itself is csai_live_ plus 48 hex characters; if it is 18 characters and an ellipsis, you copied the display prefix instead of the secret.
• Everything looks right and it still fails on auth. Check the key's counters via GET /auth/api-keys. Flat counters mean the header never arrived — suspect a Hermes build that does not attach custom headers to HTTP MCP servers, or a configuration value that was never substituted.
• The literal string $CLIPSPEED_API_KEY is being sent. Your config file is not shell-expanded. Use the literal key and keep the file out of version control, or use whatever substitution syntax Hermes documents.
• The key works in Claude Code but not in Hermes. This is the compatible tier showing itself, and it is good news: the credential and the server are proven, so the variable is the Hermes-side integration. Take that result to Hermes's own documentation or support channel — it is a much stronger bug report than “it does not work”.
• check_clips comes back empty and the agent gives up. Usually not a failure at all. Rendering takes real time; the agent polled too early and interpreted an in-progress result as an error. Instruct it to wait and re-check. Investigate the submission only if it stays empty far longer than the source length would suggest.
• A submission will not start. Check account state before code. There is no free tier, so a lapsed trial stops work. Also confirm the URL you supplied is reachable by the server, not merely by your browser — the server fetches the video itself, and a session-authenticated page that renders fine for you is a different thing from a URL a backend can retrieve.
• publish_to_youtube fails while the other nine tools work. Publishing requires your YouTube account to be connected inside ClipSpeedAI; confirm that in the app if the tool errors. Nothing in the Hermes configuration affects it either way.

The general bisect, if you remember nothing else: call list_templates. It takes no arguments and starts no clipping job, so it isolates the connection from everything else. Six template ids back means your transport and credential are fine and the problem lives in the specific tool, its arguments, or your account.

What Someone Holding Your Key Could Do

A Bearer token is a bearer instrument. Whoever has the string can act as your ClipSpeedAI account until the key is revoked, and there is no second factor in front of it.

Concretely, the blast radius is: the ability to submit videos and open live sessions against your account, the ability to read back everything those produced, and — if you have connected YouTube — the ability to publish clips to that channel. publish_to_youtube defaults to private, which softens the worst case considerably, but a private upload is still an upload on your channel.

Practical handling:

• Add the config file to .gitignore before you write the key into it, not after. History is the leak, not the working tree.
• Prefer an environment variable where Hermes supports real substitution, and the literal key in a protected file where it does not. Half-substituted configs are worse than either.
• Treat screenshots, screen shares and support tickets as publication. If a key appears in one, revoke it — DELETE /auth/api-keys/:id flips it inactive and stamps the revocation. That is fast; hoping is not.
• Prefer one key per person over one key per team. Shared keys make rotation a scheduling negotiation and make the per-key request counters meaningless as an audit trail.

On what the server can see: it is a remote HTTPS service, so it has no view of your filesystem, your shell, your environment or your repositories. A locally launched stdio MCP server runs as a process with your permissions and can read what you can read; this one cannot, because it is not on your machine. What it receives is exactly what your agent chooses to send — tool arguments, principally URLs and publishing metadata.

That last clause is the part worth sitting with. The boundary is your agent's judgement about what belongs in a tool argument, not the transport. If Hermes has sensitive material in context and constructs an argument containing it, that argument is transmitted like any other. This is a property of agent design rather than of this integration, and MCP Security: Scopes, Keys and Safe Tool Design treats it properly.

Habits Worth Keeping on an Unverified Client

• Re-run the ladder after any Hermes upgrade. Compatible-tier means the client can change behaviour underneath you without anyone testing it against this server. Rungs one and two take thirty seconds.
• Keep Claude Code installed as an oracle, even if you never use it for work. One known-good client turns “is it broken?” into a measurement.
• Name the captionStyle whenever output ships as a set. Pick from karaoke, hormozi, beasty, fire, youshaei, cinematic and say it in the prompt.
• Make the agent echo ids back. Ask it to state the projectId or subscriptionId it received. On a multi-video run, an agent that has lost the id-to-source mapping produces a summary table you cannot act on.
• Give explicit polling instructions. “Wait and check again” is a better default than letting the agent decide when to call a render failed.
• Confirm before publishing until you trust the scores on your own content. The private default is a safety net, not a policy.
• Say “publish nothing” on batch prompts. Five videos and an eager agent is five things to undo.
• Close live sessions when you are done with them. One call, immediate, and captured clips survive.

If you also run an editor-based agent, Claude Code vs Cursor for MCP Workflows compares how the same server feels across client types, while ClipSpeedAI MCP for Windsurf: Complete Setup Guide and ClipSpeedAI MCP for Cursor: Complete Setup Guide cover those two directly. Best MCP Servers for Video and Content Workflows places ClipSpeedAI against the alternatives.

What This Page Deliberately Does Not Claim

An honest limits section on a compatible-tier client should include the limits of the documentation itself.

• Hermes Agent has not been verified end to end. Same protocol, same transport, same credential as clients that have — but nobody has driven the full path on Hermes and confirmed it. Reproduce anything strange on a verified client before concluding the server is at fault. Codex and OpenClaw sit in the same tier, and ClipSpeedAI MCP for Codex CLI: Complete Setup Guide and ClipSpeedAI MCP for OpenClaw: Complete Setup Guide describe the same pattern. ChatGPT is a separate case, gated by its vendor's own rollout, which ClipSpeedAI MCP for ChatGPT: Complete Setup Guide addresses.
• No Hermes configuration schema appears on this page. That is deliberate. ClipSpeedAI does not define Hermes's field names, and a fabricated snippet would be indistinguishable from a real one until it failed. The three values are certain; their spelling is Hermes's to document.
• Plan behaviour beyond price is not documented here. Pricing is known: a dollar for three days, then Starter $15, Pro $29 or Ultra $49 monthly, halved annually, with one free demo on a video under 30 minutes. What each tier permits in practice is a question for your account settings, not for a guide.
• Ten tools is the entire surface. If a capability is not in the table above, this server does not expose it. Publishing goes to YouTube; there is no tool for other destinations, and none for arbitrary timeline editing.
• Rendering is not instantaneous. This is video encoding. Design prompts and any automation on top of them around waiting rather than immediate returns.
• Viral scores rank; they do not predict. The score is a sorting signal over your own output. Treating it as a forecast is reading more into it than it offers.
• Sources must be reachable by the server. ClipSpeedAI fetches the video from the URL you hand it, which is not the same test as the URL working in your logged-in browser.

If you are weighing an MCP integration against calling the platform directly, AI Clipping API: Programmatic Short-Form Video and Video Clipping API for Developers cover the non-agent route, and How to Build an MCP Server (Practical Guide) is the read if you are the one writing the server on the other side of a connection like this.

Frequently asked questions

Is Hermes Agent verified by ClipSpeedAI?

No. Hermes sits in the COMPATIBLE tier: it uses the same MCP protocol, the same streamable HTTP transport and the same Bearer credential as the verified clients, but ClipSpeedAI has not driven it end to end. Verified today: Claude (claude.ai), Claude Code, Claude Desktop and Windsurf. Cursor, Codex and OpenClaw share the compatible tier with Hermes.

Why does this page not include a Hermes config file example?

Because ClipSpeedAI does not define Hermes's configuration schema and has not verified it. A plausible-looking snippet with invented field names is worse than prose, since people copy blocks and skip the caveat under them. Take the three certain values to Hermes's own MCP documentation: transport HTTP, the URL https://api.clipspeed.ai/mcp, and an Authorization: Bearer header.

What should a ClipSpeedAI API key look like?

The prefix csai_live_ followed by 48 hexadecimal characters, generated from 24 random bytes. If your string is shorter, ends in an ellipsis, or contains characters outside 0-9a-f after the prefix, it is not the secret. The API & Integrations list shows only the first 18 characters as a display prefix; the full key is shown once at creation and cannot be retrieved later.

Can I revoke a key, and what does revocation do?

Yes. DELETE /auth/api-keys/:id revokes a key, setting is_active to false and stamping revoked_at. Revoke immediately if a key reaches git, a screenshot, a ticket or a shared session. For planned rotation, create the new key first, update every client holding the old one, then revoke — one key authenticates all your clients, so revoking first breaks them all at once.

How do I tell whether Hermes's requests are reaching the server?

GET /auth/api-keys returns per-key counters — requests_today, total_requests and last_request_at. Read them, have Hermes call a tool, read them again. Counters that moved prove the request arrived and was attributed to your key. Counters that stayed flat mean the key was never successfully presented, which usually points to a client that is dropping the Authorization header.

Which caption templates exist, and how do I pick one?

Six: karaoke, hormozi, beasty, fire, youshaei and cinematic. Call list_templates to see them from the agent, then pass the id you want as captionStyle on submission. Naming it explicitly is what keeps a multi-video batch looking like one set.

What happens to a live session if I close my laptop?

Nothing — the session runs on ClipSpeedAI's servers, keyed by the subscriptionId that clip_livestream returned. Reconnect and call check_livestream to see where it got to; a status of monitoring means the stream is still live and still being clipped. extend_livestream runs it longer, and stop_livestream ends it while keeping the clips already made downloadable.

Will publish_to_youtube post something publicly by accident?

It defaults to private. The tool takes a projectId plus optional clipId, title and privacyStatus, and unless privacyStatus says otherwise the upload lands privately on your connected channel. Still keep it behind a confirmation while you are learning the scores, and say 'publish nothing' on unsupervised batch prompts.

Does discover_trending search the whole of YouTube history?

No. It looks for the fastest-growing recent video in a niche and searches only videos published in roughly the last three weeks. Asking it for the best video of the year is asking for something outside its window. To clip something older, skip discovery and pass the URL straight to submit_to_clipspeed.

Do I need to install anything on my machine?

No local runtime is required — no Node, no Python, no Docker. The server is remote at https://api.clipspeed.ai/mcp and Hermes only makes HTTPS requests to it. An npm package named clipspeed-mcp at version 1.0.0 also exists for clients that prefer a package-based install, but a plain HTTP connection does not need it.

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

There is no free plan. One dollar opens a three-day trial, after which the tier you picked begins billing unless you cancelled. Starter runs $15 a month, Pro $29 and Ultra $49, with annual billing at half the rate. A free demo exists — one demo, on a video shorter than 30 minutes — which is enough to judge output quality but not a substitute for an account.

Related reading