WeaverClip MCP · Comprehensive

Agents get their own footage locker.

Connect Claude, Codex, or any MCP client to your WeaverClip account — or spin up a dedicated agent workspace with its own 10 GB / 2-hour free vault that scales through the same $15 / $29 / $119 plans humans use. Agents read transcripts, create clips, and poll renders without ever receiving raw video bytes in the chat.

Connect a client Create an agent workspace

See WeaverClip vs OpusClip →·Start free as a human →

weaverclip

stdio connected

1List recording sessions
2Read transcripts and exact timecodes
3Choose a start time and end time
4Create the clip and queue its render

New: Agent workspaces get the same Free 10 GB/2h/6 renders — isolated by API key, free to start, scales like human plans. How it works

Quick start

Connect an editing agent from the WeaverClip project.

This is only for MCP editing: OBS uploads use the downloadable Mac app. Connecting Claude, Codex, or another editing agent currently requires the WeaverClip repository and Node.js 20 or newer.

1
Install this project on the Mac
Open Terminal in your local WeaverClip project directory. Check the Node.js version, then install the project dependencies.
Copy and paste
```
node --version\nnpm ci
```
2
Confirm that WeaverClip is signed in
The MCP server reuses the helper session stored in macOS Keychain. Sign in through the Mac app, then run the diagnostic check before you connect an editing client.
Copy and paste
```
npm run helper:doctor
```
3
Add the local server to your MCP client
The example below works for clients that read a project-level .mcp.json file. Replace the placeholder with the absolute path to your local WeaverClip project. Other clients use a different settings file or screen, but the command and arguments are the same.
Copy and paste
```
{
  "mcpServers": {
    "weaverclip": {
      "command": "npx",
      "args": ["-y", "weaverclip-mcp"]
    }
  }
}
// Scoped after org creation: npx -y @weaverclip/mcp
// Legacy local: npm --prefix /absolute/path/to/weaverclip run mcp
```
4
Restart the MCP client
Restart Claude, Codex, or your other MCP client so it loads the server. Confirm that a server named weaverclipappears and provides the six tools listed below.

Run a read-only connection test

Start with a prompt that reads metadata only. This proves the connection without creating a clip or starting a render.

Copy and paste

Use the WeaverClip MCP to list my five newest recording sessions. Open the editing manifest for the newest session and summarize its duration, transcript coverage, markers, and verified source media. Do not create a clip or render yet.

Available controls

What each MCP tool does.

ToolAccessWhat it does

weaverclip_list_sessionsRead
Lists recent recording sessions and their metadata.
weaverclip_get_editing_manifestRead
Returns source metadata, transcript, markers, and temporary signed media references for one session.
weaverclip_add_markerWrite
Adds a non-destructive editorial marker at a source timecode.
weaverclip_create_editWrite
Creates a clip with exact start and end times and immediately queues its render. There is no separate approval step.
weaverclip_get_clipRead
Checks the render and review state for a clip.
weaverclip_get_clip_mediaRead
Returns a short-lived signed URL after the finished clip is verified.
weaverclip_search_transcriptRead
Search a transcript without downloading video — returns timecodes + snippets for a query. Use before bulk create.
weaverclip_bulk_create_editsWrite
Create up to 18 clip edits in one call. Use after search to turn 12 hits into 12 queued renders.
weaverclip_schedule_transcribeWrite
Request transcription for only a slice of a long recording (e.g., last 6h of 24h) — saves transcript hours.
weaverclip_get_usageRead
Returns vault used/limit, transcript hours used/included/remaining, renders and layouts — so agents pick a range that fits.
weaverclip_submit_reviewWrite
Leave a verified run report (1-5, task, model) after using a workspace — one per session, max 5/day. Free counts.
weaverclip_share_mediaWrite
Create a private gallery link for a session or clip and optionally email it — Free 3 total 30d, paid unlimited 180d.

Agent workspaces

Give your agent its own footage locker.

An API key is not a person. When an agent generates, records, or edits video autonomously, it should have its own private vault — isolated storage, its own transcript hours, its own renders — not commingled with your camera roll. Agent workspaces are free to start and scale through the same $15 / $29 / $119 plans humans use.

Free scalable trial

10 GB (~3h), 2 transcript hours, 6 renders, 2 layouts — one-time, no card, kept 30 days. An agent that renders 3 short tests a week never leaves Free.

Same $0.04/GB-month & $0.05/render overage only above the vault — but Free never bills; it simply pauses at 10 GB.

Isolated by design

Each workspace gets a scoped API key and its own R2 prefix. Signed playback URLs expire in minutes. Your human vault never sees agent footage, and vice versa.

Revoke the key in Settings → API keys. Storage stays until its 30/180-day date or you delete it.

Autonomous creation ready

Agent generates video (Remotion, FFmpeg, or any pipeline), uploads via helper or direct import, then calls MCP to transcribe, rank moments, and create captioned clips — no human in the loop.

Agent workspaceFreeCreator $15 · Pro $29Studio $119

Storage (vault)10 GB (~3h)75 GB / 150 GB1.5 TB (~535h)

Transcript hours2 total4h / 8h per month70h/month

Renders6 total100 / 300 / mo2,000/mo

Layouts2 total30 / mo60/mo

OverageNever bills — pauses at 10 GB$0.04/GB-month + $0.05/render above vaultSame

Retention30 days180 days180 days

Create an agent workspace Use your existing account as an agent

Agents use the same billing-catalog.json source of truth as humans — no separate SKU to drift. The MCP local beta currently reuses the helper's Keychain session; scoped agent keys land with the hosted API. Early agent workspaces can start on Free today.

Architecture

What travels where

Three lanes, each with a single job. Nothing crosses lanes by accident.

Lane 1 — Helper

OBS → R2

One-minute MKV segments, byte count + MD5, signed PUT, verification before local delete. Never deletes unverified.

Lane 2 — MCP

Text only

Sessions, transcripts, markers, timecodes, render status. Tool responses never contain video bytes.

Lane 3 — Render

Worker → R2

You or the agent creates a clip decision; the helper renders; the worker writes a new MP4 and verifies it. Source never overwritten.

For autonomous agents: The agent generates an MP4 (Remotion React, FFmpeg, or any pipeline) → uploads it as a new session via the helper import or direct signed URL → calls weaverclip_get_editing_manifest to read transcript/markers → calls weaverclip_create_edit with exact start/end → polls weaverclip_get_clip → fetches the signed URL. Human approval is optional; the agent can loop nightly.

Raw media stays out of MCP

The response contains metadata and temporary references. Video bytes move through scoped storage URLs, not tool payloads.

Creating a clip starts a render

The create-edit tool saves the exact time range and immediately queues the render. It does not wait for a separate approval. The source recording is not overwritten.

Access expires

Review media uses short-lived signed URLs. The helper's long-lived refresh credential remains in macOS Keychain.

Ready to test the connection?

Install the local beta, sign in the helper, and run the read-only test prompt before creating a clip.

Open WeaverClip setup