AutoShort MCP
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@AutoShort MCP Draft a 30-second faceless video script about 3 morning productivity habits"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
AutoShort MCP
Turn an idea into a faceless short video: script, voiceover, captions and scenes, from any AI assistant that speaks MCP. The primary way to use it is the hosted remote MCP server of AutoShort (nothing to install). This repository also holds the MIT-licensed source of the local stdio server (mcp-server-autoshorts on npm), a thin proxy that forwards tools/list and tools/call to the hosted endpoint with your API key.
Endpoint:
https://autoshort.org/api/mcp(Streamable HTTP)Registry name:
org.autoshort/autoshort(Official MCP Registry)Auth: OAuth 2.0 with PKCE and dynamic client registration (discovered from
/.well-known/oauth-protected-resource), or an AutoShort API key asAuthorization: Bearer sk_live_...Docs and API keys: https://autoshort.org/en/developers
Also on npm as a stdio proxy:
npx -y mcp-server-autoshortswithAUTOSHORT_API_KEYset (source insrc/)
What you need
An AutoShort account. The server is a connector to your own account, not a free video generator: drafts are free, renders spend credits from your balance. AutoShort's current plans: a 3-day trial for $2.99 (non-refundable, includes 150 credits), then from $19/month; credit packs start at $2.99. See https://autoshort.org/en/pricing for the live prices.
Related MCP server: EchoFM Studio
Connect
Claude Code
claude mcp add --transport http autoshort https://autoshort.org/api/mcpthen run /mcp and authenticate autoshort (a browser opens: sign in and allow).
Gemini CLI
gemini extensions install https://github.com/airdropfi/autoshort-gemini-extensionVS Code (.vscode/mcp.json)
{
"servers": {
"autoshort": { "type": "http", "url": "https://autoshort.org/api/mcp" }
}
}Any other client that supports remote (Streamable HTTP) servers: add the URL above. If the client cannot do OAuth, create an API key in the AutoShort dashboard and send it as Authorization: Bearer sk_live_....
What the tools cover
54 tools, with read-only / destructive annotations on each:
Area | Examples |
Draft and render | draft a script, review and edit it, revise a scene, price it, render it, cancel, track status |
Formats | faceless videos, chat-style videos, product-page ads, image-to-video, motion clips, UGC-style campaigns |
Series | plan a multi-episode character series, character sheets, per-episode quotes, pause/resume |
Account | credit balance, usage, limits, cost estimate, subscription, webhooks, API keys |
Publishing | list connected social accounts and publish a finished video |
Rules the server enforces: a draft is free and renders nothing; a render is priced first (autoshort_estimate_cost / autoshort_quote_video) and spends credits only when you confirm it; real or famous people, protected characters and sexual content are refused. Videos use AI-generated images and voice: switch on the platform's AI-content label when you post. No result or performance is promised.
Related
Claude Code plugin: https://github.com/airdropfi/autoshort-claude-plugin
Gemini CLI extension: https://github.com/airdropfi/autoshort-gemini-extension
Privacy: https://autoshort.org/en/privacy · Terms: https://autoshort.org/en/terms · Support: support@autoshort.org
Run the stdio server from source
npm ci && npm run build
AUTOSHORT_API_KEY=sk_live_... node dist/index.js # or: docker build -t autoshort-mcp . && docker run -i -e AUTOSHORT_API_KEY autoshort-mcpWithout an API key the server still starts and answers tools/list from an offline snapshot of the hosted server's public tool list (src/tools-snapshot.ts; no network, no account), but every tool call is refused until a key is set. With a key, the tool list is fetched live from the hosted server, so it is always current.
About this repository
It holds the registry metadata (server.json, identical to the published registry entry), documentation and the source of the stdio proxy (src/, tests/, Dockerfile). The hosted server's own code (the tool registry, billing and rendering) is closed source and runs at autoshort.org. MIT license covers the contents of this repository.
Available Tools
54 toolsautoshort_buy_creditsBuy the approved credit packAIdempotentInspect
Buy the owner-approved credit pack on their saved card, off-session — only when auto-recharge is ACTIVE and only within its monthly cap. Idempotent: the same idempotencyKey never charges twice. Returns 202 while Whop processes it; poll autoshort_get_credit_balance. Without auto-recharge use autoshort_get_buy_credits_url.
Inputs: idempotencyKey (required).
autoshort_cancel_videoCancel a video that has not started renderingADestructiveIdempotentInspect
Cancel a video that has NOT started rendering (status PENDING or DRAFT) and refund whatever it was charged, through the credit ledger (net of earlier refunds — never twice). Refused once rendering has started (CANNOT_CANCEL_STARTED) and for operator-fulfilled clips. A cancelled video never renders later. Free.
Inputs: videoId (required).
autoshort_create_character_episodeCreate a character episodeAIdempotentInspect
Make the episode: 3-8 shots, 12-60 seconds, the same fictional character in every shot, narrated with captions. CHARGES credits. The series must have a REVIEWED, CONFIRMED season plan and the episode must be one of its episodes exactly as planned (SEASON_PLAN_REQUIRED / SEASON_NOT_REVIEWED / EPISODE_NOT_IN_PLAN otherwise, with a nextAction, nothing charged); the narrator voice, language, style, look and outfit come from the plan. ALWAYS call autoshort_quote_character_episode first and get the customer yes: this call refuses unless confirm is true and expectedCredits equals the quoted price (a changed price answers 409 and charges nothing). Credits are held when it starts. A shot that cannot be animated keeps a still image and its clip credits go back; if too few shots move, or anything else fails, everything goes back. Takes about 10-25 minutes: poll autoshort_get_video with arguments { id: <the returned id / videoId> } (or use a webhook); it reports status, stage and, when COMPLETED, videoUrl. Pass idempotencyKey so a retry never charges twice. One episode at a time per account, 3 per day.
Inputs: confirm (required), seriesId (required), expectedCredits (required), shots, +8 more.
autoshort_create_character_sheetCreate a character sheetAIdempotentInspect
Make a character sheet for one of your series: 4-6 AI images (default 5: front portrait, full body, side, two expressions) of ONE fictional character, from a text description. Price: 21 credits for 5 images of a person, 10 for an animal or mascot; call autoshort_get_character_sheet first and tell the user. Credits are taken when it starts and returned in full if no sheet comes back. If a non-primary view (full body, side, an expression) could not be made in time, the sheet still comes back with the images that exist (the answer says partial: true and lists missingViews) and only those images are charged: the difference is returned and creditsCharged shows what was kept. For a person the face is carried from the front portrait into the other views; the outfit follows the description and can drift a little. For an animal or mascot the views share one description and seed, so they look alike but are not guaranteed to be identical. Usually under a minute; the answer already contains the images (a slow image model fails the call and returns the credits). Not accepted (CONTENT_POLICY, nothing charged): real or famous people, children or anyone who looks under 18, sexual content, logos or protected characters. Characters must be fictional and clearly adult (or an animal / mascot). A series can hold 3 sheets in total; the first sheet is chosen automatically. Pass idempotencyKey so a retry never charges twice.
Inputs: seriesId (required), imageCount, description, subjectKind, +1 more.
autoshort_create_seriesCreate a seriesAInspect
Create a series: AutoShort makes a video on this niche and brief every scheduleIntervalDays, and can auto-post it. Creating or changing a series is FREE. While active, the scheduler makes one video every scheduleIntervalDays (the first at its next run, within about 30 minutes) and charges each video like any video, at render — only when the balance covers it; a short balance skips that run, it never fails or overdraws. A series created or resumed through this connection counts each scheduled video against this key's daily agent spending cap (autoshort_get_limits); over the cap, that day's run is skipped. brief is what the generator writes from (topics, facts, tone) — put the user's own words here. Set startPaused: true to create it without generating yet (resume with autoshort_resume_series). Auto-post needs the platform connected (autoshort_get_connection_status); TikTok auto-post goes to Drafts.
Inputs: name (required), niche (required), brief, quality, +9 more.
autoshort_create_webhookCreate a webhookAInspect
Register an https URL to receive a signed POST when any of the user's videos reaches COMPLETED (video.completed) or FAILED (video.failed), within about a minute — instead of polling. Returns the signing secret ONCE: verify X-Webhook-Signature = hex HMAC-SHA256(raw body, secret). The URL must be public (private/internal addresses are refused). Max 10 per account. Free.
Inputs: url (required), events, description.
autoshort_delete_webhookDelete a webhookADestructiveIdempotentInspect
Delete a webhook; deliveries to it stop immediately. Free.
Inputs: webhookId (required).
autoshort_disable_auto_rechargeTurn off auto-rechargeAIdempotentInspect
Turn auto-recharge off immediately; autoshort_buy_credits stops charging. Turning it back on needs the owner's approval again. Free.
Inputs: no named parameters.
autoshort_draft_videoDraft a video (free, no render)AInspect
Create a video DRAFT — nothing is rendered and no credits are charged. Director mode, the recommended way to make a video the user has opinions about: (1) write and agree the script with the user in this conversation first — narration per scene and what each scene should show; (2) call autoshort_draft_video with scenes[] (free, nothing is rendered or charged); (3) show the user the draft (scenes, estimated length, estimated credits, warnings) and apply their changes with autoshort_update_draft; (4) only after the user approves, call autoshort_render_draft — that is when credits are charged. Narration is read VERBATIM: AutoShort never rewrites it. Each scene with a visual gets exactly that image (plus the art style). A scene can carry image_url (the user's own picture, public https link): that scene shows it instead of a generated image, and the draft marks it imageSource "your image". Pass scenes[] for a script you agreed with the user (free; stored word for word), or a brief to have AutoShort write one draft for review (needs a positive credit balance, max 20 per hour). Returns draftId, the scenes, estimatedDurationSeconds, estimatedCredits and warnings[].
Inputs: brief, title, scenes, artStyle, +3 more.
autoshort_estimate_costEstimate the cost of a callARead-onlyIdempotentInspect
Price a paid call BEFORE making it: pass {tool, arguments} — the tool name and the exact arguments you would send (or just {draftId} to price autoshort_render_draft). Returns the most credits it can commit, the balance it needs, whether the balance and this key's daily cap cover it, and when it is charged. Nothing is created or charged. Free.
Inputs: tool, draftId, arguments.
autoshort_generate_chat_videoGenerate a video from a creative briefAIdempotentInspect
Create a video from a natural-language creative brief; AutoShort writes the script from it. To keep an agreed script word for word with your own shots, use autoshort_draft_video instead. To use the user's own pictures ("make a video with these images"), pass image_urls (public https links, up to 6): image 1 becomes scene 1, image 2 scene 2, …; the rest are generated. Naming an image inside the brief does NOT attach it: only image_urls do. If the brief points at a picture you did not pass, the answer carries warnings["IMAGE_IGNORED"] with a warningText (read it to the user), or CHAT_NO_IMAGE_INPUT (retry with image_urls, or proceedWithoutImage: true). Optional captionSecondaryLanguage adds a translated second caption line under the narration captions (e.g. "vi" for English narration with Vietnamese under it); "none" turns it off for this video even if the account default has one; omitted = the account default (off unless the user set one). It costs nothing extra. Costs 40 credits with the default voice (+25 if ElevenLabs narrates); images do not change the price. Rendering is asynchronous: poll autoshort_get_video every 20-30 seconds until status is COMPLETED or FAILED. If get_video returns blockedReason, stop polling and act on it (e.g. top up credits). ROUTING: if the user pasted a cinematic / video-model prompt (camera, lens, lighting, a scene description), do NOT use this tool: it writes its own script and makes narrated still-image scenes. Use autoshort_generate_motion_clip, which sends the prompt as written. Use this tool for narrated stories and facts. videoProvider VEO_3_1_OPERATOR is operator-fulfilled and not guaranteed: it does not turn a prompt into a moving clip.
Inputs: message (required), artStyle, language, image_urls, +6 more.
autoshort_generate_image_to_videoAnimate one image into a clipAIdempotentInspect
Animate ONE reference image into a silent 5-second AI-generated video (for a multi-scene video built from several of the user's pictures, use image_urls on autoshort_generate_chat_video instead). Send the image as image_url (a public https link, JPEG/PNG/WebP, at most 10 MB) or as imageBase64; the stdio package also accepts a local imagePath and uploads it. The photo becomes the first frame of the clip. ACCEPTED: products, pets, scenery, food, illustrations, and cartoon, anime or other clearly stylised characters (not realistic people, whether real or AI-generated). REJECTED before anything is charged: photos of real people (any realistic human face, to prevent deepfakes), sexual content, anything that may show a child; the answer says why. Only send images the user owns or may use. Costs 100 credits (20 credits per second x 5 s), charged the moment the job is accepted (not on delivery). Any plan with enough credits; a never-paid account gets one AI clip until its first payment. Rendering is automatic (OpenRouter Seedance 2.0 Mini, 480p, no audio): ready in up to about 13 minutes, typically less (not yet measured), so poll autoshort_get_video every 20-30 seconds. If the clip cannot be made (for example the video provider refuses the image on content-policy grounds) the video ends FAILED with the specific reason and the credits are refunded automatically; if it does not come back, check autoshort_get_credit_balance and report a missing refund. The result is labelled AI-generated (aiGenerated: true); keep that label when posting. Retry-safe: the same image + motionPrompt returns the first job (duplicate: true) for 24 hours instead of charging again; pass idempotencyKey to force a separate clip from identical inputs. To turn a TEXT prompt into a moving clip automatically (no photo, no human operator), use autoshort_generate_motion_clip instead.
Inputs: motionPrompt (required), imagePath, image_url, imageBase64, +2 more.
autoshort_generate_motion_clipGenerate an AI motion clipAIdempotentInspect
Turn a text-to-video prompt into ONE AI motion clip (Seedance 2.0). The prompt is sent EXACTLY as written: no script is written, no still images are made, no voice is added, nothing is rewritten or shortened. USE THIS TOOL when the user pastes or asks for a cinematic / video-model prompt (camera moves, lens, lighting, a scene description, "9:16 vertical", "slow dolly-in", the kind ChatGPT or Claude writes for Seedance, Sora or Veo). For a narrated story or facts video use autoshort_generate_chat_video. The clip is silent (no audio, no lip-sync, no talking), 4-12 seconds (default 5), resolution 480p (default 480p; higher resolutions need a higher plan: PLAN_TIER_LOCKED). Price: 20 credits per second, so 5 s = 100 credits and 12 s = 240; call autoshort_quote_video first and tell the user the price before creating. The credits are held when the clip is accepted and returned in full if no clip comes back. The only text added to the prompt is a short server suffix ("No spoken dialogue, no lip-sync, no talking to camera, no watermark."); the answer echoes promptSent and the seed so the user can see and repeat exactly what was made. Not accepted (CONTENT_POLICY, nothing charged): real or famous people, minors, sexual content, protected characters or brands, deepfakes and lip-sync. A first-frame photo is not supported yet. Optional character_id: the id of one of YOUR character sheets (autoshort_get_character_sheet); the clip then starts from that sheet's chosen image, so the first frame shows your character. The character can still drift while it moves; it is not a guarantee of an identical face. A sheet that is not yours or not ready is CHARACTER_NOT_FOUND (nothing charged). Same price. Optional templateId: one of the 26 ready clip templates from autoshort_list_templates (kind "motion"); its prompt, seconds and aspect ratio are used. If you also pass prompt, the prompt wins and the template is ignored. An unknown templateId is refused (INVALID_INPUT, nothing charged). Trial accounts get up to 10 clips of up to 5 s each (MOTION_TRIAL_LIMIT); at most 2 clips run at once; a daily capacity limit applies (DAILY_CAP_REACHED). Rendering is asynchronous: poll autoshort_get_video every 20 seconds until COMPLETED (videoUrl is an MP4) or FAILED (errorCode, creditsRefunded). Pass idempotencyKey so a retry never charges twice.
Inputs: seed, prompt, duration, resolution, +4 more.
autoshort_generate_product_adGenerate a product ad from a pageAIdempotentInspect
Create a product marketing video from a public product page. AutoShort extracts product details and images, writes the ad, and creates editable scenes. Costs at least 40 credits; the exact quote is checked before the page is fetched. Rendering is asynchronous: poll autoshort_get_video every 20-30 seconds until status is COMPLETED or FAILED. If get_video returns blockedReason, stop polling and act on it (e.g. top up credits).
Inputs: url (required), artStyle, duration, language, +1 more.
autoshort_generate_videoGenerate a video from a topicAIdempotentInspect
Generate a video from a topic; AutoShort writes the script (to render a script you already agreed with the user, use autoshort_draft_video). Optional image_urls (public https links, up to 6) put the user's own pictures in the first scenes. Costs 65 credits (40 render + 25 ElevenLabs voice); art style does not change the price. Images do not change the price. A short balance is refused with 402 INSUFFICIENT_CREDITS. Rendering is asynchronous: poll autoshort_get_video every 20-30 seconds until status is COMPLETED or FAILED. If get_video returns blockedReason, stop polling and act on it (e.g. top up credits). ROUTING: this makes a narrated video of still images from a topic. If the user pasted a cinematic / video-model prompt, use autoshort_generate_motion_clip instead.
Inputs: topic (required), niche, quality, artStyle, +4 more.
autoshort_get_buy_credits_urlGet a checkout link for credits or a planARead-onlyIdempotentInspect
A checkout link to buy credits (pack) or start a plan (plan, 3-day trial) on Whop — for the human to open and pay once. No email or personal data is in the link. Packs: MICRO, STARTER, VALUE, MEGA. For a new customer, EPISODE is the first episode pack: 350 credits, enough for one 12-second Character Studio drama episode. AI-generated video. Credits do not expire while your account is active. One-time purchase, no renewal. First purchase 50% off the regular $6.99. A new account's first video can be free, in the web app or through autoshort_render_draft when the account has no credits (one watermarked video per person, a daily cap of 20 shared by all accounts; not available through direct REST calls with an API key), then EPISODE at $3.49 on a first purchase is the next step. After they pay, poll autoshort_get_credit_balance. If the owner enabled auto-recharge, use autoshort_buy_credits instead (no link). Free.
Inputs: pack, plan.
autoshort_get_capabilitiesGet capabilities and first stepsARead-onlyIdempotentInspect
Start here. Describes the whole agent workflow end to end — make, approve, render, publish, automate, pay — the only steps a human must do, and the limits. Free.
Inputs: no named parameters.
autoshort_get_character_sheetRead character sheetsARead-onlyIdempotentInspect
Read the character sheets of one of your series: each sheet is a set of AI images of one fictional character, its images (id, view, url), which sheet and which image are chosen, how many sheets the series may still make (3 in total), and the exact price of a new sheet (21 credits for 5 images of a person, 10 for an animal or mascot). Free. Use this before autoshort_create_character_sheet and tell the user the price.
Inputs: seriesId (required).
autoshort_get_connection_statusCheck a platform connectionAIdempotentInspect
Is this platform connected? If yes, returns the account. If not, returns connectUrl: a short, single-use link (expires in 15 minutes) that opens the platform's consent screen directly. Give it to the user — that consent is the only human step, once per platform — then call this again every 10 seconds (pollAfterSeconds) until connected is true and continue on your own. Polling reuses the same unexpired link. YouTube, Facebook, Instagram and Threads need a paid plan; Facebook/Instagram/Threads answer PLATFORM_PENDING_APPROVAL where Meta has not enabled them for the account yet. Free.
Inputs: platform (required).
autoshort_get_credit_balanceGet credit balanceARead-onlyIdempotentInspect
Your current credit balance, monthly allocation, bonus credits and plan. Requires the "credits:read" scope (default in new keys). Free.
Inputs: no named parameters.
autoshort_get_draftRead a draftARead-onlyIdempotentInspect
Read a draft (or a submitted director video) as scenes with narration, visual, timing estimates, estimated credits and warnings. Free.
Inputs: draftId (required).
autoshort_get_limitsGet spending and rate limitsARead-onlyIdempotentInspect
Everything that can stop a call: credit balance, this key's daily agent spending cap (spent / remaining / reset), auto-recharge status and monthly cap, platform publishing limits, and per-hour caps on free AI calls. Free.
Inputs: no named parameters.
autoshort_get_season_planRead a season planARead-onlyIdempotentInspect
Read the season plan of one of your series: the plan (logline, genre, narrator voice, language, style, cast with outfits, every episode), its hash, its status (none, saved, reviewed or confirmed) and the recorded season review (a checklist with pass or fail per rule, the season price and, if it ran, the AI review). Free. An episode can only be made from a plan that is reviewed and confirmed: use this to see where the plan stands and which episodes can be quoted.
Inputs: seriesId (required).
autoshort_get_series_performanceGet series performanceARead-onlyIdempotentInspect
How YOUR OWN posted YouTube Shorts performed, per series: videos posted/measured, total/median/mean views, top 3 and bottom 3 videos (with outlierScore = views / series median), and views gained in the last 7 days vs the 7 days before. Use it to decide what to make next: repeat the formats of the best videos, drop the worst. Only your own videos; views come from daily YouTube snapshots; audience retention is not available. Free, read-only.
Inputs: days, seriesId.
autoshort_get_subscriptionGet subscription planARead-onlyIdempotentInspect
Your subscription plan, status and credit allocation. Requires the "billing:read" scope. Free.
Inputs: no named parameters.
autoshort_get_usage_statsGet API usage statisticsARead-onlyIdempotentInspect
API usage statistics: credit balance, API call counts (today/total) and recent credit transactions. Requires the "usage:read" scope. Free.
Inputs: no named parameters.
autoshort_get_videoGet a videoARead-onlyIdempotentInspect
Get one video's status and details by id. While rendering, status is PENDING/GENERATING_*/RENDERING with estimatedCompletionTime. A PENDING video that cannot render returns blockedReason (e.g. INSUFFICIENT_CREDITS) with creditsNeeded, creditsAvailable and topUpUrl: stop polling and resolve it. COMPLETED returns a playable videoUrl; FAILED returns error. Free. Motion clips (autoshort_generate_motion_clip) also return motionClip{promptSent, seed, resolution, seconds, credits}, and on failure errorCode and creditsRefunded.
Inputs: id (required), videoId.
autoshort_list_nichesList niches, styles and durationsARead-onlyIdempotentInspect
List the content niches, art styles, video qualities and durations the generation tools accept. Free.
Inputs: no named parameters.
autoshort_list_optionsList options and pricesARead-onlyIdempotentInspect
Every option and price the tools accept, from the live constants: voices for a language (premium flag + extra credits), art styles (PRO flag), niches, caption themes, aspect ratios, the durations each tool allows, video providers for the plan, motion-clip / hero-scene prices — and for each, which tool lets you choose it. Use it instead of guessing an enum. Free.
Inputs: language.
autoshort_list_seriesList seriesARead-onlyIdempotentInspect
List the user's series (autopilot channels), newest first, with schedule, auto-post flags, brief and video count. Paginated (page, limit). Free.
Inputs: page, limit.
autoshort_list_social_accountsList connected social accountsARead-onlyIdempotentInspect
List the connected publishing accounts per platform (YouTube, TikTok, Facebook Page, Instagram, Threads) with username, whether they need reconnecting, the publish mode, the AI-disclosure handling and today's platform limits. Never returns tokens. For a platform that is not connected, call autoshort_get_connection_status to get a one-click connectUrl. Free.
Inputs: no named parameters.
autoshort_list_templatesList video templatesARead-onlyIdempotentInspect
List 12 ready-made video templates (kind "video": history facts, scary stories, motivation, personal finance education, kids music, product ad, small-business explainer, character mini-episode and more) and 26 AI motion clip templates (kind "motion": single-shot prompts for landscapes, macro food, animals, products, abstract loops, city nights, weather, miniatures, fantasy scenery and short-drama beats in thriller, comedy, horror, romance, action, epic and drama; the clips are silent, and any person is only a silhouette, seen from behind or as hands, never a face or a child). A video template has the full prompt, length, credit price and the exact arguments for autoshort_generate_chat_video. A motion template has the full prompt, genre, a six-slot breakdown (camera, subject, action, setting, style, lighting: each phrase is literally in the prompt), a one-line why, seconds, credits, a demoVideoUrl when a sample clip exists, and the arguments for autoshort_generate_motion_clip (pass its id as templateId, or edit the prompt and pass it as prompt). 6 short-drama episode scripts (kind "episode", 12-60 s multi-shot episodes for Character Studio; listed only with kind "episode" or an id) carry a script, logline and cliffhanger. An episode is only made as one of the episodes of a reviewed, confirmed season plan: add it to a plan with autoshort_save_season_plan (at least 3 episodes, the cast, the narrator voice and the style), review and confirm it, then autoshort_quote_character_episode prices it for free. Edit any prompt first (swap the topic, shop name or facts). Pass kind "video", "motion" or "episode", id for one template, genre (drama, thriller, comedy, horror, romance, action, epic, nature, product, fantasy) to filter motion and episode templates, or niche (video templates) to filter. Nothing is created or charged; show the user the price before you generate. Free.
Inputs: id, kind, genre, niche.
autoshort_list_videosList videosARead-onlyIdempotentInspect
List your videos, newest first, with pagination and an optional status filter (PENDING, GENERATING_SCRIPT, GENERATING_VOICE, FETCHING_MEDIA, RENDERING, COMPLETED, FAILED, DRAFT). Free.
Inputs: limit, offset, status.
autoshort_list_webhooksList webhooksARead-onlyIdempotentInspect
List the registered webhooks (URL, events, active, last delivery, failures). Secrets are not shown. Free.
Inputs: no named parameters.
autoshort_pause_seriesPause a seriesAIdempotentInspect
Pause a series: the scheduler stops making (and charging for) its videos until resumed. Videos already made are untouched. Free.
Inputs: seriesId (required).
autoshort_plan_drama_seasonPlan a drama seasonARead-onlyInspect
Drama Studio writers room: turn a one-line premise into a short-drama season: a character bible (1-4 original fictional characters: name, role, look) and 2-8 episode scripts, each with a title, a logline, a script and a "cliffhangerLine". The cliffhanger is SPOKEN: the script's last sentence is exactly "cliffhangerLine" (an open hook for every episode but the last; a payoff plus one lingering question for the last), the first sentence is a hook and the next episode picks the hook up. Each script is already sized to pass autoshort_quote_character_episode (12-60 seconds of narration); an episode that could not be made to fit comes back with needsEditing: true and the exact limit in issue. FREE: it spends no credits, starts nothing and saves nothing (it is limited per hour). Characters are always original fictional adults, animals, robots or mascots; real people, brands and sexual or graphic content are refused. Next steps: autoshort_create_series (paused) with the main character as characterDescription, autoshort_create_character_sheet, then autoshort_save_season_plan (the whole season: cast, voice, style, every episode), review it, get the customer's yes and confirm it; only then autoshort_quote_character_episode and autoshort_create_character_episode per episode.
Inputs: genre (required), premise (required), episodes (required), language.
autoshort_publish_videoPublish a completed videoAIdempotentInspect
Publish one of the user's COMPLETED videos. YOUTUBE: uploads to the connected channel with your title/description and privacy (public, unlisted, private); the "altered or synthetic content" disclosure is always set; madeForKids is the user's COPPA answer (ask them for a kids audience); nothing is appended to the description unless addAttribution is true (default false — only when the user asked for "Made with AutoShort"). TIKTOK: sends the video to the creator's TikTok Drafts (inbox) — they add the caption, switch on the AI-generated label and post in the app; pass userConsent: true only after the user agreed. FACEBOOK / INSTAGRAM / THREADS: publishes publicly as a Facebook Page Reel, an Instagram Reel or a Threads video with your caption (or a default one); #AIGenerated is always added. Meta processes the video for a minute or more: the first call answers QUEUED, call again with the same arguments to read the status (POSTED with the url). A FAILED publish is retried only with retry: true. Idempotent per (videoId, platform): a repeat returns the first result and never posts twice. Respects platform caps (YouTube ≈5 uploads/day; TikTok's pending-drafts limit; Facebook 25, Instagram 25, Threads 50 posts/day). Not connected → NOT_CONNECTED with a connectUrl. Free.
Inputs: videoId (required), platform (required), retry, title, +6 more.
autoshort_quote_character_episodeQuote a character episodeARead-onlyIdempotentInspect
Price one PLANNED episode (12-60 seconds, 3-8 shots) of a series with a confirmed season plan, starring the character the plan names. FREE: it spends nothing and starts nothing. Returns the shot plan (narration, action, camera and seconds of every shot), the exact credits (clips are Seedance at the per-second rate of the chosen resolution: 480p by default, 720p only when quote.pricePerResolution lists it as available, plus a still per shot and the narration), and a ready-made nextAction for autoshort_create_character_episode. Show the customer the price and the shots, and call the create tool only after they say yes. The same safety checks as the real call run here: real or famous people, anyone who looks under 18, sexual content and protected characters are refused with CONTENT_POLICY. Only an episode of a REVIEWED, CONFIRMED season plan can be quoted or made: send its script or shots exactly as planned (autoshort_get_season_plan). Without a confirmed plan the answer is SEASON_PLAN_REQUIRED or SEASON_NOT_REVIEWED, and for shots that are not a planned episode EPISODE_NOT_IN_PLAN, each with a nextAction. The narrator voice, the language, the style and the character come from the plan and cannot be overridden (SEASON_FIELD_LOCKED); to change an episode, edit the plan (that clears the review).
Inputs: seriesId (required), shots, title, script, +4 more.
autoshort_quote_videoQuote the credit price of a videoARead-onlyIdempotentInspect
The exact credit price of a video BEFORE it is made. Read-only: nothing is created, reserved or charged. Tell the user the price, then call the creating tool. mode "motion_clip": one moving clip from a prompt (autoshort_generate_motion_clip), by duration and resolution; also says whether this account can start it now (canStart, blockedBy). mode "stills": a normal narrated video made of still images (autoshort_generate_chat_video, or tool "autoshort_generate_video"). Also returns the balance, whether it covers the price, and this key's remaining daily spending cap. Free.
Inputs: mode (required), tool, duration, resolution, +1 more.
autoshort_render_draftRender an approved draftAIdempotentInspect
Render an approved draft. Call ONLY after the user has seen the draft and said yes. Charges the draft's estimatedCredits now (40 with the default voice), before any rendering work; refunded automatically if the render fails for good. Narration is read verbatim and each scene shows its visual; targetDuration is recorded as requested, and the video runs as long as its narration takes to read (any mismatch was in the draft's warnings). Retry-safe: a repeated call returns the first submission and charges nothing. A short balance returns 402 and keeps the draft. If the account has no credits and has not yet had its free first video, this renders that video instead of failing: watermarked, labelled AI-generated, up to 30 seconds, standard voice, one per account, subject to the day's availability. The answer carries the new video id (not the draft id): poll that one. Rendering is asynchronous: poll autoshort_get_video every 20-30 seconds until status is COMPLETED or FAILED. If get_video returns blockedReason, stop polling and act on it (e.g. top up credits).
Inputs: draftId (required), idempotencyKey.
autoshort_resume_seriesResume a seriesAIdempotentInspect
Resume a paused series. Creating or changing a series is FREE. While active, the scheduler makes one video every scheduleIntervalDays (the first at its next run, within about 30 minutes) and charges each video like any video, at render — only when the balance covers it; a short balance skips that run, it never fails or overdraws. A series created or resumed through this connection counts each scheduled video against this key's daily agent spending cap (autoshort_get_limits); over the cap, that day's run is skipped.
Inputs: seriesId (required).
autoshort_revise_sceneRevise one scene of a rendered videoAInspect
Change one scene of a video that was already rendered. Creates a NEW draft that copies every scene (unchanged scenes keep their existing images) with this scene changed; the original video is untouched and nothing is charged. Show it to the user, then autoshort_render_draft renders it as a new, fully charged video (narration re-voiced, video re-assembled). Single-scene re-render inside the existing file is not available yet.
Inputs: scene (required), videoId (required), visual, narration.
autoshort_save_season_planSave a season planADestructiveIdempotentInspect
Design, review and confirm the WHOLE season of a series before any episode is made. Free (no credits). Founder rules: a series is fully designed and reviewed before any video is produced, and its characters, voice and style are fixed in every episode. Three steps, one tool: (1) pass plan to save it (version 1: logline, genre, language, narratorVoiceId, styleTokens, characters[] with look, sheetId and wardrobeLock, rules[], at least 3 episodes[] with title, characterName, cliffhangerLine and shots[] or a script). Every edit clears the review and the confirmation. (2) pass review: true (with or without plan) to run the season review: a deterministic checklist (cliffhangers, hooks, one narrator and style, no on-screen text, one subject per look and per shot, outfit locked, season price) plus an advisory AI review that lists up to 8 concrete issues; if the AI review cannot run the answer says so and the checklist stands. (3) show the owner the checklist, the AI issues and the season price, and ONLY after they say yes call again with confirm: true and planHash from the review. Every character an episode uses needs a READY sheet of this series (autoshort_create_character_sheet, one sheet per character) whose id is in the plan. Then autoshort_quote_character_episode / autoshort_create_character_episode make the planned episodes.
Inputs: seriesId (required), plan, review, confirm, +2 more.
autoshort_select_character_imageChoose the series character imageAIdempotentInspect
Choose which character sheet a series uses and which of its images is the main one. The main image is what autoshort_generate_motion_clip starts from when you pass character_id (the sheet id). Only your own READY sheets and their images can be chosen. Free.
Inputs: sheetId (required), seriesId (required), assetId.
autoshort_set_limitsSet the daily agent spending capADestructiveIdempotentInspect
Set this key's daily agent spending cap in credits. Lowering (or keeping) it applies immediately. Raising it returns approvalUrl: the account owner must open it while signed in and approve — an agent cannot raise its own cap. Free.
Inputs: dailyCreditCap (required).
autoshort_setup_auto_rechargePropose auto-rechargeAInspect
Propose auto-recharge so later purchases need no link: a pack and a monthly USD cap. Returns approvalUrl — the owner signs in, confirms exactly that pack and cap, and saves a card on Whop (nothing is charged then). Tell the user the pack price and the cap before sending the link. Until they finish, nothing changes. Cap: pack price to $500/month. Free.
Inputs: pack (required), monthlyCapUsd (required).
autoshort_ugc_create_campaignCreate a Silent UGC campaignAIdempotentInspect
Create a Silent UGC campaign for the user's own app. Silent UGC: 9-12 s silent short marketing clips for the user's OWN app. Scene 1 = one consistent FICTIONAL AI character (realistic, or faceless: hands on a phone / over-the-shoulder / back view) silently reacting with body language and a big hook in the upper third; scene 2 = the app's real screen recording with a short caption. No voice, no audio track (a trending sound is added when posting). Every video carries a visible "AI-generated" note and AI metadata; switch the platform AI label on when posting. Characters come only from a text description (no photo uploads), must be fictional adults (no real or public people, lookalikes or @handles) and non-sexual — the server refuses anything else. Flow: (0) autoshort_ugc_upload_recording (the app screen recording as a public https URL or base64 → recordingAssetId); (1) autoshort_ugc_create_campaign (app name, what it does, a character, recordingAssetId); (2) autoshort_ugc_suggest_hooks; (3) autoshort_ugc_preview ONE hook and show the still to the user; (4) after they approve, autoshort_ugc_render_batch with the hooks they picked; (5) poll autoshort_ugc_get_campaign for the finished videos. Pass characterId to reuse a character, or characterDescription (a fictional adult's look; never a real or public person, a lookalike or a @handle; nothing sexual) plus characterStyle ("face" = realistic fictional character, "faceless" = hands/over-the-shoulder only) to generate one (1 credit, charged before the image is made). recordingAssetId comes from autoshort_ugc_upload_recording (MP4/MOV, 3-60 s, max 50 MB). Free otherwise.
Inputs: appName (required), appDescription (required), goal, appUrl, +7 more.
autoshort_ugc_get_campaignRead a UGC campaignARead-onlyIdempotentInspect
Read a Silent UGC campaign: character, recording, suggested hooks, and every variant with its status, preview and finished videoUrl (download). Free.
Inputs: campaignId (required).
autoshort_ugc_previewPreview a UGC variantAIdempotentInspect
Preview ONE variant's scene 1 before rendering anything: the character in the chosen setting and gesture (expression = body language), with the hook laid out as the video will show it. Returns previewUrl and a variantId (a draft). 1 credit only when a new start frame has to be generated; otherwise free. Show the still to the user; render only after they approve.
Inputs: hook (required), campaignId (required), setting, expression, +1 more.
autoshort_ugc_render_batchRender a batch of UGC variantsAIdempotentInspect
Approve and render up to 20 variants. Call ONLY after the user approved the preview. Pricing: character portrait 1 credit; preview 1 credit only when a new start frame is generated; a variant with a new clip 102 credits; a re-caption (same setting + expression, different hook, reuses the clip) 1 credit. The whole batch is reserved in one step before anything is generated — all or nothing; a short balance returns 402 and charges nothing. variantIds approves drafts from autoshort_ugc_preview; variants adds new hooks (setting/expression default to the latest previewed variant's, so they become cheap re-captions of its clip; fromVariantId re-captions a rendered clip). A clip that cannot be made falls back to the still frame and its clip credits come back. Poll autoshort_ugc_get_campaign every 30 seconds.
Inputs: campaignId (required), variants, variantIds, idempotencyKey.
autoshort_ugc_suggest_hooksSuggest UGC hooksAInspect
Propose 10-20 hooks for a campaign from its app description, in the families "I can't believe…", "No one told me…", "POV: …", "X months of … and now I find this" and a pricing angle. An honesty filter drops income or results promises, testimonial stats and speed claims the app cannot back up. Free, but needs a positive credit balance; max 20 per hour. Show the hooks to the user and let them pick.
Inputs: campaignId (required), count.
autoshort_ugc_upload_recordingUpload a screen recording for UGCAInspect
Upload the app screen recording for Silent UGC and get its recordingAssetId (for autoshort_ugc_create_campaign). Pass recordingUrl (a public https link — fetched by AutoShort, not by you; up to 50 MB) or recordingBase64 (at most 10 MB; larger files must use recordingUrl). MP4 or MOV, 3-60 seconds, at most 50 MB, checked from the file itself. The stdio package also accepts a local recordingPath. Free.
Inputs: fileName, recordingUrl, recordingPath, recordingBase64.
autoshort_update_draftEdit a draftADestructiveInspect
Change a draft before render. Free. Every scene number refers to the draft as it is now (1-based); operations apply in the order edits, reorder, remove, insert. edits: change a scene's narration (verbatim), visual (null clears it → auto image) or seconds. insert: add scenes after scene N (0 = at the start). remove: scene numbers to drop. reorder: every current scene number in the new order. Returns the updated draft — show it to the user again.
Inputs: draftId (required), edits, title, insert, +6 more.
autoshort_update_seriesEdit a seriesADestructiveIdempotentInspect
Change a series: name, brief, schedule, auto-post flags, the madeForKids answer or the AI motion level (motionMixLevel). Only the fields you pass change. Creating or changing a series is FREE. While active, the scheduler makes one video every scheduleIntervalDays (the first at its next run, within about 30 minutes) and charges each video like any video, at render — only when the balance covers it; a short balance skips that run, it never fails or overdraws. A series created or resumed through this connection counts each scheduled video against this key's daily agent spending cap (autoshort_get_limits); over the cap, that day's run is skipped.
Inputs: seriesId (required), name, brief, madeForKids, +7 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 54 tools
The set has six or seven overlapping video-creation entry points (generate_video, generate_chat_video, generate_product_ad, generate_image_to_video, generate_motion_clip, draft_video, character/UGC episode tools), which forces an agent to rely on lengthy embedded ROUTING notes rather than clear tool boundaries. The descriptions do actively disambiguate (drafts vs rendered, stills vs motion clips, narrated vs silent), so misselection is avoidable but expensive with 54 tools. Pricing is also split across estimate_cost, quote_video and quote_character_episode in ways an agent must learn.
Every tool uses the autoshort_ prefix with snake_case verb_noun (get_, list_, create_, update_, render_, publish_, quote_), which is highly predictable. Minor strain comes from nested namespaces (ugc_*) and near-synonym verbs: estimate_cost vs quote_video, buy_credits vs get_buy_credits_url vs setup_auto_recharge, plan_drama_season vs save_season_plan.
54 tools is far beyond a well-scoped surface, even for a platform spanning generation, drafts, publishing, billing, webhooks, series, character sheets and season plans. Several clusters (six generation entry points, four credit/purchase tools, many UGC sub-steps) could be collapsed into parameterized tools, and the volume itself becomes a discovery burden.
Coverage is unusually thorough: drafting, editing, rendering, cancellation, publishing per platform, credits/billing, spending limits, webhooks, series autopilot, character sheets, season plans and performance stats. Gaps are modest — no video deletion or metadata update tool, and no delete/archive series operation (only pause), which agents can mostly work around.
Maintenance
Related MCP Connectors
Build, run, schedule, and publish AI video pipelines to YouTube and TikTok from any MCP client.
Generate, schedule and post faceless and AI UGC short videos from Claude, Cursor or any MCP client.
Make, render and auto-post AI faceless videos to YouTube, TikTok and Instagram from any MCP client.
Make faceless YouTube videos and Shorts from a topic or script, then publish to YouTube.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceTurns text scripts into complete videos with stock footage, AI narration, and subtitles via MCP tools for AI assistants.MIT
- FlicenseNot gradedqualityDmaintenanceEnables AI assistants to manage audio-story series: create, edit, narrate, publish, and generate marketing content like UGC videos and reels through a secure MCP endpoint.-
- AlicenseBqualityBmaintenanceEnables AI agents to take a raw script all the way to a finished, downloadable short-drama .mp4, covering AI rewrite, character consistency, storyboards, frames, video shots, TTS voiceover, and final cut with quote-before-spend billing from any MCP client.1324,605 npm1MIT
- AlicenseNot gradedqualityBmaintenanceEnables AI assistants to create finished short-form videos with script, voiceover, scenes, captions, and music, delivering an MP4 ready for TikTok, Instagram Reels, and YouTube Shorts.115 npmMIT