auto stud
MCP server live

Built for AI agents

Autostud turns text, links and media into finished, rendered short-form videos: quizzes, rankings, karaoke, subtitled clips, faceless narration and AI music. Every part of it is callable -- there is no step that requires a human to click something in a dashboard.

Model Context Protocol endpoint
https://autostud.ai/api/mcp

OAuth 2.1 with dynamic client registration -- paste the URL and nothing else. A Bearer API key (or `?key=<api key>` on the URL) still works for clients that cannot open a browser.

Get a connection URL/llms.txtAPI reference
151
callable actions
24
resources
67
spend credits
10
MCP tools

Connect your client

No SDK, no code generation. One URL and a key.

Claude Code
claude mcp add --transport http autostud https://autostud.ai/api/mcp
Claude Desktop / claude.ai
Settings > Connectors > Add custom connector > https://autostud.ai/api/mcp
Cursor
{"mcpServers":{"autostud":{"url":"https://autostud.ai/api/mcp"}}}
VS Code
{"servers":{"autostud":{"type":"http","url":"https://autostud.ai/api/mcp"}}}
OpenAI Responses API
{"type":"mcp","server_label":"autostud","server_url":"https://autostud.ai/api/mcp","authorization":"<oauth access token>"}

Prefer plain HTTP? The same key works on https://autostud.ai/api/v1. The contract is published as OpenAPI.

Evaluating it with human eyes? The API guides walk through every capability end to end, in fourteen languages.

The first five calls

From an empty workspace to a finished mp4.

  1. 1

    Check the workspace and its credit balance.

    MCP whoami

    REST GET /api/v1/me

  2. 2

    Find out what this key may touch. Never guess a field name -- ask.

    MCP catalog, then describe { resource: "videos" }

    REST GET /api/v1 (resources + actions the key is scoped for)

  3. 3

    Create the video. One action builds a full timeline composition.

    MCP run_action { action: "videos.create", input: { ... } }

    REST POST /api/v1/actions/videos.create

  4. 4

    Render it. Runs on a worker VM and spends credits.

    MCP run_action { action: "renders.create", input: { video_id } }

    REST POST /api/v1/actions/renders.create

  5. 5

    Wait for the mp4 -- poll, or let a signed webhook tell you.

    MCP list_records { resource: "renders" } until status is done

    REST GET /api/v1/renders?video_id=... or subscribe to render.completed

What you should know first

The things that make an integration behave well instead of merely work.

  • Renders are asynchronous and cost credits. A render takes minutes, not seconds -- poll, or use a webhook, never block.
  • Actions flagged `spends_credits` debit the workspace. `GET /api/v1/me` returns the balance; a 402 `insufficient_credits` carries the shortfall.
  • Every write accepts an `Idempotency-Key` header, kept 24h. Retry with the same key instead of creating a second video.
  • Errors are stable machine codes with a `hint` field naming the call that fixes them. Branch on `error.code`, never on the message.
  • Rate limits and monthly quotas are per key and reported on every response via `X-RateLimit-*`; a 429 carries `Retry-After`.
  • Test the whole path for free with an `sk_test_` key: real auth, real validation, no writes, no credits, no webhooks.
  • Any page on this site can be fetched as Markdown -- send `Accept: text/markdown`, or append `.md` to the URL.

Every failure carries a machine code, a hint naming the call that fixes it, and whether retrying can help. Full error reference.

151 actions

Everything the platform does, callable in one request each.

renders3
  • renders.createcreditsQueues a render for a video and returns the render job.
  • renders.listRender jobs with their status and output URLs.
  • renders.deleteDeletes a render job and its output reference.
videos4
  • videos.createCreates a video through the dashboard controller: applies the template, defaults and workspace stamping.
  • videos.updateValidated update of a video document (same Joi schema as the editor).
  • videos.generate_layer_audiocreditsGenerates the audio of one timeline layer and syncs its timing.
  • videos.launch_flowcreditsRuns the end-to-end video flow (generation pipeline) for a video.
timeline7
  • timeline.generate_audiocreditsGenerates the voice-over of a block/group and runs Whisper alignment.
  • timeline.generate_questionscreditsWrites quiz questions for a video from a topic or keyword.
  • timeline.sync_voiceRecomputes block durations from the audio sequence.
  • timeline.whisper_analyzecreditsWord-level transcription and timing for an audio file.
  • timeline.analyze_subtitlescreditsBuilds subtitle groups from a transcription.
  • timeline.translate_subtitlescreditsTranslates a subtitle track into a target language.
  • timeline.hydrate_tu_preferescreditsFills a would-you-rather timeline with generated questions and media.
subtitles1
  • subtitles.generatecreditsTranscribes a media URL with Whisper, marks the words to emphasise and writes the subtitle track + layer onto the video. One call between `videos.create` and `renders.create`.
images1
  • images.generatecreditsRuns an image agent and bills the workspace.
videos_ai2
  • videos_ai.generatecreditsRuns a video agent (Veo, Kling, Sora, Seedance...) and bills the workspace.
  • videos_ai.extendcreditsExtends a generated video by another segment.
agents2
  • agents.executecreditsRuns any configured agent with its prompt template and variables.
  • agents.executionsHistory of agent runs with their outputs.
generations1
  • generations.launchcreditsThe playground pipeline: prompt in, image or video out, billed and stored.
music2
  • music.generatecreditsCreates a Suno song from a prompt, lyrics or a style brief.
  • music.get_taskStatus and tracks of a music generation.
characters2
  • characters.generate_imagecreditsGenerates a consistent image of a character.
  • characters.smart_variantscreditsGenerates a batch of consistent variants for a character.
faceless8
  • faceless.generate_storycreditsWrites the script of a faceless video from a prompt.
  • faceless.generate_outlinecreditsProduces the act/scene outline before the full script.
  • faceless.parse_scriptcreditsSplits a script into scenes ready for the faceless engine.
  • faceless.generate_audiocreditsGenerates the voice-over of one or more scenes.
  • faceless.generate_videocreditsGenerates the visual of a faceless scene (image or video model).
  • faceless.check_statusStatus of a running faceless scene generation.
  • faceless.analyze_urlcreditsExtracts a usable brief from an article or video URL.
  • faceless.detect_characterscreditsFinds recurring characters and proposes consistent prompts.
smart_groups3
  • smart_groups.generatecreditsBuilds a smart group (quiz, ranking, dialogue...) inside a video.
  • smart_groups.actioncreditsExecutes one of a smart group's declared actions.
  • smart_groups.create_qcmCreates a multiple-choice question group from a question set.
tools10
  • tools.generate_from_promptcreditsDraws a single image from a text prompt and stores it on the CDN. This is an image tool, not a video one. `videos.create` and the `*_to_video` actions build videos.
  • tools.image_to_promptcreditsTurns an image into a reusable generation prompt.
  • tools.remove_backgroundcreditsReturns a cut-out version of the image.
  • tools.image_modificationcreditsApplies an instruction-based edit to an image.
  • tools.image_cropCrops or reframes an image supplied inline as base64. It does not fetch a URL, upload the bytes or crop from an asset you already hold.
  • tools.reddit_post_to_videocreditsFetches a Reddit post and turns it into a video project.
  • tools.youtube_to_karaokecreditsBuilds a karaoke video composition from a YouTube URL.
  • tools.read_commentscreditsFetches the comments of a TikTok or Instagram post.
  • tools.write_lyricscreditsTurns comments into song lyrics, each line keeping its comment id.
  • tools.variant_analyzecreditsAnalyses a media variant and reports what it contains.
slideshows2
  • slideshows.generatecreditsGenerates the visuals of every pending slide.
  • slideshows.exportcreditsExports the finished slideshow.
flows2
  • flows.executecreditsRuns an automation flow and returns its execution.
  • flows.executionsExecution history of a flow.
publishing2
  • publishing.schedule_postcreditsQueues a video for publication on a connected account.
  • publishing.calendarScheduled posts grouped by day.
account3
  • account.creditsCurrent credit balance of the workspace.
  • account.limitsPlan limits and current consumption.
  • account.credit_historyCredit movements, newest first.
image_agents6
  • image_agents.listImage agents configured for the workspace.
  • image_agents.createCreates an image agent with its model and default parameters.
  • image_agents.updateUpdates an image agent.
  • image_agents.deleteDeletes an image agent.
  • image_agents.generatecreditsStarts an image generation job. Poll `image_agents.status` for the result.
  • image_agents.statusStatus of one or more image generation jobs.
app_screenshots5
  • app_screenshots.listApp-screenshot projects of the workspace.
  • app_screenshots.createCreates an app-screenshot project.
  • app_screenshots.updateUpdates an app-screenshot project.
  • app_screenshots.deleteDeletes an app-screenshot project.
  • app_screenshots.generatecreditsGenerates one app-store screenshot from a project.
voice_projects4
  • voice_projects.listBulk text-to-voice projects.
  • voice_projects.createCreates a bulk text-to-voice project.
  • voice_projects.updateUpdates a bulk text-to-voice project.
  • voice_projects.deleteDeletes a bulk text-to-voice project.
playground2
  • playground.random_promptcreditsGenerates an image prompt from a theme, for exploration.
  • playground.image_to_promptcreditsTurns an image into the prompt that would produce it.
instructions2
  • instructions.generatecreditsWrites the instruction set driving a generation from a brief.
  • instructions.generate_with_newscreditsSame, seeded with fresh news on the topic.
assets1
  • assets.static_libraryThe platform-provided asset library (backgrounds, overlays, sounds).
scripts76
  • scripts.listThe scripts in this workspace, newest edit first, with their id, length, runtime and how much of them has been voiced. Start here: every other script tool takes the `script_id` this returns.
  • scripts.createStart a new, empty script and return its id. Nothing is written yet: fill it with `script_draft_paragraphs` (from the subject), `script_write_from_source` (from text or a page) or `script_insert_paragraph` (by hand). A script always has one speaker, and every generated line is assigned to it, so `speaker` names the narrator.
  • scripts.duplicateCopy an existing script into a new one: words, structure, cast and the recordings, which travel because they were paid for and the words they belong to are about to be identical. The credit meter does not: a copy has cost nothing yet. Use it before a rewrite somebody may want to compare against, or to keep a short cut and a long cut of the same video.
  • scripts.deleteDelete a script and everything on it: paragraphs, restore points, review notes and the take history. Not reversible. Confirm with the person before calling it.
  • scripts.modelsThe priced model catalog, as `model_ref` values. A script names one for its whole-document passes and, separately, one for the per-paragraph edits somebody presses forty times an afternoon.
  • scripts.voicesThe voices this workspace can record with, as `voice_ref` values. Filter by language before choosing: a French script read by an English voice is a take somebody has to notice to undo, and it costs credits either way.
  • scripts.ideascreditsSubjects for a script that does not exist yet, each with the angle that makes it worth watching. The one writing pass that runs before there is a document, so it does not need a `script_id`. Spends credits.
  • scripts.openThe whole document: every paragraph with its id, role, speaker, lock, recording and words, plus the chapters, the cast, the sources, the research and where the runtime stands against the target. Call this before you change anything -- every other tool addresses paragraphs by the `paragraph_id` it returns.
  • scripts.timingThe running order with a timecode on every paragraph: where it starts, how long it runs, and whether that is measured from a real recording or estimated from the word count. Free, no model. This is how you answer "what is at 0:22" and "how much has to come out to make thirty seconds".
  • scripts.speech_checkThe mechanical read a voice tool can make and a writing tool cannot: digits, symbols, acronyms, URLs, abbreviations and sibilant runs, per paragraph, with what the voice will actually be handed. Free, no model. Run it before spending credits on takes -- "40%" reaches the provider verbatim.
  • scripts.settingsWhat the document is written and read BY: the model for whole-document passes, the cheaper model for per-paragraph edits, the default voice, and the structure it is written to. Title, subject, tone, audience, language and target runtime are `script_set_meta`.
  • scripts.write_from_sourcecreditsTurn material into a script: paste the text, or give a URL and it is fetched. REPLACES the paragraphs, so it is the way to start a document from something that already exists, not the way to add to one. `close` keeps the source order and its claims, `loose` takes the substance and rewrites it as a video. Spends credits.
  • scripts.write_from_linkcreditsRead one to four pages and write a whole script WITH A STANCE: a review, a comparison, an explainer, a hot take. Unlike `script_write_from_source` this one is fenced -- no number, price, date or version may come from anywhere but the pages, and whatever the model wanted to say and could not verify comes back in `unverified` for somebody to check. Answer the angle honestly: `experience` decides whether the script is allowed a single first-person claim. REPLACES the paragraphs. Spends credits.
  • scripts.exportThe document rendered as text, in one of: txt, markdown, srt, vtt, teleprompter, csv, shotlist, json. `srt` and `vtt` are timed from the real takes where they exist, `shotlist` carries the visual direction, `csv` is one row per paragraph. Returns the content itself, not a download link.
  • scripts.to_videocreditsCreate a video from the script: one scene per paragraph, each carrying its recording where one exists. This is the hand-over to the video side of the platform -- from there it is `videos` and `renders` like any other project. Voice the script first, or the scenes come out timed by an estimate rather than by the real audio.
  • scripts.snapshotsThe restore points on this script, newest first, with what each one was taken before. One is taken automatically before the first write of any call, so there is always something to go back to. Restore one with `script_restore_snapshot`.
  • scripts.changesThe edit log: every change to this document, newest first, with the tool that made it and the sentence that asked for it. Filter by `paragraph_id` to see the history of one line.
  • scripts.shareTurn the read-only review link on or off, decide whether reviewers may leave notes, or rotate the token so the old URL stops working. The token is minted here and can never be chosen: it is a capability.
  • scripts.notesThe notes left through the review link, resolved ones included, each pointing at the paragraph it is about. Posting a note is the reviewer door and is not reachable from here.
  • scripts.resolve_noteMark a reviewer note resolved, reopen it, or delete it. Resolve it once the change it asked for is actually in the document, never to tidy the list.
  • scripts.snippetsReusable lines this workspace keeps: sign-offs, disclaimers, calls to action. Drop one into the document with `script_insert_snippet`, save a new one with `script_save_snippet`.
  • scripts.style_guideThis workspace's own rules, in the three kinds that act in three places: `banned` and `preferred` shape the WRITING and are injected into every prompt, `spoken` acts on the VOICE only and is applied between the paragraph and the provider. Add one with `script_add_style_rule`.
  • scripts.speakersThe cast: every named speaker, the voice they are recorded in, who they are, and how many lines and words are theirs. The FIRST one is the base speaker -- every line written lands on them and they can never be removed. A speaker with no voice of their own is read in the document default, which is what makes a two-hander come back in one voice.
  • scripts.set_speaker_voiceRecord everything this person says in a voice of their own, whatever the document default is. This is what makes a dialogue sound like two people: without it every speaker is read by the same voice and the script is a monologue with names on it. Pass `voice_ref` from `script_voices`, or null to put them back on the default. Changes nothing already recorded -- re-record those with `script_voice` and `force`.
  • scripts.update_speakerChange a speaker name or their persona -- the line describing how they talk, which every later AI pass reads before writing for them. Their lines, their voice and their id are untouched, so renaming is safe.
  • scripts.remove_speakerTake somebody out of the cast. Their lines are NOT deleted: they go back to the base speaker, which is where an unassigned line belongs. The base speaker themself cannot be removed -- a script is somebody talking, so the list never reaches zero. Rename them instead.
  • scripts.voicecreditsRecord paragraphs with a real voice. SPENDS CREDITS, one synthesis per paragraph per take. With no `paragraph_ids` it does the whole script, and it is safe to run twice: a take whose words have not changed is left alone, so it fills the gaps and re-does the stale ones rather than re-buying what is there. `takes` (1 to 3) buys several readings of each paragraph and KEEPS them all -- that is how you compare two performances. The voice is the most specific one that applies: the paragraph, then its speaker, then `voice_ref` here, then the document default. A paragraph with no voice anywhere in that chain is skipped rather than read by an arbitrary one. Listen to the result with `script_listen`.
  • scripts.takesWhat has been recorded: per paragraph, every take that was kept, which one is CHOSEN, how long it runs, what voice read it, and whether the words have moved since (a stale take is one somebody has to re-buy). Free.
  • scripts.listenPlay a recording back. Returns the audio itself, not a link to it, so you can hear what was bought and say whether it is any good. Name a paragraph for its chosen take, add `take_id` for a particular one, or pass several paragraphs (up to 4) to compare readings. Free: the take already exists.
  • scripts.choose_takeMake one of a paragraph recordings THE one: the take the player, the export, the subtitle timing and the hand-over to a video all read. The others are kept beside it. Listen before you choose.
  • scripts.delete_takeDrop a recording you are not going to use. A paragraph keeps a handful of takes and the oldest falls off the end, so clearing out the readings nobody wants is what makes room to try again. If the one you delete was the CHOSEN take, the newest of the rest takes its place; delete the last one and the paragraph is unvoiced again. The credits are already spent either way -- this frees nothing but the list.
  • scripts.paceA paragraph own playback rate, 0.75 to 3, stored ON the document: it is what the page plays it at AND what the audio export writes it out at, so it survives a reload and a re-recording. `null` means FOLLOW whatever the listener or the export is set to, and 1 is NOT null: "hold this one at 1x while the rest go to 2x" is a real instruction. Speeding up never raises the pitch.
  • scripts.narrationEvery chosen take in document order, with the file it lives in, the pace it is written out at and how long the finished narration runs. What is NOT recorded is reported rather than padded with silence: an export that quietly skips half a script is an export that lies about being finished. The joining into one file happens in the browser (it is where the time-stretch runs); this is the plan and the pieces.
  • scripts.readRead the FULL text of paragraphs. The document block above only shows the first line of each one, so call this before you rewrite, quote, judge or continue anything. Give paragraph_ids, or a from/to range, or a role, or a search term. With no arguments it reads the whole script.
  • scripts.reportMeasure the script: runtime against its target and how many words that is, the shape of it by role, house-style rules it breaks, paragraphs that repeat an opening, recordings that no longer match their words. Costs nothing and runs no model. Call it before and after any length work.
  • scripts.replace_everywhereSwap one string for another across the whole document, changing nothing else. This is the ONLY correct answer to "replace X with Y", "rename X", "we say Y now". Never rewrite a paragraph to perform a swap.
  • scripts.set_paragraph_textWrite exact words into one paragraph, keeping its role, its visual, its recording and its history. Use this when YOU wrote the sentence (a hook you drafted in the chat, a typo you fixed). Use rewrite_paragraphs instead when the writing model should do the work.
  • scripts.rewrite_paragraphscreditsRun the script own writing model over paragraphs with an instruction. This is the same writer the editor buttons use, with this script chosen model and the workspace house style, so the result sounds like the rest of the tool. One model call per paragraph, so keep the list to what the user actually asked for.
  • scripts.insert_paragraphAdd a new paragraph, with your own words, at a chosen place in the document.
  • scripts.delete_paragraphsRemove paragraphs from the script. The restore point taken at the start of this turn is the way back, so say what you deleted clearly enough for the user to ask for it back.
  • scripts.move_paragraphMove one paragraph to another position. `to_index` counts the document AFTER the paragraph is lifted out, so moving index 0 to index 3 puts it fourth. Move one at a time and re-read the map between moves.
  • scripts.set_paragraph_roleLabel what a paragraph IS: hook, intro, body, transition, example, punchline, cta, outro. The role drives the colour in the outline and the way later AI passes treat it.
  • scripts.lock_paragraphsLock or unlock paragraphs. A locked paragraph is never touched by any document-wide pass, yours included. Lock freely when the user says a line is final. NEVER unlock without being asked in so many words.
  • scripts.annotate_paragraphLeave a note in the margin of a paragraph. The editor shows it, and every later AI pass on that paragraph is given it as an instruction. Use it to park an idea the user has not asked you to act on yet. Pass an empty string to clear one.
  • scripts.set_paragraph_visualSay what is on screen while a paragraph is spoken: one line of direction, what KIND of shot it is, and the keywords somebody would type into a stock library.
  • scripts.set_metaChange what the document IS rather than what it says: its title, subject, tone, audience, language code, short or long form, and the runtime it is written to. Send only the fields you are changing.
  • scripts.translatecreditsTranslate the WHOLE document in one call: every unlocked paragraph, the title with it, and the document language field. Use this rather than looping rewrite_paragraphs over forty paragraphs.
  • scripts.snapshotTake a named restore point before something large. One is taken automatically before your first edit of a turn, so only call this when the user asks for a marker, or before a pass you expect them to regret.
  • scripts.restore_snapshotPut the words back to a restore point. Takes its own safety point first, so restoring is itself undoable. The restore points are listed in the document block, newest first.
  • scripts.historyRead what has been done to this script: who changed what, when, and what they were asked for. Newest first. Pass a paragraph_id to see only one paragraph's history. Each entry has an edit_id, which `revert_change` takes. Free, no model.
  • scripts.undo_changeUndo ONE entry from the change log, by edit_id: the paragraphs it rewrote go back to the words they had. Everything done since is left alone (use `restore_snapshot` to go back to a whole earlier state). Locked paragraphs are skipped. Read `read_change_log` first to get the edit_id.
  • scripts.check_flowcreditsRead the SEAMS between paragraphs: abrupt cuts, things said twice, contradictions, pacing, paragraphs that wandered off topic. Returns a score and a list of issues, each with a ready replacement where there is one. Changes nothing. The right first move for "does this flow?", "it feels off", "it repeats itself".
  • scripts.research_allcreditsFact-check the WHOLE script. It works out which separate subjects the script stands on, searches each one on its own, and files every source on the document along with what could NOT be confirmed. This is the tool for "research this script", "check my facts", "is any of this out of date" and for a script the user has just pasted in. It searches at most 4 subjects and costs one web search per subject. For ONE specific question, use research_topic instead: it is a fraction of the price.
  • scripts.analyzecreditsNumbers about the script as an object: how dense it is, how strong the opening is, where a listener is most likely to leave, reading level, pace, and the single highest-leverage change. Changes nothing. Use it when asked whether the script is any good, before offering an opinion of your own.
  • scripts.suggest_hookscreditsWrite several openers for this script, each pulling a different lever, with the angle named. Writes NOTHING: read them out and let the user choose, then apply the chosen one with set_paragraph_text.
  • scripts.suggest_titlescreditsWrite several titles for this script. Writes NOTHING: offer them, then set the chosen one with set_script_meta.
  • scripts.write_variantscreditsWrite several alternative versions of ONE paragraph, so the user can compare them side by side. Writes NOTHING. This is the right answer to "give me options", "a few versions", "another way of saying it" -- better than rewriting once and hoping.
  • scripts.outlinecreditsPlan the script before any of it is written: chapters, and the beats each one needs. Writes the CHAPTERS and returns the beats for you to read out. It does not write a single paragraph -- call draft_paragraphs for that, once the user has agreed to the plan.
  • scripts.draft_paragraphscreditsWrite the actual script, from its topic, its structure and whatever chapters exist. EXPENSIVE: this is one large model call and it appends a whole draft. Say what you are about to do first. On a document that already has paragraphs it ADDS to them, so outline first, or the user ends up with two scripts in one.
  • scripts.group_into_chapterscreditsRead the script as it stands and group it into chapters, assigning every paragraph to one. Use it on a document that was written straight through and has grown a shape nobody named.
  • scripts.split_paragraphcreditsBreak one paragraph that is doing too much into two or three that each do one thing. The first part KEEPS the original id, its history and its recording; the rest are new. Better than deleting and re-adding.
  • scripts.direct_visualscreditsWrite a shot direction for EVERY paragraph in one pass: the kind of shot, the direction, the stock keywords. Use set_paragraph_visual instead when it is one or two paragraphs.
  • scripts.polishcreditsOne editing pass over the WHOLE document at once: tightening, the same word used twice in a row, sentences that do not say themselves out loud. EXPENSIVE, and it touches many paragraphs, so say what it will do first. Locked paragraphs are skipped and counted.
  • scripts.research_topiccreditsLook up facts for this script and store them as SOURCES on the document, so every later pass can cite them instead of guessing. Use it when the user asks whether something is true, asks for numbers, or asks you to back a claim up. It adds sources, it does not edit a paragraph.
  • scripts.retentionWhere a viewer is most likely to stop watching, paragraph by paragraph, with a timecode and the reason. Also finds phrases the script repeats to itself. Costs NOTHING and runs no model, so call it freely: before any length work, and any time the user asks why a video is not being watched to the end.
  • scripts.add_style_ruleWrite a rule into the WORKSPACE house style guide. It applies to every script anybody writes here, from now on, and it is attached to every AI pass automatically. Use it when the user states a standing preference ("we never say X", "always write it Y"), never for a one-off edit. Ask before adding one they only implied.
  • scripts.save_snippetPut a paragraph in the workspace snippet library, so it can be dropped into any future script unchanged. The right answer to "keep this one", "save that line", "I always open like this".
  • scripts.insert_snippetDrop a saved snippet into this script, word for word. Call it with no `snippet_id` to LIST what is on the shelf first, then again with the one the user picked. The whole value of a snippet is that nothing rewrites it, so never paraphrase one.
  • scripts.add_sourceRead a URL and attach it to the script as a source, with whatever the page declares about itself. Every later AI pass gets those facts, so a rewrite six paragraphs later still knows the number. Use it whenever the user pastes a link or asks where a claim comes from.
  • scripts.add_speakerAdd a named speaker to the script, so a paragraph can say who is talking and get its own voice. Use it for a dialogue, an interview, a two-hander. Adding one changes nothing on its own: assign paragraphs to it with assign_speaker.
  • scripts.assign_speakerSay which speaker says which paragraphs. Send speaker_id as an empty string to give them back to the base speaker (the first one), which is who says every line nobody else was given.
  • scripts.filmcreditsFilm paragraphs: the speaker's photo saying the line, lip-synced to the recording already on it. SPENDS CREDITS, billed per second of clip, so say what it will cost before calling it. It STARTS the jobs and returns AT ONCE: one clip takes one to three minutes, the pending clips are written onto the document, and they finish whether or not anybody is watching. Do NOT poll and do not promise a link in this turn. Each paragraph needs two things, and this reports the ones missing rather than buying them: a face on the speaker (set_speaker_face) and a voice recording (script_voice, or the editor Voice tab). Safe to run twice, a paragraph already filmed against the same recording is left alone unless `force`. Call it with `dry_run` first whenever the user has not agreed to a number.
  • scripts.set_speaker_faceGive a speaker the photo they are filmed from, or clear it. One face per PERSON rather than per paragraph: it is a property of whoever is talking, so every line they say is filmed from it, including lines written later. The url has to be a public image the lip-sync provider can fetch, which anything in the user own file library is. With no speaker_id it sets the base speaker, who says every line nobody else was given. Free, and nothing is filmed by setting it.
  • scripts.clipsWhat has been filmed, and what stands in the way. Per paragraph: whether it has a clip, whether the clip is still running, WHICH MODEL made it, how long it runs and what it cost, plus how many attempts are kept. Also which speakers have a face and which lip-sync models this deployment can run, with the price per second. Free, no model call, so read it before quoting a cost and before saying a clip is late.
  • scripts.choose_clipKeep one filmed attempt as the paragraph clip: the one the export and the video editor use. The others stay in the list, so this is reversible and costs nothing. read_film_status names the attempts.
  • scripts.delete_clipDrop one filmed attempt from a paragraph list. The mp4 itself is LEFT on storage, exactly as a deleted take leaves its audio: the same url may already sit in a timeline layer, and what this shortens is the list, not the bucket. Deleting the chosen clip promotes the newest survivor rather than leaving the paragraph blank. Nothing is refunded, the clip was already paid for.

24 resources

Read and written with the standard CRUD verbs, scoped per key.

videos

Video projects with their timeline, blocks and generation settings.

list - get - create - update - delete

scripts

Video scripts: paragraphs, chapters, speakers, takes and the research behind them. Writing goes through the `scripts.*` actions.

list - get

folders

Folders organising videos and playground generations.

list - get - create - update - delete

assets

Files uploaded to the workspace library.

list - get - create - delete

characters

Recurring characters with their visual and voice configuration.

list - get - create - update - delete

agents

Image and video generation agents.

list - get - create - update - delete

flows

Automation flows: nodes, edges and variables.

list - get - create - update - delete

slideshows

Slideshow projects and their slides.

list - get - create - update - delete

templates

Saved video templates.

list - get - create - update - delete

video_styles

Reusable style presets applied to timelines.

list - get - create - update - delete

smart_group_configs

Custom smart-group definitions used by the timeline editor.

list - get - create - update - delete

custom_video_types

User-defined video types available in the editor.

list - get - create - update - delete

generations

Every AI generation billed to the workspace: image, video, audio, music.

list - get

music

AI song generations and their tracks.

list - get

scheduled_posts

Posts queued for publication on connected social accounts.

list - get - create - update - delete

social_accounts

Connected publishing destinations. Read-only: connect them from the dashboard.

list - get

renders

Render jobs and their output files. Start one with the `renders.create` action — it charges credits.

list - get

backgrounds

The curated background shelf: the stills and loops an admin published for everyone to build on.

list - get

voices

The voice catalog: the shared global library plus the workspace and personal voices.

list - get

character_tags

Tags used to organise characters.

list - get - create - update - delete

agent_executions

History of agent runs with their prompt, variables and result.

list - get

flow_executions

Flow runs: status, node states, execution path and credits consumed.

list - get

credit_transactions

Every credit movement of the workspace: what was charged, by whom, for what.

list - get

playground_generations

Images and videos generated from the playground gallery.

list - get - update - delete

Read this site as Markdown

Because HTML is a bad way to hand a page to a model.

curl -H "Accept: text/markdown" https://autostud.ai/tools/tweet-to-video
curl https://autostud.ai/tools/tweet-to-video.md
curl "https://autostud.ai/tools/tweet-to-video?format=md"

Same page, roughly fifty times fewer bytes, with the layout chrome removed. Works on every public URL on this domain.

Connect in under a minute

Mint a key, paste the URL into your client, call whoami.

Get your MCP URL