AI Clipping API: Programmatic Short-Form Video

Strip the marketing off an AI clipping API and what remains is a job queue that happens to contain video. You hand it a source — an uploaded file, a link to a recorded video, or a stream that has not finished yet — and some time later you collect vertical clips that have been transcribed, segmented, scored, reframed to 9:16, captioned and encoded. The request/response shape is ordinary. The timescale is not: rendering is long-running work rather than something you can wait on inside a web handler, and that single property drives almost every decision downstream of it, from where you persist state to how you retry.

ClipSpeedAI's programmatic surface is one MCP endpoint — https://api.clipspeed.ai/mcp, spoken over streamable HTTP. GUI clients authorize with OAuth. Anything scripted (a CLI, a queue worker, a nightly job, a Python client you wrote this morning) sends an Authorization: Bearer header carrying an API key. One endpoint, ten tools, and a tool list you read at runtime rather than a document you have to trust.

This page is written for whoever is doing the integration. It starts with the identifiers you will be storing, moves through key lifecycle and the JSON-RPC exchange on the wire, then a resumable backfill in Python, then the parts of the surface that behave differently from a plain job — live sessions and publishing. It ends with the cases where a tool server is the wrong shape entirely. If the protocol itself is unfamiliar, read What Is MCP? Model Context Protocol Explained first; everything below assumes it.

Three identifiers carry the whole integration

Before any code, decide what your database is going to hold. Almost everything you build against a clipping API is bookkeeping around three strings.

The projectId is the join key for the recorded path. Clips, the suggested titles and hooks in a creator pack, and the publish call all address the same project. That single fact settles your schema: one row per submission, holding the source URL, the options you sent, and the project id, written before your process does anything else. If a worker crashes between submitting and persisting, the render still happens, you still pay for it, and you have no handle to collect it with.

The subscriptionId is the live equivalent, and the difference in vocabulary is worth taking seriously. A project is a thing that finishes on its own. A subscription is a thing you are responsible for ending. Model them as two different lifecycles rather than forcing both through one "job" abstraction, because the state machines genuinely differ and a shared abstraction will leak within a week.

Seven stages, and the two you can steer from code

Clipping is not one operation, and

1. Ingest. Resolve the link or accept the file, pull the media, normalize container, frame rate and audio.
2. Transcribe and align. Speech to text with word-level timing. Segmentation, captions and cut points all inherit whatever this stage gets wrong.
3. Segment and score. Group the transcript into candidate moments and rank them. This ranking is what surfaces later as a viral score.
4. Boundary selection. Snap each candidate's start and end to something that sounds finished rather than truncated.
5. Reframe. Carry a 16:9 source into 9:16 while keeping the speaker in frame. Multi-speaker footage forces a judgement about when to move.
6. Caption. Burn word-by-word captions from the aligned transcript in a named style.
7. Render and deliver. Encode the vertical output and expose it for retrieval alongside a title, a score and a download URL.

Of those seven, exactly two are addressable from your code. You choose the caption style by passing a template id, and you choose the privacy of an upload when you publish. Ingest, alignment, scoring, boundaries and reframing are the product's opinions, not parameters. Nothing you send will nudge a crop that chose the wrong face or a cut that lands half a word early.

That constraint is not a complaint — it is the deal this category offers, and it changes how you evaluate. There is no configuration pass that rescues bad output, so your assessment has to happen on rendered clips from your own footage, early, before you have wired anything into a pipeline. Cutting a clip mid-sentence is among the most noticeable defects in automated clipping, and it is audible in the first two seconds, which makes it a cheap thing to test. MCP for Video Editing and Clipping Workflows sets out where this kind of pipeline stops and a real timeline editor begins.

The ten tools and what each one hands back

The MCP endpoint is the documented programmatic surface, and these ten tools are what it exposes.

Read as a shape rather than a list, this is three clusters and two accessories. The recorded cluster is submit, check, pack. The live cluster is start, poll, extend, stop. Discovery sits in front of both. The accessories are the template list, which exists so you can validate a style id instead of guessing it, and the publish call, which is the only tool that writes anywhere your audience can see.

What stands out is the reach past rendering into distribution. Most pipelines in this category stop at a file and leave the upload to you. Having publishing inside the same surface is convenient and slightly dangerous for the same reason: an agent holding all ten tools can go from "find something trending" to "it is on the channel" without a human in between. There is a reason a compact surface is easier for a model to use correctly than thirty fine-grained endpoints, and it is worked through in MCP Tool Design: Writing Tools an Agent Can Actually Use.

Key lifecycle: created once, counted continuously, revoked for real

The credential is the part of this integration most likely to bite you, so it is worth knowing exactly how it behaves rather than assuming the usual.

Format. A key is the prefix csai_live_ followed by 48 hexadecimal characters — 24 random bytes, hex-encoded. That shape is easy to write a secret-scanner rule for, and worth adding to your pre-commit hooks alongside your other provider patterns.

Creation. POST /auth/api-keys mints one; in the interface that is Account → API & Integrations → Generate API Key. Only the prefix is retained for display — the first 18 characters followed by an ellipsis — so the complete key is visible once, at creation, and cannot be fetched afterwards. There is no "reveal" endpoint to fall back on. Lose it and you generate another.

Inspection. GET /auth/api-keys lists every key with id, name, key_prefix, plan, rate_limit, requests_today, total_requests, last_request_at, is_active and created_at. Two of those turn a guessing game into an observation: requests_today and total_requests mean you can see what a poll loop is actually spending without instrumenting your own client. last_request_at is how you find the key nobody has used since the intern left.

Revocation. DELETE /auth/api-keys/:id sets is_active to false and stamps revoked_at. Revocation is a real state change, not a cosmetic hide-from-the-list, which is what makes per-environment keys worth the small overhead: staging can be cut without touching production.

The operational rules follow from those four facts. Name each key after the machine or environment that holds it, because key_prefix alone will not tell you which one to kill at three in the morning. Keep the value in the environment or a secrets manager; MCP client configuration files are easy to commit by accident. Log the fact of a call, never the header. And if a key ever lands in shell history or a CI log, revoke it rather than reasoning about who might have seen it — you have both the endpoint and the counters to confirm it went quiet afterwards. MCP Authentication: OAuth and Bearer Keys walks both credential flows end to end.

On the wire: one POST, a JSON-RPC envelope, two possible encodings

Streamable HTTP sounds exotic and is not. Every call is a POST carrying a JSON-RPC 2.0 object. You need three headers: the bearer credential, a JSON content type, and an Accept that permits both JSON and server-sent events, because the server may answer in either encoding and a client that only accepts one will fail on the other.

Open with the handshake. The protocol version below is illustrative — let your client negotiate the version it supports rather than pinning a string you have not confirmed this server accepts:

curl -sS 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": "initialize", "params": { "protocolVersion": "<version your client negotiates>", "capabilities": {}, "clientInfo": { "name": "curl-demo", "version": "0.1.0" } } }'

If the response comes back with an Mcp-Session-Id header, echo it on every later request; if it does not, there is nothing to echo and you carry on without one. Treat it as conditional rather than mandatory.

Next, enumerate the tools. This is the call that replaces documentation, and the one to make before writing any other request:

curl -sS 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":2,"method":"tools/list"}' \ | jq '.result.tools[] | {name, description}'

Invocation is tools/call with a name and an arguments object shaped by that tool's inputSchema. Field names come from the schema you just fetched, not from a table on a web page — including this one. How MCP Servers Work: Architecture and Request Flow takes the same exchange apart at the protocol level if you want to see what each frame is doing.

Worked example: a resumable archive backfill in Python

The scenario that justifies writing a client rather than typing at an agent: a back catalogue of a few hundred recorded episodes that you want clipped once, cheaply, without babysitting. The requirements are boring and non-negotiable — resume after a crash, never submit the same episode twice, and never block on a render.

Start with a transport small enough to read in one sitting. It handles both response encodings and threads the session header through if the server issues one.

import os, json, time, sqlite3, requests ENDPOINT = "https://api.clipspeed.ai/mcp" class MCP: def __init__(self, key): self.s = requests.Session() self.n = 0 self.h = { "Authorization": f"Bearer {key}", "Content-Type": "application/json", "Accept": "application/json, text/event-stream", } def _parse(self, r): if "text/event-stream" in r.headers.get("Content-Type", ""): for line in r.text.splitlines(): if line.startswith("data:"): return json.loads(line[5:].strip()) raise RuntimeError("no data frame in SSE response") return r.json() def rpc(self, method, params=None): self.n += 1 body = {"jsonrpc": "2.0", "id": self.n, "method": method} if params is not None: body["params"] = params r = self.s.post(ENDPOINT, headers=self.h, json=body, timeout=60) r.raise_for_status() sid = r.headers.get("Mcp-Session-Id") if sid: self.h["Mcp-Session-Id"] = sid # only if the server issued one out = self._parse(r) if "error" in out: raise RuntimeError(out["error"]) return out.get("result", {}) def call(self, name, arguments): return self.rpc("tools/call", {"name": name, "arguments": arguments})

Before writing a single tool call, print the schemas. The argument names for submit_to_clipspeed belong to the server, and reading them takes one command:

c = MCP(os.environ["CLIPSPEED_API_KEY"])
c.rpc("initialize", { "protocolVersion": "<version your client negotiates>", "capabilities": {}, "clientInfo": {"name": "archive-backfill", "version": "0.1.0"},
}) for t in c.rpc("tools/list")["tools"]: print(t["name"], json.dumps(t.get("inputSchema", {}), indent=2)) # Validate your configured style against the server's own list rather than
# hard-coding a string that may be retired later.
print(c.call("list_templates", {}))

Now the backfill itself. The local table is the point: it is what makes the run resumable and what stops a retried request from starting a second render of the same episode.

db = sqlite3.connect("backfill.db")
db.execute( "CREATE TABLE IF NOT EXISTS jobs(" " source TEXT, style TEXT, project_id TEXT," " state TEXT, submitted_at REAL," " PRIMARY KEY (source, style))") def submit_once(source, style): row = db.execute("SELECT project_id FROM jobs WHERE source=? AND style=?", (source, style)).fetchone() if row: return row[0] # already submitted; do not pay twice res = c.call("submit_to_clipspeed", { # field names exactly as printed from submit_to_clipspeed's inputSchema }) project_id = res["projectId"] if "projectId" in res else None db.execute("INSERT INTO jobs VALUES(?,?,?,?,?)", (source, style, project_id, "submitted", time.time())) db.commit() # persist BEFORE anything else can fail return project_id def collect(project_id, ceiling_sec): # your deadline, not a promised time deadline, delay = time.time() + ceiling_sec, 10 while time.time() < deadline: status = c.call("check_clips", {"projectId": project_id}) if terminal(status): # write this against the real payload return status time.sleep(delay) delay = min(delay * 1.5, 60) # back off; the render is not going faster raise TimeoutError(project_id) # alert a human, do not loop forever

Two details do the heavy lifting. The primary key on (source, style) makes submission idempotent on your side, which matters because an HTTP retry that quietly starts a second render costs real money and produces a duplicate you then have to reconcile. And the commit happens immediately after the id comes back, before any further work — the window between "the server accepted this" and "I wrote the id down" is the only place in the whole design where a crash is unrecoverable.

Everything else in the surface follows the same call shape: one tools/call, one result object. There is no per-capability client to write, which is the practical argument for a tool server over a hand-rolled SDK. Video Clipping API for Developers covers the same territory from a plain-HTTP starting point.

Caption templates are ids, not stylesheets

list_templates returns the caption looks you can ask for, and the real ids are exactly these six: karaoke, hormozi, beasty, fire, youshaei, cinematic. You pass the one you want as captionStyle.

Notice what is not on offer: font stacks, colour values, safe-area padding, per-word timing curves. A template is a name for a finished look, not a stylesheet you can edit. For most teams that is the right trade — the styles are ones that already work on short-form feeds, and nobody has to argue about a drop shadow. For a team with a strict brand system it is a genuine constraint, and better discovered now than after a rollout.

Two habits are worth adopting. Call list_templates at startup and validate whatever your config says against the response, rather than shipping a hard-coded string that quietly stops matching. And judge a style the way an audience will: on a phone, at arm's length, with the sound off, holding the clip you actually produced rather than a vendor sample. Legibility at that size is the whole job of a burned-in caption.

discover_trending looks at a narrow, recent window

The discovery tool searches only videos published in roughly the last three weeks, and finds the fastest-growing recent one in a niche. That scope is a design decision worth reading carefully before you build around it.

It means discovery is about momentum, not archives. You cannot use it to reconstruct which videos in your niche performed best last quarter, and a crawl scheduled monthly will keep missing most of what the window contained. If discovery is part of your loop, run it on a cadence that fits inside three weeks, and store what it returns — the tool will not remember for you.

Chained with the rest of the surface it produces a tidy sequence: discover a source, submit it, collect the clips, then call creator_pack on the same projectId for per-clip titles, hooks and suggested posting times. That chain is also where the honest case for an agent lives. Submitting and collecting are mechanical. Choosing which of today's fast-movers is worth clipping at all is judgement, and judgement is the only thing worth handing to a model. AI Agent Video Automation: End-to-End Workflows follows that chain further downstream.

Live sessions behave like subscriptions, not jobs

With a recorded file the pipeline can see the entire timeline before it decides anything. With a stream there is no end yet, so every decision is made on partial information against a window that keeps moving. The tool set reflects that difference honestly: the live path is four tools where the recorded path is one submission and one retrieval.

clip_livestream opens a session and returns a subscriptionId. check_livestream polls that id, and a status of monitoring means the stream is still live and still being clipped — that is your "keep going" signal, not a completion signal. extend_livestream pushes an active session out. stop_livestream ends one, and clips already made are kept and remain downloadable, so stopping early costs you future clips rather than past ones.

Two consequences for your code. First, the existence of an extend call implies a session has a bounded life, so a long-running loop needs a policy — extend while the broadcast continues, stop when it ends — rather than an assumption that the session persists indefinitely. Second, read check_livestream's schema and its returned fields to see exactly what state it reports before you write branching logic against imagined field names. Livestream Clipping API: Clip While You Stream goes through the session lifecycle in more depth.

Publishing is the one call that reaches outside

publish_to_youtube takes a projectId, and optionally a clipId, a title and a privacyStatus. It defaults to private, and that default is doing real work: nothing in this surface puts a video in front of an audience unless a caller explicitly asked for it.

That default suggests the right place for a human gate. Uploading privately is reversible and low-stakes; flipping a video public is neither. So rather than blocking the upload, let the agent publish privately and put the review on the transition — a person watches the clip in the channel's own drafts and decides. You keep the automation and lose none of the safety.

Everything else in the ten-tool surface reads or writes inside ClipSpeedAI. This one writes to a channel your audience sees, under your name, with a title a model chose. Before you hand an unattended agent a credential capable of that, the reasoning to work through sits in MCP Security: Scopes, Keys and Safe Tool Design.

Orchestration rules for the wrapper you own

None of what follows is specific to this vendor — it applies to any long-running render sitting behind an HTTP call. Build it once, properly, in a thin wrapper you control.

• Never block a request thread on a render. Submit, persist the identifier, return. Poll from a worker that can die and be restarted.
• Persist the id before anything else. Not after logging, not after a metrics call. The gap between acceptance and persistence is the one unrecoverable window in the design.
• Back off. Ten seconds growing to a minute is fine. Polling every second wastes requests and does not make the encoder faster.
• Deduplicate before you send, not after. A unique constraint on source plus configuration in your own table is what separates a retry that costs nothing from a retry that pays for a second render and leaves you a duplicate to reconcile.
• Separate transient from terminal. A socket timeout deserves a retry. A rejected source does not, and a retry storm against a terminal error burns requests while fixing nothing.
• Give every poll loop a wall-clock ceiling and an alert when it trips. A job that never reaches a terminal state should page someone, not spin quietly.
• Watch your own usage from the key. GET /auth/api-keys reports requests_today and total_requests per key, and each key carries its own rate_limit — read yours rather than assuming a number, and check your plan's limits in-product before sizing a pipeline.

That last point is the one people skip. A poll loop is invisible in your own metrics until it is not, and the counters are already there, attached to the credential doing the spending.

Where a tool server earns its keep, and where it is just indirection

A conventional video API hands you documented routes and request bodies. You read, you write a client, you own the retry semantics. The contract is stable and entirely yours. A tool server inverts the discovery step: the client asks what exists and receives names, descriptions and JSON Schemas, and an agent picks among them at runtime. The same endpoint then serves a chat client, a coding CLI and your backfill script without three separate integrations.

The cost is a protocol handshake and a layer of indirection you would not otherwise need. If your caller is one service making one fixed call, that indirection buys you nothing. Be honest about which you are:

• A deterministic program with fixed behaviour — a nightly job clipping yesterday's episodes with the same template — gains nothing from runtime tool discovery. Write the client, spend the saved effort on reliability.
• Several clients, one integration. If the same capability has to be reachable from an editor, a chat client and a server, one MCP endpoint beats three bespoke clients.
• Frame-accurate editing, compositing, or control over individual pipeline stages is outside this category entirely, whichever protocol wraps it. Use clipping to generate candidates and take them into an editor.
• Clipping as your own product means building the pipeline, because the transcription, scoring and reframing decisions are the thing you would be differentiating on.

These are not exclusive, and the common production shape is both: a deterministic worker for the bulk path plus an agent connection for exploratory work on the same key family. The detailed version of this decision lives in MCP vs REST API: When to Use Each, and the adjacent confusion is cleared up by MCP vs Function Calling: What Actually Differs — function calling is how a model asks for a call, MCP is how a server publishes what is callable. Wrapping a clipping backend of your own instead? Then start from How to Build an MCP Server (Practical Guide).

Connecting a client: one command to copy, prose for everything else

To drive clipping from an agent rather than your own service, the CLI is the shortest route. Generate a key under Account → API & Integrations → Generate API Key, then register the endpoint:

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

That is the canonical CLI install. ClipSpeedAI MCP for Claude Code: Complete Setup Guide expands it with verification steps and the first call to run afterwards.

The split between credential types is simple: GUI clients authorize with OAuth and never handle a key; CLI and scripted clients send the bearer header. For any client other than the one above, the honest instruction is prose rather than a config snippet — register ClipSpeedAI as an HTTP MCP server pointing at https://api.clipspeed.ai/mcp, put your key in an Authorization header, and follow that client's own MCP documentation for where its configuration lives. Config formats change on the vendor's schedule, not ours, and a stale snippet copied from a third-party page costs more time than reading the source.

An npm package, clipspeed-mcp, also exists at v1.0.0, published 2026-07-10. Remote MCP vs Local MCP Servers explains why both remote and local shapes exist in this ecosystem and which one suits a given setup.

Client coverage, stated as tiers

Because MCP is a protocol, "this should work" and "we have run it end to end" are different sentences. The tiers below say which is which.

If certainty matters this quarter, build against a client in the top row. The browser-authorized path has its own walkthrough in ClipSpeedAI MCP for Claude (claude.ai): Complete Setup Guide. Running the desktop application instead? That is ClipSpeedAI MCP for Claude Desktop: Complete Setup Guide. Windsurf has a dedicated page as well.

For the compatible tier, each client has a setup page of its own — Cursor's is ClipSpeedAI MCP for Cursor: Complete Setup Guide, and equivalents exist for the Codex CLI, for OpenClaw and for the Hermes agent. ChatGPT's page tracks the connector rollout as it moves. Choosing between the two most common developer setups is its own question; Claude Code vs Cursor for MCP Workflows compares them directly.

Testing a clipper on footage you already own

Pages in this category run heavy on adjectives and light on falsifiable claims, this one included. The only assessment worth trusting uses your own video. Work through the list below with rendered output in front of you.

• Input coverage first. Direct file, platform VOD and live stream are three separate capabilities. Confirm the ones you actually have before spending time on anything else.
• Listen to the boundaries. Play the first and last two seconds of every clip with your eyes closed. Cuts that land mid-word are obvious with sound alone.
• Stress the reframe. Two people on screen, a speaker who walks, an on-screen graphic that matters. Centre-crop failures only appear on hard footage.
• Check captions against your vocabulary. Product names, jargon, accents, code words. Generic accuracy claims say nothing about your domain.
• Read the score as an ordering. Ignore the absolute value. Ask whether the ranking agrees with the clips you would have picked yourself — agreement on ordering is the only thing a score is for.
• Measure the latency shape. Ten jobs of realistic length, then look at the worst case rather than the mean. Schedulers break on tails, not averages.
• Price it against your real volume. Per minute of source, per clip and flat subscription diverge sharply once you scale.
• Ask how files leave and how long they live. A download URL is not an archive strategy.

Run the list before wiring anything into production, not after. For comparators to put through the same eight checks, the category survey in Best MCP Servers for Video and Content Workflows is where to look next.

What it costs, and how to sequence an evaluation

The commercial terms are short. Entry is a single $1 charge that opens a three-day trial; on the fourth day it becomes whichever plan you selected, unless you cancel before then. The plans are Starter at $15 a month, Pro at $29 and Ultra at $49, and paying annually halves those rates. No free plan exists, but there is a free demo — one run, and the source has to be shorter than half an hour.

That structure suggests an order of operations. Spend the free demo on a real file from your own library — not a polished sample — and judge the rendered output using the checklist above, because that single demo answers the only question that cannot be answered from documentation. If the output holds up, take the $1 trial and spend it on the integration itself: the handshake, the schemas, one submission driven from your own code, one collection. Choose a plan afterwards, sized by what your pipeline actually consumes, and check your plan's limits in-product before you commit a pipeline to them.

If the person running clips day to day is not the person writing the client, MCP for Creators: Automating Video Without Code is the version of this material written for them, and it is a better link to send than this page.

Limits and caveats

Worth knowing before you commit engineering time.

Not every client is verified. Compatible is a real tier and not a soft yes. The four clients in it speak the protocol and use the same transport and credential pattern, but verification is still in progress; ChatGPT depends on a vendor rollout nobody here controls. Build against the fully supported tier if you need certainty now.

Ten tools is the whole surface. If your workflow needs a capability outside that list, it is not present, and no configuration flag will produce it.

A viral score is a sort order. It ranks candidates. Treat it as a queue to review, not a decision to automate, at least until you have checked its ordering against your own on your own footage.

Publishing is a real side effect. It writes to a channel your audience sees. The private default helps; a human on the public transition helps more.

No open sandbox. The demo is a single run against a source under half an hour, and the $1 trial is the cheapest way past it. Sequence your evaluation around that rather than expecting unlimited free calls.

This page is not the contract. Argument names, response fields and the exact set of tools live in tools/list.

Pick your first move

Three starting points, depending on what you are actually trying to do.

1. You want clips today, from an agent. Generate a key, run the claude mcp add command above, and work through the Claude Code setup guide. Then ask for a tool list and read what comes back — that response is the rest of the documentation.
2. You are building a service. Start with the curl handshake, print every inputSchema, and write the wrapper described in the orchestration section — persistence, idempotency, backoff, deadlines — before any business logic touches it. Video Clipping API for Developers and Livestream Clipping API: Clip While You Stream are the two references to keep open.
3. You are not sure a tool server is the right shape. Read What Is MCP? Model Context Protocol Explained, then MCP vs REST API: When to Use Each, then How MCP Servers Work: Architecture and Request Flow. If the answer comes back "my caller is a fixed program", a plain HTTP client is the honest recommendation, whoever you end up buying from.

Whichever path applies, put rendered clips from your own footage in front of your eyes before anything reaches production. Automated clipping is good enough to be genuinely useful and not good enough to go unreviewed, and most of the engineering effort in a real deployment lives in that gap.

Frequently asked questions

Is the MCP endpoint the only way to call ClipSpeedAI programmatically?

The MCP endpoint at https://api.clipspeed.ai/mcp is the documented programmatic surface, and the ten tools described above are what it exposes. It speaks JSON-RPC 2.0 over streamable HTTP, so any HTTP client can drive it — the curl and Python examples here use nothing beyond a bearer header and a POST body. You do not need an MCP SDK to integrate.

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

A key is the prefix csai_live_ followed by 48 hexadecimal characters. Only the prefix is stored for display, so the complete key is shown once at creation and cannot be fetched afterwards — if you lose it, generate another. GET /auth/api-keys lists your keys with their name, prefix, plan, rate_limit and request counters, and DELETE /auth/api-keys/:id revokes one by setting is_active to false and stamping revoked_at.

How do I find the exact arguments a tool takes?

Call tools/list after the initialize handshake. It returns every tool's name, description and inputSchema, and that schema is the contract. Populate your arguments object from the live response rather than copying field names out of documentation, including this page. Where the two disagree, the schema is right.

Which caption styles can I ask for?

list_templates returns them, and the real ids are karaoke, hormozi, beasty, fire, youshaei and cinematic. Pass the one you want as captionStyle. There are no font or colour parameters underneath — a template is a named finished look rather than a stylesheet, so validate your configured id against list_templates at startup instead of hard-coding it forever.

Can I clip a stream that is still running?

Yes. clip_livestream starts a live session and returns a subscriptionId; check_livestream polls it, and a status of monitoring means the stream is still live and still being clipped; extend_livestream pushes an active session out; stop_livestream ends it, and clips already made are kept and remain downloadable. Treat it as a session you are responsible for ending, not a fire-and-forget job.

Should an agent be allowed to publish clips on its own?

publish_to_youtube defaults to private, which makes a good division of labour: let the agent submit, collect and upload privately, and keep a person on the decision to make something public. That preserves the automation while keeping a human on the only step your audience can see. The general rule for tools with outside effects is set out in MCP Security: Scopes, Keys and Safe Tool Design.

Is there a free tier for building an integration against?

No free plan exists. A free demo does: one run, with the source under half an hour, which is enough to see rendered output from a file you already own. Past that, a single $1 charge opens a three-day trial, and on day four it becomes the plan you selected unless you cancel. Starter runs $15 a month, Pro $29, Ultra $49, and annual billing halves each of those.

How far back can discover_trending look?

It searches only videos published in roughly the last three weeks, and finds the fastest-growing recent one in a niche. That makes it a momentum tool rather than an archive search, so schedule discovery on a cadence that fits inside the window and store what it returns — reconstructing older winners is not something it is built to do.

Related reading