MCP App Store
by KeenEthics
AutoShort icon

AutoShort MCP Server for ChatGPT

By AutoShort

Overview

AutoShort turns a script you agree with ChatGPT into a narrated, captioned 9:16 short video. How it works: 1. Write the script together in the conversation, scene by scene: what is said and what is shown. 2. ChatGPT saves it as an AutoShort draft. Drafts are free, and nothing is rendered yet. 3. Review and edit the draft. Narration is read exactly as written. 4. Once you approve, ChatGPT renders the video and gives you the link when it is ready, usually within a few minutes. You can also make a video from a topic, a short brief or a public product page, animate one image into a 5-second clip, and list or check your existing videos, credit balance and usage. Requires an AutoShort account. Rendering uses the credits already on that account, at the same prices as the AutoShort website, and ChatGPT states the cost before it renders. Videos are AI-generated: images are AI stills with camera motion, and voices are synthetic. Review every video before you publish it, and only use scripts, images and product pages you have the right to use.

How to connect

  1. ChatGPT: Open the AutoShort listing in the ChatGPT app directory and choose Connect. ChatGPT listing AutoShort exposes 51 tools here.

Tools

autoshort_archive_character_sheet

ChatGPT
Take a bad character sheet out of a series (wrong outfit, wrong look, a failed or unusable sheet) so its slot can be used for a new one: a series holds 6 sheets that are not archived or failed. Free. Nothing is deleted: videos already made keep their images; the archived sheet can no longer start a clip or star in an episode. Refused (SHEET_IN_SEASON_PLAN) while the confirmed season plan names the sheet: put the new sheet id in the plan first. Refused (SHEET_IN_FLIGHT) while it is still being made. Archiving does not reset the daily limit on new sheets.

autoshort_cancel_video

ChatGPT
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.

autoshort_create_character_episode

ChatGPT
Make the episode: 3-8 shots, 30-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.

autoshort_create_character_sheet

ChatGPT
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.

autoshort_create_series

ChatGPT
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.

autoshort_create_webhook

ChatGPT
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.

autoshort_delete_webhook

ChatGPT
Delete a webhook; deliveries to it stop immediately. Free.

autoshort_draft_video

ChatGPT
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[].

autoshort_estimate_cost

ChatGPT
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.

autoshort_generate_chat_video

ChatGPT
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. 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.

autoshort_generate_image_to_video

ChatGPT
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 40 credits (8 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 1.5 Pro, 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.

autoshort_generate_motion_clip

ChatGPT
Turn a text-to-video prompt into ONE AI motion clip (Seedance 1.5 Pro). 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: 8 credits per second, so 5 s = 40 credits and 12 s = 96; 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.

autoshort_generate_product_ad

ChatGPT
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.

autoshort_generate_video

ChatGPT
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. 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.

autoshort_get_capabilities

ChatGPT
Returns a guide to the AutoShort workflow: drafting, approving, rendering, publishing and scheduling videos, which steps the user has to do themselves, and the usage limits that apply. Read-only; call it first.

autoshort_get_character_sheet

ChatGPT
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.

autoshort_get_connection_status

ChatGPT
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.

autoshort_get_credit_balance

ChatGPT
Your current credit balance, monthly allocation, bonus credits and plan. Requires the "credits:read" scope (default in new keys). Free.

autoshort_get_draft

ChatGPT
Read a draft (or a submitted director video) as scenes with narration, visual, timing estimates, estimated credits and warnings. Free.

autoshort_get_limits

ChatGPT
Returns your credit balance, this key's daily spending cap with what has been spent and what remains today, platform publishing limits, and the hourly caps on AI calls.

autoshort_get_season_plan

ChatGPT
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.

autoshort_get_series_performance

ChatGPT
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.

autoshort_get_subscription

ChatGPT
Your subscription plan, status and credit allocation. Requires the "billing:read" scope. Free.

autoshort_get_usage_stats

ChatGPT
API usage statistics: credit balance, API call counts (today/total) and recent credit transactions. Requires the "usage:read" scope. Free.

autoshort_get_video

ChatGPT
Returns one video's status and details by id. While it is being made, status is PENDING, GENERATING_* or RENDERING, with estimatedCompletionTime. A PENDING video that cannot start returns blockedReason (for example INSUFFICIENT_CREDITS) with creditsNeeded and creditsAvailable: stop polling and tell the user. COMPLETED returns a playable videoUrl; FAILED returns error. Motion clips (autoshort_generate_motion_clip) also return motionClip{promptSent, seed, resolution, seconds, credits} and, on failure, errorCode and creditsRefunded.

autoshort_list_niches

ChatGPT
List the content niches, art styles, video qualities and durations the generation tools accept. Free.

autoshort_list_options

ChatGPT
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.

autoshort_list_series

ChatGPT
List the user's series (autopilot channels), newest first, with schedule, auto-post flags, brief and video count. Paginated (page, limit). Free.

autoshort_list_social_accounts

ChatGPT
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.

autoshort_list_templates

ChatGPT
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", 30-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.

autoshort_list_videos

ChatGPT
List your videos, newest first, with pagination and an optional status filter (PENDING, GENERATING_SCRIPT, GENERATING_VOICE, FETCHING_MEDIA, RENDERING, COMPLETED, FAILED, DRAFT). Free.

autoshort_list_webhooks

ChatGPT
List the registered webhooks (URL, events, active, last delivery, failures). Secrets are not shown. Free.

autoshort_pause_series

ChatGPT
Pause a series: the scheduler stops making (and charging for) its videos until resumed. Videos already made are untouched. Free.

autoshort_plan_drama_season

ChatGPT
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 (30-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.

autoshort_publish_video

ChatGPT
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.

autoshort_quote_character_episode

ChatGPT
Price one PLANNED episode (30-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).

autoshort_quote_video

ChatGPT
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.

autoshort_render_draft

ChatGPT
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. 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.

autoshort_resume_series

ChatGPT
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.

autoshort_revise_scene

ChatGPT
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.

autoshort_save_season_plan

ChatGPT
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.

autoshort_select_character_image

ChatGPT
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.

autoshort_set_limits

ChatGPT
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.

autoshort_ugc_create_campaign

ChatGPT
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.

autoshort_ugc_get_campaign

ChatGPT
Read a Silent UGC campaign: character, recording, suggested hooks, and every variant with its status, preview and finished videoUrl (download). Free.

autoshort_ugc_preview

ChatGPT
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.

autoshort_ugc_render_batch

ChatGPT
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 42 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.

autoshort_ugc_suggest_hooks

ChatGPT
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.

autoshort_ugc_upload_recording

ChatGPT
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.

autoshort_update_draft

ChatGPT
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.

autoshort_update_series

ChatGPT
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.

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/autoshort"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/autoshort)