MCP App Store
by KeenEthics
Doublespeed icon

Doublespeed MCP Server for ChatGPT

By Doublespeed

Overview

Create social slideshows and product videos using your Doublespeed templates and media. Browse sample folders, pinned templates, and brand knowledge, then save editable drafts and share review links. Scoped to the Doublespeed products your account can access.

How to connect

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

Tools

browse_media

ChatGPT
Browse the media library. Operation 'list_folders' enumerates active-product folders by default, or public folders across products with visibility: public. Operation 'list_files' lists files within an active-product folder, or within a chosen public folder when product_id plus folder or folder_id are supplied. Fields that don't apply to the chosen operation are rejected.

cancel_generation

ChatGPT
Cancel one or more image or video generations that are still queued, and release their credit holds. Accepts media file IDs from generate_image, generate_images, or generate_video. A job that is already processing, completed, or failed is left as it is, and the result says why. Cancelled jobs are removed from the library and do not run. Scoped to the active product.

check_generation_status

ChatGPT
Check the status of one or more image or video generation jobs, or of queued editor renders (render_video with background: true). Returns the current status (pending, in_progress, completed, failed) and the media URL when complete. A render job id this session cannot see reads as not_found; a status read that failed reads as unknown and should be polled again.

commit_media_upload

ChatGPT
Finalize one or more media-library uploads after the file bytes have already been PUT to the SAS upload URLs from prepare_media_upload. Registers the uploaded blobs in doublespeed and returns durable media URLs you can use in drafts, posts, or save_editor_project scenes. Pass the single-file fields or a files batch. Unless probe is false, video and image files missing width/height/duration are probed server-side so the response carries real source metadata.

context_add_rule

ChatGPT
Add a content rule to the active product. Use this for a user-requested constraint on future content runs and review checks, optionally limited to specified accounts or templates. The rule becomes active immediately without a review queue. It is stored as a product rule, separately from reference wiki pages or feedback on one post. Confirm the active product before calling. This tool cannot create company-wide rules. Declines with 409 already_queued when an identical statement is waiting in the review queue with different settings, or duplicate_fingerprint when it collides with an existing rule (the response names the row and its status, including one that was previously rejected).

create_avatar

ChatGPT
Create and save an Avatar Builder portrait in the active product. This spends image-generation credits. Call get_avatar_options for current trait IDs and values. Use prompt mode for a free-text description with optional identity selections, traits mode for complete normal-avatar attributes, or crazy mode for a crazy-character trait object. The result includes avatar_id for use with generate_video. A timeout or provider error may leave the outcome uncertain. If pending_media_file_id is returned, poll check_generation_status with ids containing that ID; otherwise inspect browse_media in avatars before retrying.

create_avatar_sheet

ChatGPT
Create a contact sheet for a saved crazy avatar. This uses image-generation credits. Existing sheets are reused and concurrent pending requests are refused; each new sheet attempt can incur a charge. A timeout or error may leave the outcome uncertain, so check get_avatar_sheet before retrying.

create_content_agent_routine

ChatGPT
Schedule the content agent for the active product: a routine that fires on a recurring schedule (every few hours, daily, or on chosen weekdays) and asks for a batch of posts for the product's accounts each time. For product members, every scheduled time sends the Doublespeed team a request to write the batch; the drafts arrive as review links on the product's Content agent page (workspaceUrl in the result). Doublespeed staff choose per routine with generate_mode: "run" starts a content agent run at each scheduled time and is the staff default, "request" sends the team a request; ask a staff member which one they want when they have not said. Staff may also pin the content agent's pipeline settings for this routine (allow_new_ai_images, allow_image_detail_edits, trend_search_enabled, skip_judge_pass, use_post_learnings, qa_enabled); each one left out follows the product's content agent settings at each scheduled time. Product members leave them out. A product holds at most 5 routines, which are edited, paused, and deleted on the Content agent page. Confirm the schedule and its timezone with the person before calling.

create_image_collection

ChatGPT
Create a new image collection (a media-library folder of type 'images') for the active product. The name is slugified to lowercase with hyphens, so 'Summer Looks' becomes 'summer-looks'. Fails if a collection with that name already exists. After creating, add images with prepare_media_upload + commit_media_upload, or list collections with browse_media.

create_post

ChatGPT
Create a new slideshow or video post from media URLs. Defaults to scheduled, which queues publication to a connected account; set status to draft to save without scheduling. Provide either image_urls for a slideshow or video_url for a video post. The post is assigned to an account by username and optional platform. Externally-supplied videos are re-encoded through the iPhone metadata fingerprint by default (pass randomize_metadata: false to skip). Pass logo_url to burn a brand logo into a drifting corner of a video (video posts only; upload the logo once via prepare_media_upload/commit_media_upload and reuse its hosted URL).

create_posts_bulk

ChatGPT
Create multiple posts in bounded parallel batches, with up to 50 objects using the same fields as create_post. Each item defaults to scheduled and can publish to its connected account; use status: draft to save without scheduling. Concurrency defaults to 3 and can be set with batch_size. A completed response reports each item's success or failure. This is not an atomic operation: some posts may be created before another fails or the request times out. Check for already-created posts before retrying an interrupted batch.

create_template

ChatGPT
Create a v2 scene template for the active product. For a simple named draft, pass metadata.name (and optional metadata.prompt) and omit scene_data; the app creates a blank slide. Only send scene_data when you already have a full preview from render_slides. Omit thumbnail_url and reference_import unless you have real values. Call once; do not retry on failure. Returns the new template id; use get_template to inspect it or list_templates to rediscover it later.

delete_media_files

ChatGPT
Permanently delete files from the active product's media library: audio tracks, images or videos, including tracks in collection folders. Pass the id of each file as browse_media list_files returns it. Deletion cannot be undone: the file and its stored copy are removed, and a draft or scheduled post that still uses the file's URL can no longer load it. Only the active product's files can be deleted. An id that belongs to another product (such as a file in a public folder found with visibility: public) is refused and left untouched, and an id that matches no file is reported as not_found. Every id gets its own status in results (deleted, not_found, refused or failed), with counts, so one call can delete some files and not others.

generate_captions

ChatGPT
Transcribe a publicly fetchable HTTP(S) audio or video URL with Whisper and return word-level timings ({ word, start, end } in seconds). Feed the words to save_editor_project as captions to get editable, word-timed caption items on the editor timeline. For generated voiceovers, use the hosted audioUrl from generate_voiceover; data URI fallbacks are not supported.

generate_image

ChatGPT
Generate a single image using AI. Supports text-to-image and image-to-image modes (single reference via image_url, or up to 4 references via image_urls when the output must combine sources, e.g. recreating one scene while keeping a recurring character's identity from another image). Returns the generated image URL. Generation uses the active product's credits and requires access to image generation. Set async: true to queue generation and return a media file ID before the image is ready; poll check_generation_status with that ID. Completion time varies by model and load.

generate_images

ChatGPT
Generate multiple images from independent prompts in one call, with bounded concurrency. Returns one result per image in input order, with a URL or an error. Each generation uses the active product's credits; cost depends on the model and generation settings. Set async: true to queue generation and return media file IDs before the images are ready; poll check_generation_status with those IDs. Completion time varies by model and load.

generate_video

ChatGPT
Submit an async video generation job. Returns a media file ID to poll with check_generation_status. Videos are generated via the configured model provider and cost credits. Call list_models to see supported models, parameters, and reference pricing; the actual charge can depend on product-specific pricing rules.

generate_voiceover

ChatGPT
Generate a voiceover audio track from a script using ElevenLabs text-to-speech. Returns audioUrl and an estimated duration in milliseconds. The URL is normally hosted; if hosting fails, it can be a data URI, which generate_captions cannot accept. Use a hosted HTTP(S) URL for caption generation and editor workflows that fetch remote audio. Omit voice_id to use the default narrator voice; call with list_voices=true to see the available voices first.

get_account

ChatGPT
Get details of a specific social media account including username, bio, status, platform, and profile info.

get_avatar_options

ChatGPT
Read the Avatar Builder's current normal and crazy-character options. Use these exact values when calling create_avatar; this is read-only and does not use credits.

get_avatar_performance

ChatGPT
Read the speaking performance profile for a saved avatar. If none is stored, the route returns an editable default. This does not spend generation credits.

get_avatar_sheet

ChatGPT
Read the status and views of a saved crazy avatar's contact sheet without making one or spending credits. Normal avatars do not have contact sheets.

get_draft

ChatGPT
Fetch a draft's current state. Two modes: 1. Summary (default): compact overview of all variants with textOverlays for quick scanning. No segments or sceneData. 2. Detail (variant_index or variant_id provided): full segments, sceneData, and textOverlays for one variant. Summary mode includes addressable blocks. Slideshows: blocks (every addressable block with its current text/src, style and bounds, a variableKey that stays stable across variants, and spans for any per-word styling already applied). Videos: videoSegments (text blocks with their flat styling, image overlays, filters, framing and clips). Plus the narrower textOverlays and imageBlocks views. A block's style applies to the WHOLE paragraph. Per-word colour, bold, size, or font lives in spans on that block, not as a second overlapping block. Detail mode returns the full segments or sceneData for one variant. Every variant also carries versionId, the version its content was read from. upsert_slideshow_draft takes it back as expected_version_id when updating that variant: it proves the update was written on top of the content read here, and a full-scene update of an existing variant is refused without it. Before an update, read by groupId: it returns each variant's current version. A review-link token returns what that link shows, which can be an older pinned version whose token the update refuses.

get_hook_demo_batch

ChatGPT
One Hook + demo batch of the active product by id, with each video's status, video_url and draft_id. A batch is { id, status (waiting | queued | preparing | generating | succeeded | failed | cancelled), account_id, requested_videos, video_count, credits, error, created_at, started_at, finished_at, videos[] }; each video is { id, status (frame | cloning | finishing | succeeded | failed), reference_url, hook_text, video_url (set once succeeded), thumbnail_url, draft_id (the editor draft it was delivered to), error }.

get_post_metrics

ChatGPT
Get exact aggregate post performance for the active product across the full filtered post set in one call. Use this for totals, averages, medians, maximums, engagement, or per-account performance questions. No pagination or sampling is needed.

get_product

ChatGPT
Get a product's title, overview, brand guide, target audience, and other context. Uses product_id when the call includes it, and the connection's active product otherwise.

get_template

ChatGPT
Fetch a single v2 template by id, including template.sceneData and its variables. The result card shows its cover thumbnail. To preview a slideshow template's pages, pass template.sceneData as scene_data to render_slides. To save a derived slideshow, pass the edited scene_data and the template id as source_template_id to upsert_slideshow_draft. Video drafts require the videos and hook_demo_state inputs described by upsert_video_draft; it has no source_template_id parameter. Access is scoped to templates owned by the active product, created by the caller, or marked public.

import_media_url

ChatGPT
Copy a publicly downloadable media file (direct mp4/mov/webm/jpg/png/webp URL) into a product media folder and return its durable media URL. Use this when a product needs a stored copy of externally hosted media. The URL must serve the file bytes directly: page URLs such as YouTube or TikTok watch pages are not downloaded here. With probe_only: true it reads remote media bytes to inspect metadata (kind, width, height, duration) without saving an imported copy; use that before save_editor_project so scene trims stay inside the source and contain/blur-fill fit modes know the source aspect (pass the result as source_duration_ms, source_width, source_height).

list_account_locations

ChatGPT
List the countries this product's accounts can post from, each with its region. The country names are the valid values for update_account's location. A product without location choice lists only USA.

list_account_posts

ChatGPT
List posts for a specific account within the active product. Supports pagination, status filtering, and sort direction. Returns summary rows by default; heavy fields (scene_data, template_data, image_urls) require explicit include_* flags. Same row semantics as list_posts: posted = live (an admin session sees the stored succeeded), post_time is the requested slot (use published_at for when it went live), and public_url_status: pending_link means live but the public URL is not linked yet. Confirmed publication data stays available during pending_private/pending_delete until removal completes.

list_accounts

ChatGPT
List social media accounts for the active product. Supports pagination, status filtering, and search by username.

list_hook_demo_batches

ChatGPT
List the active product's Hook + demo batches, newest first, 20 a page. Pass next_cursor back as cursor for the next page. A batch is { id, status (waiting | queued | preparing | generating | succeeded | failed | cancelled), account_id, requested_videos, video_count, credits, error, created_at, started_at, finished_at, videos[] }; each video is { id, status (frame | cloning | finishing | succeeded | failed), reference_url, hook_text, video_url (set once succeeded), thumbnail_url, draft_id (the editor draft it was delivered to), error }.

list_models

ChatGPT
List supported image and video generation models, input requirements, capabilities, and default pricing. Prices are reference defaults; product-specific pricing rules and billing rounding may change the actual charge.

list_posting_queue

ChatGPT
Show the order the active product's queued posts will go out in, per account, with each post's expected publish time. Every scheduled post takes the account's next open slot from the scheduler (posting windows, cooldown, daily target, device gaps); this is where to see which slot a post got. scheduled_at is the locked publish time (ISO 8601, UTC) or null while the post is queued without one (queue_state: queued); estimated_at then carries the time it would get if it took a slot now, from the account's own windows and daily target. position is 1-based firing order within the account. reorderable: true marks posts whose slots reorder_posting_queue may swap. Posts mid-publish (pending) have left the queue; use list_posts for them. truncated: true means the product holds more queued posts than one listing returns; narrow with account_id.

list_posts

ChatGPT
List posts for the active product. Supports pagination, status filtering, date range, sorting, and search. Returns summary rows by default; heavy fields (scene_data, template_data, image_urls) require explicit include_* flags. Reading a row: status is the posting state (posted = live on the platform; scheduled/pending/need_approval = still queued; draft). A post whose last publish attempt failed reads as scheduled: the failure is at our posting layer and the retry is ours, not something to report as lost work. An admin session sees the stored vocabulary instead, where a live post is succeeded and a failed one failed. post_time is the requested queue slot, not when the post went live; use published_at (ISO, null until live). public_post_url is stamped by analytics reconciliation after the post is live and can trail it by hours, so public_url_status: pending_link on a posted row means live-but-not-linked-yet, not stuck. Confirmed publication data stays available during pending_private/pending_delete until removal completes.

list_products

ChatGPT
List products you have access to, and show which product is currently active for this MCP session. Supports search (case-insensitive title match) and page/page_size pagination: required on admin sessions because the full admin listing can exceed response limits. When several products share a title, each row includes duplicateCount, isPaid (has a subscription), and isEmpty (no subscription, accounts, or posts). Always pass the product_id the user named or confirmed.

list_style_presets

ChatGPT
List the canonical text style presets used by the editor (font family, weight, size, color, background, stroke, spacing, alignment). Returns each preset's name, a short description, the surfaces it may be used on (video overlay text is limited to tiktok-sans and tiktok-stroke; slideshows may use all four), and its exact style values, plus usage guidance for applying a preset via patch_draft text_block_inserts or upsert_video_draft textBlocks. These are text style presets, not hook_demo_presets. Also returns fontFamilies: the built-in families plus this workspace's uploaded custom fonts; any of them is valid in fontFamily (block, span, or emphasis).

list_templates

ChatGPT
List v2 templates (slideshow/video scene templates) discoverable from the active product. Use this to resolve a template name into a template id. For a slideshow derived from that template, pass the id as source_template_id to upsert_slideshow_draft. Returns template metadata and available preview thumbnails; call get_template to fetch template.sceneData and variables.

list_warming_profiles

ChatGPT
List the active product's warming profiles: the search terms and accounts to follow that an account warms on. Each profile carries its version and account_ids, the accounts it is on. manage_warming_profile needs that version to update, archive or assign a profile, and refuses a version someone has since changed, so read it here first. accounts lists every account with the profile it holds (null for none); warming_profile.version there is the version the account was given, which can be older than the profile's current one. Warming profiles exist only on agency products; elsewhere this returns an error.

manage_warming_profile

ChatGPT
Create, update or archive one of the active product's warming profiles, or put one on accounts. One action per call. create takes profile. update takes id, version and profile; a profile without follow_accounts keeps the saved list. archive takes id and version. assign takes assignment with account_ids, profile_id and version, and copies the profile's search terms onto those accounts without changing their status or restarting warming; profile_id: null removes the profile and needs no version. version is the profile's current version from list_warming_profiles: a profile changed since then is refused rather than overwritten, so read it again and retry. Burned and inactive accounts cannot get a profile, and an archived profile cannot be assigned. create, update and archive return no id or version; call list_warming_profiles for them. Warming profiles exist only on agency products; elsewhere this returns an error.

patch_draft

ChatGPT
Edit a variant on a draft using either a review link token or by draft group_id (exactly one). Provide either one variant_id or several variant_ids. Targeted block helpers preserve fields you do not specify; scene_data replaces the full scene. The response reports applied edits and errors; inspect it before retrying or making further changes. Edit paths: 1. Leaf fields (caption, accountId, musicLink/musicUrl, muteMusic, status) - safe to patch independently, no baseRevision needed. 2. textBlockEdits - edit existing on-screen overlay text on video or slideshow variants. Send targeted edits by blockId from the draft's textOverlays. No baseRevision needed. 3. textBlockInserts - ADD on-screen overlay text to a hook-demo video segment. Each entry needs segment_index and text. The text fills the segment's primary (first empty) text column using the site's default TikTok-style format, so it shows in BOTH the bulk-video table editor and the review link; a new column is only appended when every existing text column is already filled. Use this when you need to ADD text that does not yet exist (textBlockEdits cannot create blocks). No baseRevision needed. 4. blockEdits - change ANYTHING about a slideshow block: text, image, font size, colour, alignment, line height, letter spacing, stroke, background, padding, position, size, rotation, stacking. Send only what changes; style and bounds are shallow merged so nothing else is touched. No baseRevision needed. 5. emphasisEdits - style individual WORDS inside a slideshow text block (bold, colour, size, font) while the rest of the paragraph keeps the block style. Pick the words with a rule, never offsets: {"type":"uppercase_words"} for every fully capitalised word, or {"type":"words","words":[...]} for named ones. The rule resolves against each variant's own copy, so one call with variant_ids styles every variant at once. clear: true removes per-word styling. No baseRevision needed. 6. segmentEdits - video on-screen text and its styling, image overlays, video filters, framing, crop, canvas colour, per-clip trim and speed. Video variants only. No baseRevision needed. 7. structureEdits - add or remove blocks, and duplicate, delete or reorder slideshow pages. Positional variableKeys and pageOrder are repaired for you. Slideshow variants only. No baseRevision needed. 8. imageBlockEdits - swaps a slideshow image src only. 9. sceneData - full structure replace when a complete scene rewrite is required. Requires baseRevision when using a token; ignored for group_id. scene_data is mutually exclusive with all targeted edit helpers: text_block_edits, text_block_inserts, image_block_edits, block_edits, emphasis_edits, segment_edits, and structure_edits. Targeted helpers can be combined. status is review-link-only (drafts without a share link have no reviewer status).

patch_editor_project

ChatGPT
Change individual items in a saved editor project without resending the whole composition: retrim or move a scene, edit a headline, swap a motion clip's HTML, hide or remove an item, add a text item or motion clip, or replace the captions. Item ids come from the items index returned by save_editor_project (or include_composition). Ops apply in order; the project is re-saved and the open editor picks the change up live. Layout and timing edits are also available to the user directly in /editor; use this tool for content changes an agent makes.

prepare_font_upload

ChatGPT
Start uploading a custom font file to the active product's workspace fonts. Checks the family name, weight, style, file type and size (at most 30 MB) and the workspace limits (15 families, 10 files per family, one file per weight and style), then returns a time-limited upload URL, the headers to send with it, and a storagePath. PUT the file's raw bytes to uploadUrl with uploadHeaders, then call commit_font_upload with that storagePath as storage_path to register the font. A registered family is listed in list_style_presets and can be set as fontFamily on text. Font files sent through prepare_media_upload are stored as media and are not registered as fonts.

prepare_media_upload

ChatGPT
Prepare a media-library upload for one or more local files. This may create the requested private media folder and ensures the public-read Azure media container exists, then returns a time-limited SAS upload URL and blob path per file. Upload each file's bytes directly to its uploadUrl with an HTTP PUT, then call commit_media_upload (which also accepts a files batch) to register them and get durable media URLs. Pass file_name for a single file or files for a batch.

queue_post

ChatGPT
Create a post from a draft variant. Defaults to scheduled, which queues it for publication to its connected account; set status to draft to save without scheduling. Resolves the variant from a draft (group_id) or review link (token) and queues it using ONLY the variant's own data: caption, account, music (including the mute-music toggle set via patch_draft mute_music), and media all come from the variant itself. There are no overrides: if a required field is missing on the variant, the call fails with a clear message and the caller must edit the variant (e.g. via patch_draft) before retrying. Video variants are composed the way the bulk-video table's Queue composes them: when the stored video is only the raw source clip (the draft has overlay text or image blocks, clip trims or speed changes, a transform, crop, filter, or more than one segment), the overlays and the music track are rendered into the video server-side and that render is queued; a single-clip variant with no overlays or edits queues its stored videoUrl as is. Composing adds render time, which varies with the content and load, and the response then carries composedVideo. Slideshow variants are server-rendered from variant.sceneData at queue time. The created post is tagged with provenance (sourceVariantId / sourceVersionId / sourceGroupId) so the drafts UI links it back. Cross-product safety: the active MCP product must own the draft, except when the caller is an admin (admins can queue drafts from any product). A slideshow queued with no audio succeeds but returns a warnings entry; attach music only when requested or appropriate for the content. Scheduled posts containing #ads are rejected because this posting path cannot complete the advertising disclosure prompt. Keep required disclosures intact and use a posting flow that supports them.

rename_avatar

ChatGPT
Rename a saved avatar. The name is saved in the Avatar Builder and updates the file name in the media library. Other avatar metadata is preserved. This does not spend generation credits.

render_slides

ChatGPT
Render slideshow sceneData to slide image URLs for visual inspection. Returns slide images and hosted URLs when hosting succeeds. Does not save a draft. Supports visual iteration on slide layouts, including 1080x1920 vertical slides. Use absolute pixel coordinates for scene block layout. Style every text block by naming a preset: style.stylePreset set to a name from list_style_presets (TikTok-style slides commonly use tiktok-stroke or tiktok-bg). The renderer expands the name into the full style using the same expansion as the draft write path. Do not hand-set fontFamily, fontSize, lineHeight, letterSpacing, padding, borderRadius, or backgroundShape alongside a preset; color and bounds are the fields meant to be tuned per slide. If the preview comes back with cramped letters, overlapping lines, or unreadable text, fix the sceneData and render again before presenting it as final. To render several independent decks (for example one per variant) in a single call, pass scenes as an array of 1 to 8 { name?, scene_data } entries, or pass top-level scene_data (exactly one of the two). Results come back per scene, labelled by name, and one scene's failure does not fail the others. The same payload still includes top-level slides / hostedUrls for callers that read those fields. Treat warnings as unreadable slides and re-render before shipping. Keep every text block inside the platform safe area: on a 1080x1920 slide that is x 46-1033, y 115-1545, minus the platform UI sitting inside it (x 313-762, y 133-216; x 887-1019, y 960-1092; x 886-1020, y 1152-1316; x 887-1019, y 1358-1521). Text crossing those rects is covered by the app's own chrome once the slide is posted, so it reads as a broken slide however good the copy is. A block grows to fit its text, and a centered block grows around its center, so leave room on both sides: wide copy belongs above the action rail rather than beside it. The write boundary moves a block down or up when that is enough to clear the chrome, but it never rewrites or shrinks copy. Size the text to the room it has. Example sceneData payload for render_slides (1080x1920, all layout values in pixels): ``json { "id": "scene-1772623220885", "name": "TikTok slide preview", "pages": [ { "id": "page-1772623220885", "name": "Page 1", "width": 1080, "height": 1920, "background": "#ffffff", "blocks": [ { "id": "background", "type": "background", "bounds": { "x": 0, "y": 0, "width": 1080, "height": 1920 }, "rotation": 0, "zIndex": 0, "style": { "type": "color", "color": "#ffffff" } }, { "id": "image-1772623222845", "type": "image", "bounds": { "x": 0, "y": 0, "width": 1080, "height": 1920 }, "rotation": 0, "zIndex": 1, "src": "https://cdn.example.com/background.jpg", "style": { "objectFit": "cover", "borderRadius": 0, "opacity": 1 } }, { "id": "text-1772623231625", "type": "text", "bounds": { "x": 140, "y": 300, "width": 800, "height": 220 }, "rotation": 0, "zIndex": 2, "text": "example text", "style": { "stylePreset": "tiktok-stroke", "verticalAlign": "middle" }, "autoResize": true, "sceneWidth": 1080 } ] } ], "pageOrder": ["page-1772623220885"], "activePageId": "page-1772623220885", "defaultPageSize": { "width": 1080, "height": 1920 }, "templateMode": true } ``

render_video

ChatGPT
Render a full video composition through doublespeed's Remotion pipeline. Accepts a Remotion composition payload and returns an mp4 or webm file, or a still frame when still_at_ms is set. Pass project_id for a saved editor project, or still_at_ms to get a single PNG/JPEG frame at that time (single-frame layout check before the full render). Composition timing is millisecond-based: duration and every track item's display.from / display.to must be in milliseconds. For layout, set details.width, details.height, details.top, and details.left to match the target canvas. The text_overlay_data input is preserved as textOverlayData in the result for downstream review bookkeeping, but it does not render visible text by itself. If you want text burned into the output, include a real text track item (or another visual overlay track) inside trackItemsMap. Parameter guide: - composition.duration: total output length in milliseconds - composition.fps: output frame rate, commonly 30 for short-form social video - composition.size: final canvas size in pixels, for example { width: 1080, height: 1920 } - composition.trackItemIds: ordered track ids to render; later items visually stack above earlier ones - composition.trackItemsMap[*].display.from / .to: when that track should appear, in milliseconds - composition.trackItemsMap[*].details.src: source media URL for image/video/audio tracks - composition.trackItemsMap[*].details.width / .height: rendered box size on the canvas - composition.trackItemsMap[*].details.top / .left: rendered box position on the canvas - text_overlay_data: review metadata only, useful for bookkeeping. It does not render visible text by itself; include a real text track item for that. After render_video succeeds, do not assume the output is acceptable just because rendering finished. Review pacing, crops, text legibility, overlay placement, transitions, and artifacts before treating the result as final. If you already have structured overlay metadata, pass it as text_overlay_data so it is preserved in the result for downstream review tooling. Example composition payload for render_video: Important: duration and every display.from / display.to value are milliseconds, not frame counts. ``json { "duration": 6633, "fps": 30, "size": { "width": 1080, "height": 1920 }, "trackItemIds": ["clip-1", "text-1"], "trackItemsMap": { "clip-1": { "id": "clip-1", "type": "video", "display": { "from": 0, "to": 6633 }, "details": { "src": "https://cdn.example.com/source.mp4", "width": 1080, "height": 1920, "top": 0, "left": 0, "objectFit": "cover" } }, "text-1": { "id": "text-1", "type": "text", "display": { "from": 0, "to": 6633 }, "details": { "text": "when i ask\n\"who all gonna be there\"", "fontFamily": "TikTok Sans", "fontSize": 60, "color": "#FFFFFF", "textAlign": "center", "width": 820, "height": 360, "top": 620, "left": 130 } } } } ``

render_video_preview

ChatGPT
Render a baked preview video from editor or hook-demo style state. Burns text and image overlays into the returned video from editor-style inputs. Does not persist a draft. Parameter guide: - clips: optional timeline clips array when previewing a multi-clip edit - video_url: single source video when you do not have a clips array - video_transform: placement box for the main video layer in editor pixels - text_blocks: editable text overlays that will be burned into the preview video - image_blocks: editable image overlays that will be burned into the preview video - editor_dimensions: required canvas size object, for example { width: 1080, height: 1920 } for vertical social content - text block styling: set stylePreset to tiktok-sans or tiktok-stroke, the only two presets video overlay text may use (the filled-block presets are slideshow-only), and let the server expand it. Do not hand-set fontFamily, fontSize, fontWeight, lineHeight, letterSpacing, padding, borderRadius, or backgroundShape alongside a preset; color and placement are the fields meant to be tuned. Example render_video_preview payload for a hook-demo-style editable preview: ``json { "video_url": "https://cdn.example.com/source.mp4", "editor_dimensions": { "width": 1080, "height": 1920 }, "video_transform": { "x": 0, "y": 0, "width": 1080, "height": 1920 }, "text_blocks": [ { "id": "text-1", "text": "me after deciding\nnot to ask the one\nquestion that\nwouldve ruined the\nwhole night", "x": 140, "y": 560, "width": 800, "height": 380, "stylePreset": "tiktok-stroke", "zIndex": 10 } ] } ``

reorder_posting_queue

ChatGPT
Change the order one account's queued posts go out in. Pass the post ids in the order they should fire (first id first). The named posts keep the set of slots they currently hold and get them back in the new order, so the account's posting windows, cooldown, and daily target still hold and posts you do not name keep their times. Only posts list_posting_queue marks reorderable: true (scheduled, holding a future slot) can be named; a post firing within the next 5 minutes cannot be moved. Returns the account's queue after the change. The MCP tools cannot pin a publish time (only the posting REST API's scheduledAt can, within the account's scheduling rules); use this to change the order.

request_post_deletion

ChatGPT
Request deletion (takedown) of a post that is already live or mid-publish (status succeeded, posted, or pending). The operations team is notified and removes the post from the platform; a processed takedown cannot be undone. The post is not deleted immediately: it flips to pending_private and shows as delete-requested in the app until the takedown is processed. Draft and scheduled posts are not eligible for takedown. This tool never hard-deletes anything. If a deletion request is already open for the post, the call returns an error saying so and no duplicate request is created.

save_editor_project

ChatGPT
Assemble scene clips, motion clips (self-contained HTML+GSAP animation bundles), native text items, an optional voiceover/music track, and optional word-timed captions into an editor project saved server-side, and return an editor link. Every layer stays fully editable on the /editor timeline: each scene is its own video item (source trim, timeline placement, and canvas box each set independently), each motion clip is its own layered motion item, text items are the editor's own text blocks, audio tracks are audio items, and captions are caption items. Motion clip HTML contract: one self-contained document (inline CSS/JS, hosted asset URLs allowed; a gsap <script> CDN tag is fine), a paused seekable GSAP timeline assigned to window.__motion, window.__motionReady = true once built, deterministic output for any seeked time (use fromTo tweens, no unseeded randomness or wall-clock time), and a transparent document background unless the clip is itself the background layer, so clips overlay like transparent PNGs. Typical flow: upload or import the source (import_media_url probe_only for its duration and size) -> generate_captions on the source -> save_editor_project with scenes trimmed out of the source and captions timing=source -> render_video with project_id. Pass project_id to overwrite an existing project; use patch_editor_project to change single items without resending everything. The response is lean (ids and an item index); pass include_composition=true to also get the full composition back.

score_slideshow_copy

ChatGPT
Rank slideshow copy candidates with a learned scorer trained on this platform's real posted-slideshow outcomes (within-account winner/loser pairs, so account effects are cancelled). Send ALL candidates in ONE call: scores are relative within the submitted set only. Returns raw linear scores and score10 (10 times the mean model-implied pairwise win rate against the other submitted candidates). Small raw margins stay near 5. These predictions have not been calibrated against fixed-age or human outcomes; score10 is not confidence or a quality grade. Higher score10 means the copy pattern historically outperformed sibling posts. It judges copy only (slide texts + caption), knows nothing about brand rules or factual accuracy, and reflects patterns resembling past winners, so pair it with editorial judgment for constraints and novelty.

search_pinterest_images

ChatGPT
Find real reference photos on Pinterest. Returns raw image URLs and dimensions. Download and inspect a chosen photo, then upload it with prepare_media_upload and commit_media_upload before placing it in a draft.

set_product

ChatGPT
Select the active product used by product-scoped MCP tools. With a session, this changes that session. persist_default: true saves the account default that new sessions and connections without a session read, and saving it moves those connections. A connection without a session whose tools list product_id does not save that default unless persist_default is true. A connection without a session whose tool list has no product_id saves the default, because that is the only way the switch outlives this request, and that moves every other connection with no session. A connection whose token is scoped to one product cannot switch away from it. Call list_products to see accessible products and inspect persistedDefault in the result.

start_content_agent_run

ChatGPT
Start the content agent for specific accounts of the active product, the same as the Generate button on the product's Content agent page. The agent drafts posts for each named account from the product wiki and delivers them as review links. Returns at once with the run id: a run takes twenty minutes or more per account and spends the product's generation credits. Each call starts a new run. Progress, drafts, and review links appear on the Content agent page (dashboardUrl in the result); this tool does not return progress on repeat calls. Settings left unset follow the agent's own settings on that page. One post per account unless post_count says otherwise. Staff only: mode "request" sends the brief to the team without running the agent, and allow_image_detail_edits and trend_search_enabled pin those settings for one call.

start_hook_demo_batches

ChatGPT
Start Hook + demo video batches (the Videos page's Hook + demo format) for one or more accounts in the active product, one batch per account. Each batch copies the setup (demo video, avatars, product context, music, clone model) of an earlier Hook + demo batch: from_batch_id, or the product's newest one. Optional fields replace the copied ones. A product with no batch yet starts a new setup: every saved avatar (get_avatar_options), the brand brief as product context, no demo, and 5 videos; send reference_links, and avatar_ids or product_context when the product has none. For a demo video, import it with import_media_url and pass its fileId as demo_video_id, or pass a direct video URL as demo_video_url. Same checks and credit charge as Generate on the Videos page; batches of the product run one after another, so later ones wait (status waiting). Finished videos land as drafts on their account. Poll get_hook_demo_batch or list_hook_demo_batches for progress. A result with code no_fresh_pairs means every clip and avatar pair is already used: add reference_links or avatars. A batch is { id, status (waiting | queued | preparing | generating | succeeded | failed | cancelled), account_id, requested_videos, video_count, credits, error, created_at, started_at, finished_at, videos[] }; each video is { id, status (frame | cloning | finishing | succeeded | failed), reference_url, hook_text, video_url (set once succeeded), thumbnail_url, draft_id (the editor draft it was delivered to), error }.

update_account

ChatGPT
Update fields on a social media account. Only provide the fields you want to change. Bio has a 160 character limit.

update_avatar_performance

ChatGPT
Set an avatar's speaking presentation and voice direction. This is a manual profile edit and does not spend generation credits. Read the current profile with get_avatar_performance first if you need to preserve its settings.

update_post

ChatGPT
Update a post's caption, status, or account assignment. Caption and account edits work on draft, scheduled, and pending posts, and on one whose last publish attempt failed (it reads as scheduled, and the retry is ours). Reassigning a queued post that holds no fire time gives it the new account's next open slot; the result reports scheduledAt, or scheduleReason queued while it waits for one (pick_failed or trigger_failed when scheduling itself failed). Status changes are draft to scheduled and scheduled to draft only: moving to draft clears the fire time, and re-queueing assigns a new future slot for publication. Caption or account changes may already be saved if a later scheduling step fails; inspect the returned error before retrying.

update_product

ChatGPT
Update fields on the currently active product. Only provide the fields you want to change.

upsert_slideshow_draft

ChatGPT
Create or update a slideshow draft backed by sceneData: save the slideshow so the user can review, edit, and post it. Persists slideshow sceneData into the draft system (variant_group). Optional create_share_link: true returns a review URL in the same call. Does not render slide images. Parameter guide: - scene_data: the normal single-draft path; persist the slideshow structure to save - variants: advanced multi-variant slideshow input when you want one draft containing several slideshow variants - group_id: omit to create a new draft, include to update an existing slideshow draft (variant_group) - variants[].expected_version_id: on an update, every variant you send with a variant_id must carry the versionId get_draft reported for it. That token is what proves your scene_data was built on the content currently stored; a full-scene update of an existing variant is refused without it, and a moved version answers 409. Call get_draft with the group_id immediately before the update (a review-link token can return an older pinned version), edit the scene it returns, and send that variant's token back. Never carry a token over from an earlier read or invent one. - variant_id + expected_version_id (top level): the same pair for an update through the single scene_data path; an update of an existing draft through scene_data is refused without them. - source_template_id: id of the template the slideshow started from (list_templates / get_template); pass it whenever the sceneData began as a template so lineage is preserved. Agent runs are held to this: when the product has templates, a new draft without source_template_id is rejected, and the persisted sceneData must be the referenced template's sceneData edited in place, not a rebuilt lookalike. Enforced per text block: keep the template's fontFamily, fontWeight, fontSize, lineHeight, and letterSpacing exactly as fetched; change only text content and image sources, and tune only color and bounds per slide. - text block styling: set style.stylePreset to a canonical name from list_style_presets and let the server expand it. Any field you also set overrides the preset, so restating the preset's own values (fontFamily, fontSize, lineHeight, letterSpacing, padding, borderRadius, backgroundShape) is how drafts drift into a look that matches no preset. Tune color and bounds per slide, and use the same preset across every slide of one slideshow. - preview_image_urls: optional composed slide preview URLs to attach to the saved card; when omitted, the card best-effort harvests one allowlisted source image per page from the first variant's sceneData (not composed renders) - create_share_link: defaults to false. Set true to return an existing link or create a new one; a new link without a password is accessible to anyone who has its URL - caption: optional override for the single-scene path; defaults to scene_data.caption when present Keep every text block inside the platform safe area: on a 1080x1920 slide that is x 46-1033, y 115-1545, minus the platform UI sitting inside it (x 313-762, y 133-216; x 887-1019, y 960-1092; x 886-1020, y 1152-1316; x 887-1019, y 1358-1521). Text crossing those rects is covered by the app's own chrome once the slide is posted, so it reads as a broken slide however good the copy is. A block grows to fit its text, and a centered block grows around its center, so leave room on both sides: wide copy belongs above the action rail rather than beside it. The write boundary moves a block down or up when that is enough to clear the chrome, but it never rewrites or shrinks copy. Size the text to the room it has. Example upsert_slideshow_draft payload that keeps a slideshow editable and reviewable as sceneData: ```json { "draft_name": "musicluvr20 artists i always come back to", "create_share_link": true, "scene_data": { "id": "scene-musicluvr20-20260408-01", "name": "musicluvr20 artists i always come back to", "pages": [ { "id": "page-cover", "name": "Cover", "width": 1080, "height": 1920, "background": "#111111", …

upsert_video_draft

ChatGPT
Create or update an editable video draft backed by bulk-video table (hook-demo) state. Persists editable text, segments, and overlays in the bulk-video table (/{productId}/bulk-video/table). Optional create_share_link: true returns a review URL in the same call. Parameter guide: - group_id: omit to create a new draft, include to update an existing draft (variant_group) - videos: review rows for the draft. For editable reviews, this is the base video that the review page plays behind the saved overlays, not a baked preview file - hook_demo_state: required editable source of truth for rows, segments, text blocks, and image blocks - hook_demo_state.table_rows[*].segments[*].externalVideoUrl: the source clip URL that the bulk-video table should reopen on edit - editor_dimensions: optional editor canvas size used to normalize editor-pixel text/image blocks into hook-demo's stored 0-1 coordinate system - videos[*].music_link: the sound to post with, as a TikTok sound link for TikTok accounts or an Instagram audio link for Instagram accounts. Do not upload or extract an audio file and pass it as music_url: drafts reject it, because the phone cannot open a file as a sound - text blocks accept stylePreset, which on a video must be tiktok-sans or tiktok-stroke; those are the only two presets allowed on video overlay text, and any other name is rejected (the filled-block presets are slideshow-only). The preset fills in style fields and any explicit field on the block overrides it. Name the preset; hand-writing fontFamily, fontSize, fontWeight, lineHeight, letterSpacing, padding, borderRadius, or backgroundShape is how drafts end up matching no preset. Tune color and placement per block, and use the same preset across every segment of one video. - create_share_link: set to true when you want reviewUrl and shareLink returned immediately - password: optional password for a newly created review link when create_share_link is true; does not change an existing link's password This tool will normalize editor-style pixel blocks into hook-demo's persisted normalized block schema before saving. Example upsert_video_draft payload that keeps the video editable in the bulk-video table: ``json { "draft_name": "saintdairy internal fight walk", "editor_dimensions": { "width": 1080, "height": 1920 }, "create_share_link": true, "videos": [ { "video_url": "https://cdn.example.com/source.mp4", "caption": "me after deciding not to ask the one question that wouldve ruined the whole night", "segments": [ { "videoUrl": "https://cdn.example.com/source.mp4", "textBlocks": [ { "id": "text-1", "text": "me after deciding\nnot to ask the one\nquestion that\nwouldve ruined the\nwhole night", "x": 140, "y": 560, "width": 800, "height": 380, "stylePreset": "tiktok-stroke" } ] } ] } ], "hook_demo_state": { "segment_count": 1, "table_rows": [ { "id": "row-1", "segments": [ { "id": "segment-1", "externalVideoUrl": "https://cdn.example.com/source.mp4", "textBlocks": [ { "id": "text-1", "text": "me after deciding\nnot to ask the one\nquestion that\nwouldve ruined the\nwhole night", "x": 140, "y": 560, "width": 800, "height": 380, "stylePreset": "tiktok-stroke" } ] } ] } ] } } ``

whoami

ChatGPT
Returns your identity, permissions, and the currently active product for this MCP session.

wiki_get_page

ChatGPT
Read one wiki page by slug for the active product (its reference knowledge). Read the pages that cover the task (overview first when present, then brand and voice, formats, learnings, the account's accounts/<handle>/persona page) before creating content; rules are not wiki pages, they live on the product Rules page. Returns the page metadata, current revision (send its rev as base_rev when editing), and rendered segments (markdown runs plus managed directive blocks resolved live). A slug not visible in the caller's scope is reported as not found.

wiki_list_pages

ChatGPT
List the active product's wiki pages: its reference knowledge (overview, brand and voice, formats, asset locations, decisions, learnings, one accounts/<handle>/persona page per account). Rules are not pages; they live on the product Rules page. Call this once after set_product and read the relevant pages with wiki_get_page before content work. Each entry carries slug, title, visibility, current revision number, generation/review flags, and sections (level-2 headings). Product members edit wiki pages in the dashboard. Staff sessions see the product's own pages plus company-wide (all_products) pages; a client session sees only the pages published to it (visibility client).

Capabilities

WritesInteractive

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/doublespeed"><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/doublespeed)