How your agent makes a take
TakeOne runs no model of its own. The agent you already use writes the shot list, records the take or asks you to, reads what was said and where the pointer clicked, writes the cuts, zooms and captions, and publishes when you let it.
Connect it once
Through MCP. TakeOne’s MCP server is at https://mcp.takeone.dev/mcp, hosted on Sokie, which rebuilds it whenever the API changes. Open mcp.takeone.dev for the steps for Claude Code, Claude Desktop, Codex, Cursor, VS Code or any other MCP client, add the server, then sign in with TakeOne when it asks and approve the scopes. Your agent only ever holds a short-lived pass, and Disconnect cuts it off.
Through the API. The REST API is at https://api.takeone.dev/v1, described by an OpenAPI contract at /v1/openapi.json. Make a token with only the scopes the job needs and send it as Authorization: Bearer; revoke it whenever you like. The MCP server has one tool per API operation, named the same.
What it reads
- The transcript (
getTranscript): what was said, with times. With none yet, the agent fetches the narration’s audio (getAssets), transcribes it with its own speech-to-text tool and writes the result back (putTranscript). - The clicks (
getEvents): where the pointer moved and clicked, recorded by the Chrome extension, the Mac app or the beacon in your own app. - The keyframes (
getKeyframes): the moments worth pointing at, the trim, each zoom and each cluster of clicks. - The picture (
getAssets): the timeline strip, the whole take in 24 frames with the time of each, so an agent that reads images sees what was on screen before it decides where to cut or zoom; and frames at the moments it picks (getFrames), up to 12 at a time and as large as 1920 px. - The edit and the notes (
getEdit,getRecording): what the take looks like now, its title, description and private script. - How it is doing (
listRecordings,getRecording): how many times the share link was played, the number your share settings show. A count only: TakeOne never records who watched.
Every time is milliseconds from the start of the recording, before any trim or speed-up, so a cut lands on the right second.
What it writes
- Cuts, zooms, speed-ups, the frame and the poster's frame into the working edit (
putEdit). - The title, the public description and the private script (
patchNotes), and a folder for the take (moveRecording). - A transcript, which gives the share page captions and chapters.
A write that breaks a rule is refused with the rule’s name, such as OVERLAPPING_SPEEDUPS, so the agent can fix the edit and try again. Edits land as unpublished changes: you can check them in the editor before anyone sees them.
Asking you for a take
Some footage only you can make: your screen, your voice. createRecordingRequest takes a title, and optionally a script and a folder, and returns one link to the recorder. Open it signed in and the recorder shows the title and the script to read from; when you stop, the take carries both, lands in the folder, and take.ready names the request, so the agent carries on without asking again. The link fills in a take only for the account that made it, and lapses after a week unless the agent asks for longer (listRecordingRequests shows which are still open). The iPhone app opens the same link and names the take with its title.
A request can carry a shot list: each shot’s lines, notes and a time budget, written by the agent or mapped from an Antescript page. You record shot by shot, retaking as often as you like, and every attempt is kept. The agent then compares each attempt with the script, from the transcript or a contact sheet of the shot (getContactSheet), keeps the best one with chooseAttempts and trims the loose ends.
Recording a take itself
An agent that drives a Chrome, through Playwright for example, can record the take on its own. It opens the recorder from a request’s link, shares the page under test and works through the shots with window.takeone.recorder, the same handlers the buttons call. After each move and click it sends its pointer with pointer(), so the take shows a drawn arrow and click ripples where a real cursor would be. The developer guide has the names and the steps; the record-a-take skill packages them.
Publishing
With the publish scope, publishRecording renders the working edit and puts it on the share page, the way Publish in the editor does. An open TakeOne tab of yours renders it; on Starter and Pro, when no tab is open, the render runs on our side, so an agent can publish on its own. While it renders, getRecording says how far it got, and if it fails, why. Webhooks tell an agent or your own service when a take is ready, is published, or fails to save or render (take.ready, take.published, take.failed), so the work can start the moment you stop recording.
Scopes
Give each agent only what its job needs: an agent that adds chapters never needs to publish.
read- Read recordings, notes, transcripts and the files behind them.
write:notes- Write the title, description and script, sort recordings into folders, and ask you to record.
write:edit- Write the edit: cuts, zooms, speed-ups and the frame. Never publishes.
write:transcript- Upload a transcript for a recording.
write:webhooks- Register and remove webhooks.
publish- Render the working edit and put it on the share page.
Skills
The common jobs come packaged as skills with their guardrails: each works on one take, shows the plan before writing and never publishes unless that is the job. They come with the MCP server, so a connected agent can read any of them without installing anything.
- Assemble the shots: Assemble the shots in my latest take.
- Describe a take: Describe my latest take.
- Draft the script: Draft a script for my onboarding take.
- Publish a take: Publish the take called Onboarding demo
- Record a take: Record the “Invite a teammate” request yourself in Chrome.
- Record from a script: Make a take from my “Launch demo script” page in Antescript.
- Tighten the take: Tighten my latest take.
- Transcribe the narration: Transcribe my latest take with whisper.
- Zoom to the clicks: Zoom to the clicks on my latest take.
Limits
The API and MCP allow 100 calls a day on Free, with no publishing; 1,000 on Starter; and 2,000 on Pro. Starter includes 60 minutes a month of video an agent publishes with no tab open, and Pro 300. Your agent’s own usage stays on the plan you have with its provider.