MCP server
A video editing MCP server
for AI agents.
An agent that can write the brief can now finish the edit. The MCP server exposes the whole workflow as tools: find the footage, compose a cut against the brief, read the plan, render the files.
Nothing is generated. Every segment is lifted from your own footage and named in a plan the agent can read before any render.
55 tools · OAuth or Bearer key · streamable HTTP
YOU The clearest answer we gave on data residency,
45 seconds, vertical. Show me the plan first.
list_source_groups → "Town hall · 12 Aug" · ready
create_cut → c7d2… · "planning"
get_cut_plan → v1 · 3 segments · 46.2 s
revise_cut_plan "Lead with the answer itself."
→ v2 · 3 segments · 44.8 s
──────── plan approved · the next call spends ────────
render_cut → 9:16 · queued
The plan arrives as a document with source timecodes. render_cut is the step that produces the file. Source minutes are counted at ingest; each rendered aspect uses export minutes.
Video becomes an action an agent can complete.
Agents already research, write and file. Video has stayed a handoff: the workflow produces a request for an editor, then stops. These tools carry the task through to the finished file.
The brief is already written
Your agent holds the context: the campaign, the audience, the argument it is making. create_cut takes that context as a prompt of up to 2,000 characters and plans an edit from the footage to match it.
The plan is machine-readable
Planning returns a document: ordered segments, each naming its source and timecodes, with an estimated duration against the target. An agent can check the result against the brief and correct it before anything renders.
Same contract as your code
Composition tools share their service contracts with the REST API. The wider catalogue also includes Explore, thumbnails and review tools using the app's product services.
55 tools cover the workflow.
Grouped the way an agent uses them, with real names and required permissions. Product actions use the same underlying services as the app and, where a REST equivalent exists, the API.
| Tool | Scope | What it does |
|---|---|---|
| Sources and transcripts | ||
list_source_groups | read | Browse the footage library, with durations and camera counts. |
get_source_group | read | Read a source group's files, metadata and readiness. |
get_transcript | read | Read diarized speech with segment or word-level timing. |
get_speakers | read | Read speaker labels, speaking time and sample quotes. |
name_speakers | write | Give diarized speakers their display names. |
mask_transcript_words | write | Mask or restore words or terms for subsequent reads and renders; existing output can become stale. |
set_content_regions | write | Override source intro, outro, sponsor and call-to-action regions used to exclude material from edits. |
redetect_content_regions | write | Re-run source content-region detection, replacing a manual override. |
| Explore ideas | ||
get_workspace | read | Read workspace capabilities and whether Explore is available. |
explore_source | write | Generate transcript-grounded editorial concepts from a source. |
get_concepts | read | Read the concepts and current Explore session. |
present_concepts | read | Present concept cards for a person to review. |
select_concept | write | Select a concept within the current Explore session. |
refine_concept | write | Refine the selected concept with editorial feedback. |
create_concept_cut | write | Save a selected concept as a cut with explicit output settings. |
| Plan cuts | ||
create_cut | write | Start planning from a brief, one to four source groups and output settings. |
get_cut_plan | read | Read the versioned segment plan; use cut status to check whether a revision has finished. |
list_cuts | read | Browse the account's cuts. |
get_cut | read | Read one cut's status and settings. |
revise_cut_plan | write | Replan with a plain-language editorial instruction. |
update_cut_plan | write | Remove, reorder, pin or unpin plan segments. |
validate_selections | read | Check proposed source selections before using them. |
| Render and review | ||
quote_render_cut | read | Check the export-minute quote before rendering. |
render_cut | write | Render a plan version in one to three aspects; exports consume export minutes. |
get_renders | read | Read a cut's render statuses, signed downloads and sidecars. |
list_renders | read | Browse rendered outputs. |
get_render | read | Read one render and its output metadata. |
present_render | read | Present a finished render for review. |
get_operation | read | Look up the outcome of an earlier call by its operation key. |
delete_render | admin | Remove a rendered output. |
| Brand, profiles and visual plans | ||
list_brand_kits | read | Browse reusable brand colours, typography and assets. |
save_brand_kit_defaults | admin | Change a brand kit's defaults for future work. |
list_render_profiles | read | Browse reusable render profiles. |
get_render_profile | read | Read a render profile and its versions. |
create_render_profile | write | Create a reusable render profile. |
save_render_profile_version | write | Append a new version of a render profile. |
archive_render_profile | admin | Archive a render profile. |
get_visual_plan | read | Read the framing plan associated with a cut. |
propose_visual_plan | write | Propose an optional visual plan for review. |
get_visual_plan_proposal | read | Read a proposed visual plan. |
preflight_visual_plan | read | Check a visual proposal before approval. |
approve_visual_plan | write | Approve a visual proposal for the cut. |
| Thumbnails | ||
get_thumbnail_contract | read | Read supported thumbnail layouts and controls. |
get_thumbnail_style | read | Read a brand kit's thumbnail defaults. |
save_thumbnail_style | admin | Change thumbnail defaults for a brand kit. |
preview_thumbnail_style | read | Preview a thumbnail style before saving it. |
create_thumbnail | write | Start a thumbnail draft for a finished render. |
get_thumbnail | read | Read a thumbnail draft and its current state. |
get_output_thumbnail | read | Read the thumbnail associated with an output. |
save_thumbnail | write | Save edits to a thumbnail draft. |
preview_thumbnail | read | Preview the draft thumbnail. |
approve_thumbnail | write | Explicitly approve a thumbnail for use. |
retry_thumbnail | write | Retry thumbnail preparation. |
export_thumbnail | read | Download an approved thumbnail export. |
inspect_thumbnail_candidate | read | Inspect a source-frame candidate for the thumbnail. |
Schemas, worked sessions and connection detail are in the MCP docs →
Plan, read, revise. Then render.
Planning is asynchronous: create_cut returns at once and the plan follows as a document the agent reads like any other structured result. Rendering is a separate, explicit call.
If the plan misses the brief, the agent has two correction paths. update_cut_plan applies structural edits synchronously at no cost: remove a segment, reorder, pin the ones that must survive. revise_cut_plan sends the whole plan back with an instruction, and a new version comes out of planning.
Every version is kept, and the loop can run as many passes as the brief needs before the render is requested. Source footage counts once per camera. AI is included; exports use export minutes. Launch plans start at £99 + VAT (£118.80 incl. 20% UK VAT) a month. See pricing →
The honesty is in the schema
render_cut · “THIS SPENDS MONEY”
That warning is in the tool description itself, in capitals, where an agent reads it before every call. Use quote_render_cut to check export minutes, then keep the render call behind your review. Other write tools can also start planning or media preparation; choose which actions your agent may run.
What you say to the agent.
Three asks these tools can carry end to end, each inside the real limits: a target between 10 and 900 seconds, up to three aspects, up to four source groups per cut.
You, to your agent
“Take Tuesday's town hall and cut the clearest answer we gave on data residency. 45 seconds, vertical, and show me the plan before anything renders.”
create_cut · target_duration_s: 45 · aspects: ["9:16"] · 1 group
You, to your agent
“Search all four customer interviews for the moments where someone describes their first week, and compose a 90-second landscape reel in their own words.”
create_cut · target_duration_s: 90 · aspects: ["16:9"] · 4 groups
You, to your agent
“Make a 30-second square teaser from the keynote. Keep the running order chronological and apply our brand kit.”
create_cut · target_duration_s: 30 · aspects: ["1:1"] · chronology: "strict" · brand_kit_id: "b1a4…"
Connect your AI app to Anjin.
Open Connect your AI in Anjin’s account menu, choose your AI app and follow its setup steps.
Approve the connection when prompted, then ask: “List my footage in Anjin.” Choose a recording and describe the edit you need. Ask to review the plan before rendering.
The setup page guides compatible clients through OAuth. If your client needs a key, choose “Use an API key instead”. The manual example below is for API-key clients.
- Endpoint
https://anjin-media-api.fly.dev/mcp- Transport
- Streamable HTTP, stateless. There is no session to establish or keep alive; every call stands on its own.
- Auth
Authorization: Bearer mk_live_…on every call for API-key clients. The same keys as REST are minted in the dashboard and shown once. Compatible connected clients can also use OAuth.- Scopes
- Checked per tool: read, write or admin. A read key can explore footage and plans; it cannot create, revise or render.
- Batching
- JSON-RPC batch arrays are rejected with a 400: send one request per call.
{
"mcpServers": {
"anjin-media": {
"type": "http",
"url": "https://anjin-media-api.fly.dev/mcp",
"headers": {
"Authorization": "Bearer mk_live_…"
}
}
}
}Manage keys through the account menu → Developers → API & MCP. Keys carry the scopes you choose. The connection guide walks through the first session.
Built for agents you have to trust.
An agent with tools is an agent with your allowance and your footage. The server is arranged so the risky step is explicit and everything before it is inspectable.
- What stops an agent overspending?
- Read the plan and request an export-minute quote before rendering. Keep auto_render off and require approval before render_cut. A write credential also permits planning and media preparation, so set the agent's approval rules for those actions too.
- What can a scoped key not do?
- Scopes are checked on every tool call. A read key explores footage and reads plans. A write key composes, revises and renders. Admin is required to delete renders, archive render profiles or change brand and thumbnail defaults. OAuth connections never receive admin scope; composition work can use read and write.
- Can the render drift from what was approved?
- render_cut accepts a plan_version, so the agent renders the exact version that was reviewed rather than whatever is latest. Every version is kept, whether the planner wrote it, a revision produced it, or update_cut_plan edited it.
- What happens when a call is malformed?
- The underlying service validates the request. A failed call returns structured problem JSON inside the tool result, including a stable code and human-readable detail, so the agent can correct its call.
Questions
- Which MCP clients can connect?
- Compatible OAuth clients and streamable-HTTP clients that can send an Authorization header can connect. The server is stateless; each call authenticates with its access token or API key.
- Do I need a separate key for MCP?
- No separate MCP key is needed: API-key clients use the same keys as REST. Start with Connect your AI in Anjin’s account menu. OAuth clients approve the connection through Anjin without pasting an API key; OAuth never grants admin scope. For API-key clients, use the key alternative or open the account menu → Developers → API & MCP. Choose explicit scopes and copy the raw key when it is shown once.
- Can the agent render without my approval?
- Only if you arrange it that way. render_cut is a separate, explicit call, and the plan is readable before it is made. Two things to know: setting auto_render on create_cut renders the first plan automatically, and a write-scoped key is allowed to call render_cut. For a human gate, keep auto_render off and have the agent hand you the plan.
- What does the agent get back after a render?
- For each aspect: the finished MP4 behind a signed URL, SRT and WebVTT captions, an EDL as JSON naming every segment's source and timecodes, and a QC report. get_renders returns them all in one call.
- Is MCP behaviour different from the REST API?
- Tools with a REST equivalent use the same service, validation and lifecycle. MCP also exposes app workflows such as Explore and presentation tools that have no REST equivalent. Clients discover typed tools and receive structured problem JSON when an action fails.
The edit is now a tool call.
55 tools · the same engine as the app and the API