arcads_add_competitors
ChatGPTAdd competitor brands to track for one of the user's brands, and start collecting their ads from public ad libraries. Call this after the user has named their competitors — never with names you guessed yourself. Adding a competitor that is already tracked replaces its url and angle with the values passed. There is no remove tool: removal is done in the Arcads app. Collection keeps running in the background, so the ads are not available the instant this returns; call arcads_list_competitor_ads and its widget will show them as they arrive. Args: - competitors (array, required): each with a name, and optionally a url and an angle (what they are known for) - productId (string, optional): UUID of the brand (auto-selected when the workspace has only one)
arcads_add_subtitles
ChatGPTBurn subtitles or captions onto a video using the Arcads API. The local file is uploaded automatically. Choose a style from the full catalogue — the right backend is selected automatically: • Text overlay : insta-dark | insta-light | insta-none | tiktok-dark | tiktok-light | tiktok-none • Basic captions : style_1 | style_2 | style_3 • Styled subtitles: glass | whisper | glide | glide2 | fusion | terminal | handwritten The text overlay styles are the same pills arcads_add_text_overlay draws, timed to the speech, so captions match the hand-typed overlays in the same ad. They are the ones to pick when the placement matters (position, textAlign, margin all apply) or when the words may need correcting afterwards: the cues come back on the asset, and passing them back re-renders without transcribing again. Args: - productId (string, optional): auto-selected if you only have one - videoPath (string): S3 path of the video — OR use sourceVideoAssetId - sourceVideoAssetId (string): UUID of an existing Arcads video asset - style (string, required): one of the sixteen styles listed above - position: honoured by the text overlay AND styled subtitle styles; the basic styles place their own - textAlign, margin, maxWordsPerSegment: text overlay styles only; the other backends lay out and time their captions themselves. No backend but ours takes a text size - segments: honoured by the text overlay AND styled subtitle styles — pass a corrected cue list to caption those exact words. The basic styles ignore it and always transcribe Returns: Asset id. The inline widget polls and displays the result automatically. Processing typically takes ~1–2 minutes (~30s for text overlay styles). Once ready, arcads_get_asset lists the burned-in cues with their time windows.
arcads_add_text_overlay
ChatGPTBurn styled text onto a video or image using the Arcads API. For captions/subtitles, use arcads_add_subtitles instead. The local file is uploaded automatically — no need to call arcads_upload_media first. Args: - productId (string, required): UUID of the product to associate with - mediaPath (string, required): Local file path or S3 path of the video or image - text (string, required): The text to display - mediaType ('video'|'image', default 'video'): Whether the input is a video or image - style (string, default 'insta-dark'): Visual style of the text pill 'insta-dark' | 'insta-light' | 'insta-none' — Instagram style 'tiktok-dark' | 'tiktok-light' | 'tiktok-none' — TikTok style '-none' variants have no background/pill - start (number, default 0): When the text appears, in seconds from the start of the video - duration (number | 'full-video', default 3): How long the text is visible, in seconds, or 'full-video' for persistent text. Always use 'full-video' for images - position ('top'|'center'|'bottom', default 'top'): Vertical placement — top, center or bottom of the frame (of the margin area when one is set) - textAlign ('left'|'center'|'right', default 'center'): Horizontal alignment — left, center or right (within the margin area when one is set) - margin (object, optional): Override for where the text sits: { left, right, top, bottom }. Leaving it out is the right choice for a normal caption — position and textAlign on their own place the text at the style's own distance from the edge, which already clears the platform UI (roughly 15-23% of the height at the top and bottom of a vertical canvas). Set a side to satisfy a placement that was actually asked for, e.g. "5% from the top", "on the left half", "clear of the product in the lower third". Each side is a fraction of the canvas (0-1) measured inward from that edge — left/right of the width, top/bottom of the height — and marks the edge of the area the text lives in: position and textAlign align the text inside that area, and it caps the text width, so long text wraps instead of running past the margin. Sides left out keep their default. A margin is a placement instruction rather than padding: a small value on every side (e.g. 0.08) puts the text CLOSER to the edges than the default does. To land text on an exact spot, pair the side with the matching alignment — then the margin IS the text's own edge: textAlign 'left' + margin.left puts the first glyph at that x, position 'top' + margin.top puts the top of the text at that y, and so on for right/bottom. The centered forms instead center the text in the room that is left, so textAlign 'center' lands its middle at (left + (1 - right)) / 2. Defaults when margin is omitted, as fractions of a 9:16 canvas: 0.21 top / 0.21 bottom for the insta- styles, 0.15 top / 0.23 bottom for tiktok-*, 0.06 each side (0.08 when centered); on 1:1 and 16:9 the vertical defaults are about 0.06 top / 0.11 bottom. Example — "at the bottom, centered, no wider than 40%": position 'bottom', textAlign 'center', margin { "left": 0.3, "right": 0.3, "bottom": 0.15 } - fontSize (number, optional): Text size on an editor scale where 16 is the default; omit it to use the style's built-in size. Glyph height is fontSize/480 of the canvas height (16 ≈ 3.3%, 24 ≈ 5%, 32 ≈ 6.7%), each line takes ~4% of the height at 16, and a character averages 0.55 × the font size wide — so at 16 a line holds roughly 27 characters across the full default width of a 9:16 canvas. Returns: Asset id and status. The inline widget polls and displays the result automatically. Processing typically takes ~1 minute.
arcads_analyze_media
ChatGPTHave Gemini listen to or watch media in motion: judge a voice (accent, age, tone, delivery), music or audio quality, lip sync, motion artifacts, pacing across a whole video, or read long documents. To look at an image or at frames of a video yourself (on-screen text, spelling, product fidelity, framing, comparing variants), use arcads_view_contact_sheet (many frames of a video) or arcads_view_frame (one frame, or an image): they return the pixels to you directly in seconds. Local file paths are uploaded automatically — no need to call arcads_upload_media first. Multiple media types can be combined in a single call. Args: - productId (string, required): UUID of the product to associate with - prompt (string, required): Question or instruction for the AI (e.g. "Describe this video scene by scene") - referenceImages (array of strings, optional): Local paths or S3 paths — up to 10 images - referenceVideos (array of strings, optional): Local paths or S3 paths — up to 3 videos - referenceAudios (array of strings, optional): Local paths or S3 paths — up to 1 audio file - referenceDocuments (array of strings, optional): Local paths or S3 paths — up to 10 documents Returns: The AI text response appears in data.generatedText on the structured output. The inline widget polls the asset and displays the response automatically. Processing typically takes ~1 minute.
arcads_animate_image
ChatGPTAnimate, move, bring to life, or add motion to a still image, photo, or picture, using a reference video that demonstrates the motion. Covers any request to animate a static image, turn a photo into a video, make a picture move, add gesture / movement / camera motion to an image, or replace the subject in a motion reference with the one from a still. Only use footage, photos or voices of people who have consented to this use, such as the user themselves, their own actors, or Arcads stock actors. Two input files: a still image (the subject) and a short reference video (the motion to apply). Both are uploaded automatically from local paths or HTTP/HTTPS URLs. Models: - kling30-animate (default): Kling 3.0 motion transfer - kling-animate: Kling legacy - wan22_animate: WAN 2.2 — supports 'move' (apply motion to subject) and 'replace' (swap subject in reference video) Args: - productId (string, optional): UUID of the product — auto-selected if you only have one - imagePath (string, required): Path or URL of the image to animate - videoPath (string, required): Path or URL of the reference motion video - model ('kling30-animate'|'kling-animate'|'wan22_animate', default 'kling30-animate') - mode ('move'|'replace', only for wan22_animate) Returns video asset id. The inline widget polls and displays the result automatically. Processing typically takes 7–18 minutes depending on model.
arcads_animate_image_kling
ChatGPTAnimate a static image using the classic Kling Animate model via Arcads. Only use footage, photos or voices of people who have consented to this use, such as the user themselves, their own actors, or Arcads stock actors. Guides the motion in the output video using a reference video as a motion template. The reference image content is animated to follow the motion pattern of the reference video. Note: For the newer Kling 3.0 Animate, use arcads_animate_image instead. Args: - productId (string, optional) - referenceImages (string[], required): Exactly 1 image to animate (S3 path or URL). Max 50 MB, 300–3850 px. - referenceVideos (string[], required): Exactly 1 video as the motion template (S3 path or URL). Max 100 MB, 3–30 s. Returns: Video asset id. The inline widget polls and displays the result automatically. Processing typically takes ~30–90 seconds.
arcads_animate_image_wan22
ChatGPTAnimate a static image using the Wan 2.2 model via Arcads. Only use footage, photos or voices of people who have consented to this use, such as the user themselves, their own actors, or Arcads stock actors. Two modes are available: - move: Animate the image so the subject moves naturally following the reference video motion. - replace: Replace the actor/subject in the reference video with the person from the reference image. Args: - productId (string, optional) - referenceImages (string[], required): Exactly 1 source image (S3 path or URL). Max 50 MB, 300–3850 px. - referenceVideos (string[], required): Exactly 1 motion/template video (S3 path or URL). Max 100 MB, 3–30 s. - mode (string, required): 'move' — animate the image | 'replace' — replace the actor in the video Returns: Video asset id. The inline widget polls and displays the result automatically. Processing typically takes ~30–90 seconds.
arcads_audio_driven
ChatGPTGenerate a talking-head video by driving an actor with a script (TTV) or an audio file (STS). For situation + script with Studio-default fidelity, prefer arcads_generate_talking_actor (model arcads_1.0). Use this tool for custom actor sources (referenceImages, sourceVideoAssetId). Only use footage, photos or voices of people who have consented to this use, such as the user themselves, their own actors, or Arcads stock actors. Local file paths and HTTP/HTTPS URLs for referenceAudios and referenceImages are handled automatically. If the MCP runs remotely (Docker/cloud), local paths will fail — use a public URL instead (upload with: curl -s -F "reqtype=fileupload" -F "fileToUpload=@/path" https://catbox.moe/user/api.php). Actor source — pick exactly one: - situationId: Use a predefined Arcads actor/situation - sourceVideoAssetId: Use an actor from an existing video asset (UUID) - referenceImages: Use a custom actor sourced from an image (1 image) Audio source — pick exactly one: - script: Text-to-video (TTV) — Arcads synthesises the voice from the script - referenceAudios: Speech-to-speech (STS) — drives the actor with the provided audio (1 file) Valid combinations: | Actor source | Audio source | Notes | |--------------------|-----------------------|------------------------------------| | situationId | script (TTV) | voiceId optional | | situationId | referenceAudios (STS) | voiceId optional | | sourceVideoAssetId | script (TTV) | voiceId required | | sourceVideoAssetId | referenceAudios (STS) | voiceId required | | referenceImages | script (TTV) | voiceId required | | referenceImages | referenceAudios (STS) | voiceId required | Args: - productId (string, required) - situationId (string, optional): Predefined actor/situation ID — call arcads_list_situations first to find one - sourceVideoAssetId (string, optional): Existing video asset UUID to source the actor from - referenceImages (array of 1 string, optional): S3 path of the actor image - script (string, optional): Script for TTV mode - referenceAudios (array of 1 string, optional): S3 path of the audio for STS mode - autoAddScriptEmotion (boolean, optional): Let Arcads inject emotions into the script (TTV only) - voiceId (string, optional): Voice ID — required when using sourceVideoAssetId or referenceImages - audioSettings (object, optional): Fine-grained voice settings (speed, stability, similarityBoost, style, useSpeakerBoost) Returns: Asset id and status. The inline widget polls and displays the result automatically. Processing typically takes ~7 minutes.
arcads_camera_angle
ChatGPTAdjust the camera angle of an image with horizontal, vertical, and zoom controls. Processing typically takes ~30 seconds.
arcads_camera_movement
ChatGPTAdd cinematic camera movements to your avatar videos with AI-powered motion presets. Call arcads_list_situations with contentType='camera_movement' to find available situationIds. Processing typically takes ~4 minutes.
arcads_change_speed_audio
ChatGPTChange the playback speed of an audio file — slow it down or speed it up. Supports speeds from 0.5× (half speed) to 2× (double speed). Max input: 500 MB, 30 minutes. Args: - productId (string, optional) - audioPath (string, required): S3 path or URL of the source audio - speed (number, required): Speed multiplier between 0.5 and 2.0 (e.g. 0.5 = slow-mo, 2 = 2× speed) Returns: Audio asset id. The inline widget polls and displays the result automatically. Processing typically takes ~5–10 seconds.
arcads_change_speed_video
ChatGPTChange the playback speed of a video — slow it down or speed it up. Supports speeds from 0.5× (half speed) to 2× (double speed). Max input: 500 MB, 30 minutes. Args: - productId (string, optional) - videoPath (string, required): S3 path or URL of the source video - speed (number, required): Speed multiplier between 0.5 and 2.0 (e.g. 0.5 = slow-mo, 2 = 2× speed) Returns: Video asset id. The inline widget polls and displays the result automatically. Processing typically takes ~5–15 seconds.
arcads_change_voice
ChatGPTReplace the voice track in a video with a different voice using the Arcads API. The local file is uploaded automatically. Args: - productId (string, required) - videoPath (string, required): S3 path - voiceId (string, required): Target voice ID Returns: Video asset id. The inline widget polls and displays the result automatically. Processing typically takes ~30 seconds.
arcads_create_brand
ChatGPTCreate a new brand in your Arcads workspace. Users may still call a brand a product — treat that as the same account. The returned id is the productId generation tools expect. Args: - name (string, required): Brand name, at least 2 characters - description (string, optional) - targetAudience (string, optional) - mainFeatures (string[], optional) - painPoint (string, optional) - perceived (string, optional) Returns: The created brand: id, name, and any provided fields.
arcads_create_music
ChatGPTCompose an original music track from a written description, at a chosen length. Use lyrics written or owned by the user; do not copy existing songs or imitate an artist's voice. Use it for the background bed of an ad, a hook sting, or any soundtrack the workspace does not already have. Instrumental by default, which is what a track sitting under a voiceover wants; set instrumentalOnly to false to let it sing. Two models: - elevenlabs (default): writes exactly the requested length, 3–600s. The one for a bed laid under a video, so the track ends on the last frame. Credits scale with duration; ready in ~10–15 seconds. - suno_v6: the richest, most musical tracks, and the one that sings your own lyrics. Its length is a target (20–360s) that the track can overshoot, so reach for it when the user asks for Suno, a standalone song, or sung lyrics. A flat 10 credits for up to two tracks; ready in ~1–2 minutes. Describe the music itself — genre, mood, instrumentation, tempo, key, energy and how it evolves ("warm lo-fi hip-hop, mellow Rhodes and soft vinyl crackle, 80 BPM, lifting slightly in the last third"). Name the sound rather than its source: "blockbuster superhero score" carries the brief that "Marvel-style" does, and "gritty analog synthwave" the one that "like Stranger Things" does. Musical terms are what get through — the upstream provider rejects a prompt that asks for the sound of a named work, artist, band, film, franchise, game or brand, and the whole call fails. Match duration to the video the track plays under, so the bed runs to the last frame. When a generation comes back rejected, rewrite the prompt in purely musical terms — drop the named reference first, then any "sounds like" or "in the style of" phrasing — and re-run with the new wording. To put the finished track under a video, pass the video as the background to arcads_layer_videos with backgroundVolume set for the mix, and the music as a layer. Args: - productId (string, optional): UUID of the brand — auto-selected if you only have one - prompt (string, required): Description of the music to compose - model (string, optional): elevenlabs (default) or suno_v6 - duration (integer, optional): Track length in seconds (default 60) — exact with elevenlabs, a target with suno_v6 - instrumentalOnly (boolean, optional, default true): Keep the track wordless; false allows vocals - lyrics (string, optional): Words to sing, with suno_v6 and instrumentalOnly false Returns: Audio asset id. The inline widget polls and displays the result automatically.
arcads_extend_video
ChatGPTExtend a video by generating additional continuation footage using the Arcads API. The local files are uploaded automatically. Two models continue the video: - omni_flash (default): Omni Flash 1.1, the continuation to use for a plain extend. Adds 3–10s. Processing typically takes ~2 minutes. - seedance_25: Seedance 2.5, for a continuation that brings in a product, a character or a place from reference images, or that runs 4–30s. It keeps the source's shape and delivers a silent video. Processing typically takes ~5 minutes. Args: - productId (string, required) - videoPath (string, required): S3 path of the video to extend - prompt (string, required, min 10 chars): Description of how to extend the video - model ('omni_flash'|'seedance_25', optional): Model that continues the video - aspectRatio ('16:9'|'9:16'|'auto', optional): Output aspect ratio (omni_flash) - referenceImages (string[], optional): Images the continuation keeps consistent (seedance_25) - duration (4–30, optional): Seconds of new footage (seedance_25) - resolution ('480p'|'720p'|'1080p', optional): Output resolution (seedance_25) Returns: Asset id. The inline widget polls and displays the result automatically.
arcads_gameplay_ad
ChatGPTCreate engaging gameplay ad videos with AI actors overlaid on your gameplay footage. Requires an Arcads situationId (actor). Call arcads_list_situations with contentType='talking_actor' to find available situationIds. Processing typically takes ~16 minutes.
arcads_generate_image
ChatGPTGenerate an image using a textual description. IMPORTANT: Use ALWAYS this tool when the user ask to create/generate/produce an image. Args: - productId (string, required): UUID of the product to associate with - prompt (string, required): Description of the image to generate - model (string, default 'nano-banana'): Image model to use 'nano-banana', 'nano-banana-2', or 'nano-banana-2-1' — fast, general purpose; nano-banana-2-1 is Nano Banana 2.1, the strongest editor 'gpt-image' or 'gpt-image-2' — OpenAI GPT image (supports reference images, up to 5) 'gpt-image-2-5-flare' or 'gpt-image-2-5-sunburst' — GPT Image 2.5; edits change only what the prompt names. Flare is the fast default, Sunburst trades speed for tighter control across successive edits 'seedream', 'seedream_5_lite' or 'seedream_5_pro' — Seedream (5 Pro = highest quality, slower) 'grok_image' — Grok image - aspectRatio ('1:1'|'16:9'|'9:16', default '1:1'): Output aspect ratio - referenceImages (array of strings, optional): Local file paths or S3 paths (up to 14; gpt-image supports up to 5) - referenceVideos (array of strings, optional, nano-banana-2-1 only): Up to 10 local video files, S3 paths, or public YouTube URLs. Combined length up to 25 minutes. The model reads frames and ignores audio. - nbGenerations (integer 1–10, default 1): Number of variants Returns: Asset id(s) and status. The inline widget polls each id and displays the results automatically. Processing typically takes ~1 minute.
arcads_generate_image_gpt
ChatGPTOpenAI's image model with precise control, preserved details, and ultra-fast speed. Use model='gpt-image-2-5-flare' for the latest generation, where an edit changes only what the prompt names, or 'gpt-image-2-5-sunburst' for tighter control across successive edits. Processing typically takes 1–3 minutes.
arcads_generate_image_grok
ChatGPTGenerate images with xAI Grok. Supports text-to-image and editing with one reference image. Processing typically takes ~15 seconds.
arcads_generate_image_nano_banana
ChatGPTOutstanding and realistic images from prompt and references; also works for image editing. Use model='nano-banana-2-1' (Nano Banana 2.1) for the strongest edits (up to 14 reference images, 1K–4K, thinking level, optional search grounding). model='nano-banana-2' is the previous generation. Processing typically takes ~1 minute.
arcads_generate_image_seedream
ChatGPTHigh-resolution visuals with strong character and product consistency. Use model='seedream_5_lite' for up to 4 references and faster generation, or model='seedream_5_pro' for the highest-quality Seedream 5 (slower). Processing typically takes ~1 minute.
arcads_generate_image_ugc_studio
ChatGPTGenerate high-quality influencer-style images with AI. Text-to-image only — no reference images supported. Processing typically takes ~1 minute.
arcads_generate_talking_actor
ChatGPTPrimary tool for talking-head UGC from Arcads situations (catalog actors). Default model is `arcads_1.0` — same as Studio — for maximum fidelity to the selected situation's reference performance. Use audio_driven or omnihuman only when the user asks for those models. Audio vs script (pick exactly one) - script — text-to-video (TTV). Works with all models (arcads_1.0, audio_driven, omnihuman). - referenceAudios — speech-to-speech (STS), one audio file. Only audio_driven or omnihuman — never arcads_1.0. Args - model (default arcads_1.0) - productId (optional — auto-selected when the workspace has one brand) - actors — array of { situationId, voiceId? } (one entry per actor; same script for all) - autoAddScriptEmotion (optional, TTV only) - projectId (optional — omit to use a dedicated API project) For a custom actor from an image or existing asset (not a situation), use arcads_audio_driven or arcads_omnihuman instead. Processing time varies by model (~minutes). The inline widget polls and shows the video when ready.
arcads_generate_video_grok
ChatGPTxAI's Grok model with text-to-video and image-to-video modes. Processing typically takes ~2 minutes.
arcads_generate_video_grok_imagine_15
ChatGPTxAI Grok Imagine 1.5 — image-to-video from exactly one reference image plus a prompt (not the same as arcads_generate_video_grok text-to-video). Pass that image as referenceImages with a single path. Duration 1–15 seconds at 480p or 720p. Processing typically takes ~4 minutes.
arcads_generate_video_happy_horse
ChatGPTAlibaba's unified model with native joint audio-video synthesis and multilingual lip-sync. Processing typically takes ~4 minutes.
arcads_generate_video_kling_26_pro
ChatGPTCreate high-fidelity video clips with complex movement and realistic transitions. Processing typically takes ~3 minutes.
arcads_generate_video_kling_30
ChatGPTKling 3.0 — text-to-video or image-to-video with an optional start and end frame, 3–15 seconds, up to 10 variants per call. Aspect ratios: '9:16' (TikTok, Reels, Shorts), '16:9' (YouTube), '1:1' (Instagram). Local file paths and HTTP/HTTPS URLs for startFrame / endFrame are uploaded automatically. Distinct from arcads_generate_video_kling_30_pro (higher-fidelity Pro tier). Processing typically takes ~3 minutes.
arcads_generate_video_kling_30_4k
ChatGPTGenerate 4K Kling videos with configurable audio and style scale control. Processing typically takes ~4 minutes.
arcads_generate_video_kling_30_pro
ChatGPTCreate high-fidelity video clips with complex movement and realistic transitions. Local files uploaded automatically. Processing typically takes ~3 minutes.
arcads_generate_video_kling_30_pro_turbo
ChatGPTKling 3.0 Pro Turbo — fast, high-fidelity text-to-video or image-to-video (optional start frame). Distinct from arcads_generate_video_kling_30_pro (standard Kling 3.0 Pro tier). Prompt up to 3072 characters. Duration 3–15 seconds. Processing typically takes ~3 minutes.
arcads_generate_video_minimax_h3
ChatGPTThe cheapest video model here per second, with stylised cinematic motion and strong prompt adherence, up to 15 seconds and up to 4K. Only use footage, photos or voices of people who have consented to this use, such as the user themselves, their own actors, or Arcads stock actors. Takes a start frame (and an optional end frame) for keyframe control, or reference images/videos/audio (up to 12 combined) to carry a subject, motion and voice into the shot — any mix works, reference audio alone with just a prompt included; references and startFrame are separate modes, so pick one per generation. H3 Max takes the same references with a better look at a higher price; H3 Max and H3 Max Turbo both stop at 720p, and Turbo takes no references. Generates native synchronized audio inside the clip — dialogue plus ambient sound and effects. Local files uploaded automatically. Processing typically takes ~2 minutes.
arcads_generate_video_minimax_h3_max
ChatGPTA post-trained MiniMax H3, tuned for stronger prompt adherence and better aesthetics and generated faster — and priced above H3 for it. Renders natively only, so it stops at 720p. Only use footage, photos or voices of people who have consented to this use, such as the user themselves, their own actors, or Arcads stock actors. Reach for it over H3 when the look matters more than the cost and 720p is enough. H3 (arcads_generate_video_minimax_h3) takes the same references at the lowest price; use this one when references need the post-trained look. Use H3 Max Turbo (arcads_generate_video_minimax_h3_max_turbo) when they name Turbo — same look, cheaper and faster, but no reference support. Takes a start frame (and an optional end frame) for keyframe control, or reference images/videos/audio (up to 12 combined) to carry a subject, motion and voice into the shot — any mix works, reference audio alone with just a prompt included; references and startFrame are separate modes, so pick one per generation. Generates native synchronized audio inside the clip — dialogue plus ambient sound and effects. Local files uploaded automatically. Processing typically takes ~1 minute.
arcads_generate_video_minimax_h3_max_turbo
ChatGPTA post-trained MiniMax H3, the same family as H3 Max: stronger prompt adherence and better aesthetics than H3, generated at higher throughput and priced below H3 Max. Renders natively only, so it stops at 720p and takes no reference images. Use it only when the user names H3 Max Turbo (or MiniMax Turbo) — it is not the default video model. Stay on H3 for the cheapest clip, for 1080p or 4K, or to carry reference images, video or audio into the shot at the lowest price; stay on H3 Max for those references with the post-trained look, or when they name that one. Takes a start frame (and an optional end frame) for keyframe control. Generates native synchronized audio inside the clip. Always generates at 720p. Local files uploaded automatically. Processing typically takes under a minute.
arcads_generate_video_omni_flash
ChatGPTCreate or edit video through a single prompt with Gemini Omni Flash. Text-to-video, image-to-video (pass referenceImages, up to 3), reference-to-video, conversational editing of existing clips (pass referenceVideos, up to 3), or first/last-frame conditioning (pass startFrame, optionally with endFrame). Optionally set aspectRatio, resolution and duration — omit for the model to auto-pick. Processing typically takes ~2 minutes.
arcads_generate_video_seedance_15
ChatGPTByteDance's fast video model with 4–12 second duration and audio support. Processing typically takes ~4 minutes.
arcads_generate_video_seedance_20
ChatGPTByteDance's fast video model with 4–15 second duration, audio support, and multi-reference inputs. Processing typically takes ~7 minutes.
arcads_generate_video_seedance_20_mini
ChatGPTByteDance Seedance 2.0 Mini — faster, lower-cost Seedance 2.0 tier with 4–15 second clips, optional native audio, and reference images/videos/audio (same caps as Seedance 2.0). 480p and 720p only. Use arcads_generate_video_seedance_20 for the full Seedance 2.0 model with 1080p. Processing typically takes ~7 minutes.
arcads_generate_video_seedance_25
ChatGPTByteDance's most natural video model: creator-style realism, spoken dialogue rendered in-video, and a character kept consistent across clips. Only use footage, photos or voices of people who have consented to this use, such as the user themselves, their own actors, or Arcads stock actors. The only model here that reaches 30 seconds in a single clip, and the only one that conditions on a reference video or a reference audio — so use it to make a specific actor say a line (from the prompt, by lip-syncing a provided voice, or from a reference video plus a prompt for a new line). Processing typically takes ~7 minutes.
arcads_generate_video_veo31
ChatGPTCreate broadcast-ready footage with cinematic understanding and consistency. Pass referenceImages (up to 3) OR startFrame/endFrame — not both. Processing typically takes ~3 minutes.
arcads_generate_video_wan_30
ChatGPTAlibaba Wan 3.0 — prompted video with native audio, 2–30 seconds, 480p–1080p. Guide with a start frame (and optional end frame) or with reference images, videos, and/or audio (any mix) named in the prompt as Image 1, Video 1, Audio 1. Keyframes and references are separate modes — pick one per generation. Use arcads_generate_video_wan_30_prime when the user wants the higher-quality Wan 3.0 Prime variant. Processing typically takes ~7 minutes.
arcads_generate_video_wan_30_prime
ChatGPTAlibaba Wan 3.0 Prime — higher quality and cost than Wan 3.0, with the same inputs: prompt with native audio, 2–30 seconds, keyframes or reference media (not both). Use arcads_generate_video_wan_30 when the user wants the cheaper Wan 3.0 tier. Processing typically takes ~7 minutes.
arcads_gestures
ChatGPTAnimate avatars with expressive gestures and emotions using AI-powered motion. Call arcads_list_situations with contentType='gestures' to find available situationIds. Processing typically takes ~5 minutes.
arcads_get_ad_audience
ChatGPTRead who the brand's own X Ads actually reached over the last 1 to 30 days, broken down by age band, gender, device and region, with spend, engagement rate and cost per result for each slice. Use this when the user asks who their ads reach or who to target, before recommending a targeting change. Pass campaignId (from arcads_list_ad_campaigns) to read one campaign; leave it out for the whole account. adNetwork is x. Supply productId when known; a workspace with one brand selects it automatically. The brand's saved X Ads account is read. On choose_ads_account, ask the user which account to use and call again with its adsAccountId; then pass that adsAccountId on every ad read in the conversation. Pass the same days as the other ad reads so every figure covers the same period, and quote the returned window. These are delivered audiences, separate from the targeting that was selected. Name each breakdown's resultBasis with every cost, and use spendShare to describe how large a slice is. Segments are ranked by spend (by impressions when no spend is billed yet) and capped; remainder rolls up the rest. spread compares the best and worst slices' engagement rates: quote gapRatio with those rates. comparison.separates true supports an observed engagement difference worth a test; false means inconclusive on this data, with blockedBy saying why, and the audience effect stays unresolved. For an acquisition question backed only by engagement data, say acquisition performance is unresolved, keep current targeting as the baseline and propose a test measured on conversions. Report pending and failed breakdowns as unavailable evidence, and say so when truncated is true. Connection actions happen in Arcads: relay the returned message for not_connected, ads_not_enrolled, reconnect_required and ads_account_unavailable.
arcads_get_ad_campaign_performance
ChatGPTBreak one campaign of the brand's own X Ads account down to its ad groups and creatives over the last 1 to 30 days: per promoted post or media creative, its spend, impressions, engagement rate, CTR, CPM and cost per result, with its delivery and approval status. Use this after arcads_list_ad_campaigns to see which creative carried a campaign; campaignId comes from that read. adNetwork is x. Supply productId when known; a workspace with one brand selects it automatically. The brand's saved X Ads account is read. On choose_ads_account, ask the user which account to use and call again with its adsAccountId; then pass that adsAccountId on every ad read in the conversation. Pass the same days as the campaign read so every figure covers the same period, and quote the returned window. caption is an excerpt of the post copy; a video's spoken or visual hook needs the media itself, which arcads_get_ad_creative_media returns for a post creative. Name costPerResult.basis with every cost. adGroupId groups the creatives that share targeting: compare creatives within one ad group, as an observational comparison rather than a controlled test. networkDetails.efficiencyIndex is a creative's share of results over its share of spend in its ad group, so above 1 means relatively efficient at the spend so far. networkDetails.waste names spend with no measured result or a cost above the advertiser's target. networkDetails.fatigue.fatigued means a rate below half its ad group's average on the named metric: describe it as below the peer average. A null signal means that comparison is unavailable. delivered false means no stats in this window. Report approvalStatus as returned, telling pending review from rejection. truncated means not every promoted post was analysed, or not every ad group or creative is listed: say so when it is true. Connection actions happen in Arcads: relay the returned message for not_connected, ads_not_enrolled, reconnect_required and ads_account_unavailable.
arcads_get_ad_creative_media
ChatGPTGet the video or photos of one of the brand's own promoted posts, as links the Arcads tools accept as media. Use this when the user wants to analyse, remake or edit one of their ads: pass its creativeId, productId and adsAccountId from arcads_list_ad_creatives, or a post creative of arcads_get_ad_campaign_performance. Then hand videoUrl or images to arcads_analyze_media, where a shot-by-shot breakdown is the base of a remake, or to a generation or editing tool as its reference or source. The links are signed for this conversation: use them right away, and call again for fresh ones later. The ad creatives gallery also calls this when the user presses play.
arcads_get_asset
ChatGPTReturn the current state of an Arcads asset and, when ready, its signed download URL. Use this when the user explicitly asks for the status or download URL of an existing asset, or when you need the output file of a generation to work with it yourself. For generation tools, the inline widget already shows the result to the user. It also takes the ids returned by arcads_generate_talking_actor, Arcads 1.0 videos included. Asset statuses: created → pending → generated (success) or failed. Uploaded media sits at 'uploaded', which is also ready. To wait for an asset that is still processing, pass waitSeconds: the call checks the asset every few seconds and returns as soon as it is ready or failed, or with its current state once waitSeconds have passed. Call it again with waitSeconds to keep waiting. Args: - assetId (string): UUID of the asset - waitSeconds (number, optional): how long to wait for the asset to be ready or failed, 0–40. Omit it or pass 0 to get the current state at once. Returns: - id, type, status, productId, createdAt, updatedAt - downloadUrl (string, present once status is 'generated' or 'uploaded' AND the asset is a media asset) — signed S3 URL of the file. - data (object, optional) — for LLM (text) assets, the response text lives in data.generatedText.
arcads_get_brand
ChatGPTGet details of a single Arcads brand by ID. Users may still call a brand a product — treat that as the same account. Use this to verify a brand exists and retrieve its full details before generating assets. The brand id is the productId generation tools expect. Args: - brandId (string): UUID of the brand Returns: Brand details: id, name, description, imageUrl, createdAt.
arcads_get_connected_post_media
ChatGPTLoad playable media for an owned TikTok video when the user presses play in the connected-posts gallery. Use its postId and connectionId from arcads_list_connected_posts.
arcads_get_creator_stats
ChatGPTGet the follower count, median views, engagement rate and country of one known creator on TikTok, YouTube, Instagram or X. Use it to look closer at a creator the user already named or one returned by arcads_search_creators. The stats come from the creator's public profile and metrics. Args: - platform ('tiktok' | 'youtube' | 'instagram' | 'x'): the creator's platform - handle (string): the creator's handle, without "@" - productId (string, optional): UUID of the brand to bill the lookup under Returns: the creator's profile link and stats.
arcads_get_credits
ChatGPTReport the workspace's credit balance: how many credits are left, and how many of them MCP spent during the current billing period. Call this when the user asks where their credits stand, or before planning a batch of generations, to check the balance covers it. The balance is the whole workspace's — the app and the API draw on it too. The spend figure counts generations made through MCP alone, so it is a share of what the balance went down by, not the whole of it. Args: None. Returns: creditsRemaining, creditsIncluded (the period's allowance, bought top-ups included), mcpCreditsSpentThisPeriod (MCP generations only, prompt enhancements included and refunded charges excluded), additionalCreditsUsed (spend past the allowance across the whole workspace, billed on top), the plan, and the period's start and end dates. Examples: - "How many credits do I have left?" - "How much have I spent through MCP this month?"
arcads_get_product
ChatGPTGet details of a single Arcads product by ID. Use this to verify a product exists and retrieve its full details before generating assets. Args: - productId (string): UUID of the product Returns: Product details: id, name, description, imageUrl, createdAt.
arcads_get_upload_url
ChatGPTGet a presigned S3 URL so this host can upload a file to Arcads itself. Use this when the host can PUT bytes to S3 (Claude). Pass the file's mimeType (e.g. image/jpeg, image/png, video/mp4), and its fileName when you know it — the result repeats it, which keeps several uploads in a row paired with the right filePath. Workflow: 1. Call this tool with the file's mimeType 2. PUT the raw file bytes directly to presignedUrl (HTTP PUT, not through MCP) 3. Set Content-Type header to the same mimeType 4. After HTTP 200, use the returned filePath in generation tools When the runtime cannot resolve s3-accelerate (ChatGPT), use arcads_upload_attachment and pass the attached file as file.
arcads_grok_video_edit
ChatGPTEdit a video using Grok's video editing model via the Arcads API. Max input: 100 MB, 8 seconds. The local file is uploaded automatically. Args: - productId (string, required) - videoPath (string, required): S3 path — OR use sourceVideoAssetId - sourceVideoAssetId (string, optional): UUID of an existing Arcads video asset - prompt (string, required, max 4096): Instruction for the edit - resolution ('480p'|'720p', default '720p') Returns: Video asset id. The inline widget polls and displays the result automatically. Processing typically takes ~1–2 minutes.
arcads_import_social_video
ChatGPTTurn the video behind an Instagram, TikTok or YouTube Shorts post, or a Meta Ad Library ad, into an Arcads video or photo asset, so it can be looked at and analysed. Use it whenever the user pastes a post link to break down, remake or study: a post page is not a video file, so link urls are never passed straight to arcads_analyze_media or any other media tool. Importing is free and a post imported before comes back as already imported. The result plays each imported video for the user in a player, so the video needs no other tool to display it. To read what people say under the post, call arcads_get_social_post_comments with the link; it needs no import. Args: - urls (string[]): 1-5 post links, as pasted by the user - productId (string, optional): UUID of the brand the asset is filed under Returns: one entry per link with the assetId of the imported video or photo (one per slide for a carousel) or the reason it failed (a private or deleted post keeps failing, so say which link and why rather than retrying).
arcads_isolate_voice
ChatGPTRemove background noise and isolate the vocal track from an audio file using the Arcads API. The local file is uploaded automatically. Max input: 500 MB, 60 minutes. Args: - productId (string, required) - audioPath (string, required): S3 path of the source audio Returns: Audio asset id. The inline widget polls and displays the result automatically. Processing typically takes ~5 seconds.
arcads_layer_videos
ChatGPTPlace one or more videos or images on top of a background using the Arcads API. Supports picture-in-picture, watermarks, app screen inserts, b-roll cutaways, and any overlay composition. All local file paths are uploaded automatically — no need to call arcads_upload_media first. Args: - productId (string, required): UUID of the product to associate with - backgroundPath (string, required): Local or S3 path of the background (video or image). A video background sets the composition's TOTAL DURATION and overlays are clipped to it, so make it the full-length element. - backgroundVolume (number 0–1, default 1.0): Audio volume of the background - layers (array, required): Ordered list of overlays (rendered bottom-to-top) Each layer has: path (string, required): Local or S3 path of the overlay media mediaType ('video'|'image', required): Type of the overlay file startSeconds (number, default 0): When the layer appears (seconds from start) durationSeconds (number, required): How long the layer is visible volume (number 0–1, default 0): Audio volume of the overlay (0 = muted) objectFit ('contain'|'cover', default 'contain'): How a FULL-CANVAS layer (one with no rect) fills the frame — 'cover' crops the overflow, 'contain' keeps the whole frame visible. A layer WITH a rect always covers its rect. rect (object, optional): Position and size as fractions of canvas (0.0–1.0) x, y, width, height — omit rect entirely to fill the full canvas height is OPTIONAL when BOTH the background and this overlay are local files: it is then computed from the overlay's aspect ratio so the layer is never distorted. Pass height explicitly when either file is an S3 path. Common rect presets (height auto-computed when omitted for local files): Full screen: omit rect entirely PiP bottom-right: { x: 0.60, y: 0.72, width: 0.36 } PiP bottom-left: { x: 0.04, y: 0.72, width: 0.36 } Center insert (80%): { x: 0.10, y: 0.20, width: 0.80 } Small watermark: { x: 0.75, y: 0.88, width: 0.20 } Returns: Asset id and status. The inline widget polls and displays the result automatically. Processing typically takes ~1 minute.
arcads_list_ad_accounts
ChatGPTList the X Ads accounts a brand can read through its connected X accounts, with the one saved as the brand's default. Use this when the user asks which ads accounts they have or wants to read a different one: pass the chosen adsAccountId on every other ad read in the conversation; the brand's saved account stays the default. adNetwork is x. Supply productId when known; a workspace with one brand selects it automatically. Connection actions happen in Arcads: relay the returned message for not_connected, ads_not_enrolled and reconnect_required.
arcads_list_ad_campaigns
ChatGPTRead the campaign performance of the brand's own X Ads account over the last 1 to 30 days: per campaign its spend, impressions, engagement rate, CTR, CPM, CPC and cost per result, and whether it is delivering now. Use this for "how are my ads doing", "which campaign spends the most" and campaign-level questions about the workspace's own paid campaigns; arcads_list_ad_creatives shows the promoted posts themselves. Pass purpose analysis when the user asks how their ads or campaigns perform, wants a breakdown, an analysis or a dashboard, or asks for insights, and leave purpose at browse for one figure or one narrow question; an analysis read ends with the reads to make and the dashboard to present. adNetwork is x. Supply productId when known; a workspace with one brand selects it automatically. The brand's saved X Ads account is read. On choose_ads_account, ask the user which account to use and call again with its adsAccountId; then pass that adsAccountId on every ad read in the conversation. days defaults to 30: keep the same days for every ad read in the conversation so every figure covers the same period, and quote the returned window. Name costPerResult.basis with every cost: a cost per engagement or per link click is a different measure from a cost per purchase. Compare costs between campaigns with the same goal and basis. delivered false means no stats in this window, with lifetime delivery unknown. running and blockedBy describe the current status, separately from past delivery. truncated means only the most recent campaigns were read: say so when it is true. Pass campaignIds to read specific campaigns, such as the ones the user names. Connection actions happen in Arcads: relay the returned message for not_connected, ads_not_enrolled, reconnect_required and ads_account_unavailable.
arcads_list_ad_creatives
ChatGPTShow the promoted posts of the brand's own X Ads account as a gallery, with spend, impressions, engagement rate, CTR and cost per result over the last 7, 14 or 30 days. Use this for "my ads", "my promoted posts", "which ads spent the most" and creative performance questions about the workspace's own paid campaigns. adNetwork is x. Supply productId when known; a workspace with one brand selects it automatically. The brand's saved X Ads account is read. On choose_ads_account, ask the user which account to use and call again with its adsAccountId; then pass that adsAccountId on every ad read in the conversation. sort is spend (default), impressions or recent; posts that delivered in the window come first. limit is how many posts to show (default 12, maximum 24). totalCreatives counts every promoted post of the account, and truncated means the account promotes more posts than one read returns. Name the cost basis with every cost: a cost per engagement or per link click is a different measure from a cost per purchase. delivered false means no delivery data in this window, so describe those metrics as unknown. To analyse, remake or edit one of these ads, call arcads_get_ad_creative_media with its creativeId for its video or photos. Connection actions happen in Arcads: relay the returned message for not_connected, ads_not_enrolled, reconnect_required and ads_account_unavailable.
arcads_list_brands
ChatGPTList all brands in your Arcads workspace with pagination. Users may still call a brand a product — treat that as the same account. Brands are required for generating any asset — every generation request must include a productId. The brand id is that productId. Use this tool first to discover available brands and their IDs. Args: - page (number): Page number, 1-indexed (default: 1) - pageSize (number): Items per page, 1-100 (default: 50) - response_format ('markdown' | 'json'): Output format (default: 'markdown') Returns: List of brands with id, name, description, imageUrl. Also returns pagination info: total, page, pageSize, has_more. Examples: - "What brands do I have?" -> call with defaults - "Show me the next page of brands" -> increment page param
arcads_list_competitor_ads
ChatGPTFetch the ads Arcads has collected for a brand's competitors — real, currently-running creatives, most with a breakdown of what makes them work. The ads come from public ad libraries, for competitors the user named. Use this whenever the user wants competitor inspiration: "what are my competitors running", "show me ads in my space", "find me a reference to clone". When the brand has no competitors set, the result says so. Ask the user which brands they compete with, then call arcads_add_competitors with those names — do not guess competitors on their behalf. Args: - productId (string, optional): UUID of the brand (auto-selected when the workspace has only one) - source (string, optional): 'competitor' (default), 'own' for the brand's own collected ads, or 'all' - limit (number, optional): how many ads to return, 1–50 (default 20) Returns: the configured competitors plus one line per ad. An inline widget plays each ad and offers to clone it, so summarise what was found rather than repeating the rows.
arcads_list_connected_posts
ChatGPTRead recent posts from the workspace's own connected X or TikTok account, with metrics and a media gallery. Use this for "my latest posts", "our TikTok videos" and performance questions about connected accounts. Pass purpose analysis when the user asks how posts or the account perform, compares posts or wants insights, and leave purpose at browse when the user only wants to see or fetch posts. Choose platform x or tiktok. Use arcads_list_social_accounts to find connectionId. X requires a brand: supply productId when known; a workspace with one brand selects it automatically. Choose among multiple eligible X accounts with connectionId. TikTok uses the workspace account. limit is how many posts to present (default 10, maximum 50). X returns at least 5 posts, while the gallery initially shows limit. X reads cost credits per post fetched, so ask for the smallest useful limit. Use any remaining returned posts before continuing with nextCursor, the same platform, productId and connectionId. TikTok reads are free. Name the returned account and use the gallery for captions, metrics, images and video playback. Give the requested interpretation or comparison in your reply. Treat missing metrics as unknown. Describe these metrics as a snapshot of the returned organic posts at read time. TikTok videos load on demand in the gallery; covers and cached videos are available immediately. Original post links remain available when media cannot load. Connection and brand-link actions happen in Arcads: use the returned message for not_connected or account_selection_required. Recommend reconnecting when the result explicitly says reconnect_required.
arcads_list_products
ChatGPTList all products in your Arcads workspace with pagination. Products are required for generating any asset — every generation request must include a productId. Use this tool first to discover available products and their IDs. Args: - page (number): Page number, 1-indexed (default: 1) - pageSize (number): Items per page, 1-100 (default: 50) - response_format ('markdown' | 'json'): Output format (default: 'markdown') Returns: List of products with id, name, description, imageUrl. Also returns pagination info: total, page, pageSize, has_more. Examples: - "What products do I have?" -> call with defaults - "Show me the next page of products" -> increment page param
arcads_list_situations
ChatGPTList situations (actor + scene combinations) accessible to the workspace via the Arcads API. Use this to discover situationId values for arcads_generate_talking_actor (default arcads_1.0 talking actor), arcads_audio_driven, arcads_omnihuman, arcads_unboxing_pov, arcads_show_your_app, arcads_gameplay_ad, arcads_gestures, and arcads_camera_movement. Args: - page (integer, default 1): Page number - pageSize (integer, default 50): Items per page - contentType (string, optional): Filter by situation type: 'talking_actor' — standard lip-synced UGC actor (default when no filter given) 'show_your_app' — actor presenting an on-screen app 'unboxing_pov' — unboxing point-of-view 'gestures' — gestures 'camera_movement' — camera movement - actorGender ('male'|'female', optional): Filter by actor gender (talking_actor only) - actorAge ('adult'|'senior'|'young adult', optional): Filter by actor age (talking_actor only) - actorName (string, optional): Filter by actor name — case-insensitive substring search (talking_actor only) - actorFreeSpeech (boolean, optional): Only return actors that support free-speech generation Returns: Paginated list of situations with id, actor info, type, tags, emotions, and preview URL.
arcads_list_social_accounts
ChatGPTDiscover X and TikTok accounts connected to the Arcads workspace and their connection IDs. Use this when the user asks which social accounts are connected. Set platform to x or tiktok for one platform, or omit it to list both. For a successful account listing, reply concisely with the account names and handles. Use the display name when a TikTok handle is unavailable. Discuss brand membership when a brand was requested. Offer management links when the user asks to manage connections, and setup guidance when the result requires action. Omit productId to browse workspace accounts directly. brandLinkStatus="not_checked" means brand membership is unknown from this call; these accounts may already be linked to brands. Supply a brand's productId to check which X accounts are enabled for it. brandLinkStatus="linked_to_requested_brand" or "not_linked_to_requested_brand" describes membership only for that requested brand. TikTok has one workspace account and no brand-link setting; its brandLinkStatus is "not_applicable". This tool reads connections stored in Arcads. Explain that live access is checked during social API operations when the user specifically asks about credential validity. Recommend reconnection only after an API error explicitly identifies a social account connection that requires reconnection. Follow each platform's pagination.nextPage to continue, specifying that platform on subsequent calls. Use the returned Arcads instructions and URLs for required connection or brand-linking actions. This read uses saved data, makes zero social API calls and costs zero credits.
arcads_list_voices
ChatGPTList all voices accessible to the workspace via the Arcads API. Use this to discover voiceId values for arcads_generate_talking_actor, arcads_text_to_speech, arcads_speech_to_speech, arcads_audio_driven, arcads_omnihuman, and arcads_change_voice. Args: - page (integer, default 1): Page number - pageSize (integer, default 50): Items per page - gender ('Female'|'Male'|'Neutral', optional): Filter by gender - language (string, optional): Filter by language — e.g. 'English', 'French', 'Spanish', 'German', 'Italian', 'Portuguese', 'Dutch', 'Japanese', 'Korean', 'Chinese (Simplified)', 'Arabic', 'Hindi', and more - age ('Young'|'Middle Aged'|'Old', optional): Filter by age range Returns: Paginated list of voices with id, name, gender, age, language, descriptive, source, and audioUrl.
arcads_mute_video
ChatGPTRemove the audio track from a video using the Arcads API. The local file is uploaded automatically. Args: - productId (string, required) - videoPath (string, required): S3 path Returns: Video asset id. The inline widget polls and displays the result automatically. Processing typically takes ~10 seconds.
arcads_omnihuman
ChatGPTGenerate a talking-head video using the OmniHuman model via the Arcads API. For situation + script with Studio-default fidelity, prefer arcads_generate_talking_actor (model arcads_1.0). Identical interface to arcads_audio_driven but uses a different underlying AI model; also supports custom actor sources (referenceImages, sourceVideoAssetId). Only use footage, photos or voices of people who have consented to this use, such as the user themselves, their own actors, or Arcads stock actors. Local files are uploaded automatically. Actor source — pick exactly one: - situationId: Use a predefined Arcads actor/situation - sourceVideoAssetId: Use an actor from an existing video asset (UUID) - referenceImages (1 image): Use a custom actor from an image Audio source — pick exactly one: - script (TTV): Arcads synthesises the voice from the script - referenceAudios (1 audio file, STS): Drives the actor with the provided audio Args: same as arcads_audio_driven — productId, situationId/sourceVideoAssetId/referenceImages, script/referenceAudios, autoAddScriptEmotion, voiceId, audioSettings Call arcads_list_situations to discover available situationId values. Returns: Asset id. The inline widget polls and displays the result automatically. Processing typically takes ~11 minutes.
arcads_probe_media
ChatGPTRead an Arcads asset's duration, dimensions, fps and whether it has audio, as text with no image. Args: - assetId (string, required): UUID of a generated or uploaded asset
arcads_prompt_builder
ChatGPTGenerate optimised prompts for any AI model from a description and optional reference files. The inline widget polls the asset and the optimised prompt appears in data.generatedText on the structured output. Processing typically takes ~20 seconds.
arcads_register_audio
ChatGPTRegister an already-uploaded audio file (S3 path) as a persistent Arcads audio asset. Use this after uploading audio with arcads_get_upload_url + presigned PUT to get a stable asset ID that can be referenced in referenceAudios for audio_driven, speech_to_speech, etc. Args: - productId (string, optional) - audioPath (string, required): S3 file path returned after the presigned URL upload Returns: Audio asset id. The inline widget polls and displays the result automatically.
arcads_register_document
ChatGPTRegister an already-uploaded document (PDF or other supported format) as a persistent Arcads asset. Use this after uploading a document with arcads_get_upload_url + presigned PUT to get a stable asset ID that can be referenced in referenceDocuments for arcads_analyze_media. Args: - productId (string, optional) - documentPath (string, required): S3 file path returned after the presigned URL upload Returns: Document asset id. The inline widget polls and displays the result automatically.
arcads_register_image
ChatGPTRegister an already-uploaded image file (S3 path) as a persistent Arcads image asset. Use this after uploading an image with arcads_get_upload_url + presigned PUT to get a stable asset ID that can be referenced as a sourceVideoAssetId or in referenceImages. Args: - productId (string, optional) - imagePath (string, required): S3 file path returned after the presigned URL upload Returns: Image asset id. The inline widget polls and displays the result automatically.
arcads_register_video
ChatGPTRegister an already-uploaded video file (S3 path) as a persistent Arcads video asset. Use this after uploading a video with arcads_get_upload_url + presigned PUT to get a stable asset ID that can be referenced in other tools as a sourceVideoAssetId or in referenceVideos. Args: - productId (string, optional) - videoPath (string, required): S3 file path returned after the presigned URL upload Returns: Video asset id. The inline widget polls and displays the result automatically.
arcads_remove_background
ChatGPTRemove the background from a video or image using the Arcads API. The local file is uploaded automatically. Args: - productId (string, required) - mediaPath (string, required): S3 path - mediaType ('video'|'image', default 'video'): Type of the input file Returns: Asset id. The inline widget polls and displays the result automatically. Processing typically takes ~10 seconds for images, ~7 minutes for videos.
arcads_replace_actor
ChatGPTReplace the main actor in a video with a person from a reference image using the Arcads API. Only use footage, photos or voices of people who have consented to this use, such as the user themselves, their own actors, or Arcads stock actors. Both files are uploaded automatically. Max video: 100 MB, 3–30 seconds. Args: - productId (string, required) - videoPath (string, required): S3 path of the source video - imagePath (string, required): S3 path of the replacement actor image Returns: Video asset id. The inline widget polls and displays the result automatically. Processing typically takes ~9 minutes.
arcads_scene_split
ChatGPTAutomatically detect and split a video into individual scene clips. Useful for repurposing long-form video into short clips. Returns a collection of video assets — one per scene. Max input: 200 MB. Args: - productId (string, optional) - videoPath (string, required): S3 path or URL of the source video (max 200 MB) - mode (string, optional): 'auto' (default) — detect scenes automatically | 'manual' — use custom settings - detectionStrategy (string, optional): 'threshold' (default) | 'count' - sceneThresholdPercent (number, optional): Scene change sensitivity 1–100 (default 17). Lower = more splits. - targetSceneCount (number, optional): Target number of scenes when strategy is 'count' (default 6, max 100) - minSceneSeconds (number, optional): Minimum scene length in seconds (default 1) - intervalSeconds (number, optional): Manual split interval in seconds (default 10) Returns: Multiple video asset ids (one per scene). The inline widget polls each id and displays the results automatically. Processing typically takes ~10–60 seconds depending on video length.
arcads_search_assets
ChatGPTSearch everything already generated or uploaded in a brand's library, newest first. Use this whenever the user refers to something they made before — "the video I made yesterday", "my running shoe images", "that ad about winter" — to find its assetId before acting on it. Results include Arcads 1.0 talking-actor videos (type arcads_1.0), whose excerpt is their script. Args: - productId (string, optional): UUID of the brand (auto-selected when the workspace has only one) - query (string, optional): free text matched against prompts and scripts. Omit to browse. - kind (string, optional): 'video' or 'photo' - aspectRatio (string, optional): '9:16', '1:1' or '16:9' - origin (string, optional): 'all' (default), 'generated', 'uploaded', 'google_drive', 'dropbox', 'broll' - page (number, optional): 1-based page number, default 1 - pageSize (number, optional): results per page, 1–50, default 20 Returns: count plus one line per asset (id, type, status, date, and an excerpt of its prompt or script). Pass an id to arcads_get_asset for the full record and the download URL. An inline widget renders the results as a gallery with previews and per-asset Download / Copy URL, so summarise what was found rather than listing the rows again.
arcads_search_creators
ChatGPTFind UGC creators on TikTok, YouTube, Instagram or X for a brand, by keyword or by a lookalike account. Use it for "find me TikTok creators for skincare", "find creators like @brewlab", or any request to source influencers/UGC creators to work with. Results come from public profiles and metrics, and the purpose is to contact creators about a paid collaboration. Each call is a paid search, so agree the keywords with the user first: propose 2-4 keywords that approach the brand from different angles (its category, the audience's routines and pain points, the way creators in the niche talk, the video format that works), and let the user pick or correct the ones to search. A keyword names what the creators post about, 1-4 words ("dog food reviews", "coffee gadgets"), never an audience label and independent of the brand or product name. Then make one call per validated keyword, in parallel when you can, each with a limit around 10. The search itself shows nothing to the user: once every keyword has run, pick the creators worth presenting across all the results, and show them with arcads_show_creators in one call, best first. Pass a brief alongside it whenever you have one: one line on what the user is looking for and what they've already ruled out, written in the language the user writes in, since that line is what decides the borderline accounts. Pass language with the ISO 639-1 code of the language the user writes in, and each creator's fitReason comes back in it. The search screens every candidate against the brand for fit, so the creators it returns are already filtered rather than a raw platform search. Judge the creators it returns against the user's brief and keep the best fits, and when the user asks for more from the same search, call it again with the cursor it returned. After finding creators, use arcads_get_creator_stats for a closer look at one. Args: - platform ('tiktok' | 'youtube' | 'instagram' | 'x'): platform to search - keyword (string, optional): 1-4 words naming what the creators post about, agreed with the user first, independent of the brand or product name - similarTo (string, optional): a handle to find lookalike creators for — pass exactly one of keyword or similarTo - limit (number, optional): creators to return, 1-20 (default 10) - region (string, optional): ISO 3166-1 alpha-2 code (common aliases like UK/USA accepted) naming the target market. It never filters Instagram and X by country (their profiles carry no country; on X it only limits the language for US, GB and FR), and on TikTok and YouTube it only removes creators whose country is known and different. To target a country, also put keywords in its language or with local markers (a city, a local expression) — "coach sportif tunis" rather than "fitness" - cursor (string, optional): pass the nextCursor from a previous call when the user asks for more - brief (string, optional): one line on what the user wants and what they've ruled out — pass it whenever you have one, since it decides the borderline accounts - language (string, optional): ISO 639-1 code of the language the user writes in (e.g. "fr") — fitReason comes back in it - faceless ('include' | 'exclude', optional): whether to include or exclude creators who do not show their face - gurus ('include' | 'exclude', optional): whether to include or exclude creators who mainly teach/coach rather than use products on camera - productId (string, optional): UUID of the brand (auto-selected when the workspace has only one) Returns: the matched creators with handle, platform, profile link, followers, median views, engagement, country and the judge's reason and verdict for each, plus a cursor to find more.
arcads_search_social_posts
ChatGPTScan TikTok, Instagram and X for the organic posts working right now on a topic, or pull a known account's latest posts. Use it for "what's working on TikTok for cold brew", "what's trending on Instagram in skincare", "what are people tweeting about the World Cup", or "what is @brand posting lately". The scan searches several formulations across several pages, screens every post for relevance against the brand, ranks the kept ones by how fast they are growing for their age and audience, and returns them with their metrics. An inline widget renders each post as a playable card. How to call it: - Topic scan: pass 3-5 queries that spread the idea — the topic in the user's words, a hashtag form ("#coldbrew"), a synonym or the product category, and an angle naming the brand when known. - Known account: pass handles instead (no "@"), never together with queries. - Platforms: TikTok and Instagram for a general scan; add X when the user names it, or use it alone for "what are people tweeting". - since: only when the user names a window ("this week", "since the launch"). Args: - queries (string[], optional): 1-5 formulations of the topic - handles (string[], optional): 1-5 account handles, instead of queries - platforms (string[]): any of tiktok, instagram, x - since (string, optional): YYYY-MM-DD lower bound on the publish date - limit (number, optional): posts to keep across every platform, 1-30 (default 10) - sort (string, optional): trending (default for queries), views, engagement, recent (default for handles) - productId (string, optional): UUID of the brand (auto-selected when the workspace has only one) Returns: the scanned scope and one entry per kept post with its url and postId, ready for arcads_get_social_post_comments.
arcads_show_creators
ChatGPTShow the final creator shortlist to the user as cards. Call it once, after every arcads_search_creators call of the request has run, with the creators you selected from all the results in your recommended order, best fit first. It shows only creators that arcads_search_creators returned for this brand, and it is free. The creators come from public profiles and metrics. Args: - picks (array, required): 1-20 creators, each { platform, handle }, copied exactly from the search results - productId (string, optional): UUID of the brand the searches were for (auto-selected when the workspace has only one) Returns: the creators now shown, plus any pick that no search returned, which is left out.
arcads_show_social_posts
ChatGPTOpen one or more TikTok, Instagram or X posts from their links and show them as playable cards with the author, metrics and caption. Use it whenever the user pastes a post link to look at, react to or discuss ("what do you think of this one?", a bare pasted link). Short links (vm.tiktok.com, vt.tiktok.com) are resolved. Args: - urls (string[]): 1-6 post links, as pasted by the user - productId (string, optional): UUID of the brand to bill the lookup under Returns: one entry per post with its metrics, url and postId, plus any link that could not be opened.
arcads_show_your_app
ChatGPTTurn static app screenshots into a professional, dynamic app showcase. Requires an Arcads situationId (actor). Call arcads_list_situations with contentType='show_your_app' to find available situationIds. Processing typically takes ~2 minutes.
arcads_skin_enhance
ChatGPTTransform AI-generated skin textures into photorealistic results. Processing typically takes ~2 minutes.
arcads_speech_to_speech
ChatGPTConvert the voice in an audio file to a different voice using ElevenLabs via the Arcads API. The local file is uploaded automatically. Max input: 5 minutes. Args: - productId (string, required) - audioPath (string, required): S3 path of the source audio - voiceId (string, required): Target voice ID Returns: Audio asset id. The inline widget polls and displays the result automatically. Processing typically takes ~5–10 seconds.
arcads_stitch_videos
ChatGPTConcatenate 2–20 video clips into a single video using the Arcads API. Local file paths are uploaded automatically — no need to call arcads_upload_media first. Videos are stitched in the exact order provided. Args: - productId (string, required): UUID of the product to associate with - videoPaths (array of 2–20 strings, required): Local file paths or S3 paths in playback order Constraints: - Minimum 2 videos, maximum 20 videos per call - For more than 20 clips: stitch the first batch, download the result, then stitch it with the remaining clips Returns: Asset id and status. The inline widget polls and displays the result automatically. Processing typically takes ~1 minute.
arcads_text_to_speech
ChatGPTSynthesise an audio file from a script using the Arcads TTS API. Args: - productId (string, required) - script (string, required, max 50 000 chars): Text to synthesise - voiceId (string, required): Voice ID to use Returns: Audio asset id. The inline widget polls and displays the result automatically. Processing typically takes ~5–10 seconds.
arcads_transcribe
ChatGPTTranscribe spoken content from a video or audio file using the Arcads API. The local file is uploaded automatically. Args: - productId (string, required) - mediaPath (string, required): S3 path of the video or audio file - mediaType ('video'|'audio', default 'video'): Type of input file - format ('plain'|'srt', default 'plain'): 'plain' returns the words as prose; 'srt' returns SubRip cues with the timing each line was spoken at — the format a subtitle editor reads, and the one to use when a transcript has to be corrected before it is burnt into a video Processing typically takes ~20 seconds. The inline widget polls the asset and the transcription appears in data.transcription on the structured output.
arcads_translate_video
ChatGPTTranslate a video's audio track into one or more languages using the Arcads API. The local file is uploaded automatically. Args: - productId (string, required) - videoPath (string, required): S3 path of the video to translate - languages (array of strings, required): Target language names, e.g. ["French", "Spanish", "Dutch (Netherlands)"] - lipsync (boolean, optional): Enable lip-sync for translated audio (default false) - numberOfSpeakers (integer 1–10, required): Number of distinct speakers in the video Returns: Asset id(s) — one per language. The inline widget polls each id and displays the results automatically. Processing typically takes ~6 minutes.
arcads_trim_video
ChatGPTRemove seconds from the start or end of a video using the Arcads API. The local file is uploaded automatically — no need to call arcads_upload_media first. Args: - productId (string, required): UUID of the product to associate with - videoPath (string, required): Local file path or S3 path of the video to trim - startOffsetSeconds (number >= 0, default 0): Seconds to cut from the beginning - endOffsetSeconds (number >= 0, default 0): Seconds to cut from the end Natural language translation examples: "remove the first 3 seconds" → startOffsetSeconds: 3, endOffsetSeconds: 0 "remove the last 2 seconds" → startOffsetSeconds: 0, endOffsetSeconds: 2 "keep seconds 2 to 8 of a 10s video" → startOffsetSeconds: 2, endOffsetSeconds: 2 Returns: Asset id and status. The inline widget polls and displays the result automatically. Processing typically takes ~1 minute.
arcads_unboxing_pov
ChatGPTTurn a single product photo into an engaging, realistic POV unboxing video. Requires an Arcads situationId (actor). Call arcads_list_situations with contentType='unboxing_pov' to find available situationIds. Processing typically takes ~8 minutes.
arcads_update_brand
ChatGPTUpdate an existing brand in your Arcads workspace. Users may still call a brand a product — treat that as the same account. Overwrites each field you pass; mainFeatures replaces the whole list. No history is kept. Args: - brandId (string, required): UUID of the brand - name (string, optional): Brand name, at least 2 characters when provided - description (string, optional) - targetAudience (string, optional) - mainFeatures (string[], optional) - painPoint (string, optional) - perceived (string, optional) Returns: The updated brand: id, name, and current fields.
arcads_upload_attachment
ChatGPTUpload a file the user attached in ChatGPT. Pass that attachment as file. ChatGPT fills download_url, file_id, and when available mime_type and file_name. This server downloads the file and stores it on Arcads. Use the returned filePath in generation tools (referenceImages, startFrame, endFrame, referenceVideos, referenceAudios). Call this once per attachment. Do not PUT the bytes to S3 yourself. Do not send raw base64.
arcads_upload_media
ChatGPTUpload media to Arcads S3 when the MCP server can fetch the file itself. Use arcads_upload_attachment when the user attaches a file in ChatGPT. Use arcads_get_upload_url when the host can PUT to S3 itself (Claude). Use this tool only for: - url: HTTP/HTTPS URL — downloaded and uploaded by the MCP server - filePath: An already-uploaded S3 key (passthrough) Supported formats: images, videos, audio (max 10 MB).
arcads_upscale_image
ChatGPTUpscale an image to higher resolution using the Arcads API. The local file is uploaded automatically. Max input: 10 MB. Args: - productId (string, required) - imagePath (string, required): S3 path - upscaleFactor (number, optional): 1.25, 1.5, 2 (default), 3 or 4 Returns: Image asset id. The inline widget polls and displays the result automatically. Processing typically takes ~30 seconds.
arcads_upscale_video
ChatGPTUpscale a video to higher resolution using the Arcads API. The local file is uploaded automatically. Max input: 100 MB, 30 seconds. Args: - productId (string, required) - videoPath (string, required): S3 path - quality (string, optional): 'standard' (default), 'fast' (Enhanced) or 'precise' (Pro) - targetResolution (string, optional): '1080p' (default), '2k' or '4k', for 'standard' - upscaleFactor (number, optional): 1.25, 1.5, 2 (default), 3 or 4, for 'fast' and 'precise' Returns: Video asset id. The inline widget polls and displays the result automatically. Processing typically takes ~3 minutes, longer on 'precise'.
arcads_video_editor
ChatGPTEdit a short video clip using a natural language prompt via Arcads. Describe the change you want (e.g. "make the sky purple", "add a sunset background") and the AI will apply it. Max input: 10 MB. Supports 5 or 10 second outputs. Args: - productId (string, optional) - videoPath (string, required): S3 path or URL of the source video to edit (max 10 MB) - prompt (string, required): Natural language description of the edit to apply - duration (number, required): Output duration in seconds — 5 or 10 Returns: Video asset id. The inline widget polls and displays the result automatically. Processing typically takes ~30–60 seconds.
arcads_view_contact_sheet
ChatGPTSee many frames of an Arcads video in one grid image, in seconds: the best first look at a video, one call covers every scene. Use it to check on-screen text, product fidelity, framing, the actor or artifacts before you deliver. Images come back at most 1024 px on their long edge. To hear audio or judge motion and lip sync, use arcads_analyze_media. Args: - assetId (string, required): UUID of a generated or uploaded asset - count (number, optional): number of frames spread evenly, 1–25 (default 9) - atSeconds (number[], optional): exact seconds to show, one cell each, instead of count
arcads_view_frame
ChatGPTSee one frame of an Arcads video at full detail, in seconds: read on-screen text, check spelling, framing or the product. For an image asset, returns the image itself. Images come back at most 1024 px on their long edge. To compare several instants of one video, arcads_view_contact_sheet returns many frames in one call. Args: - assetId (string, required): UUID of a generated or uploaded asset - timeSeconds (number, optional): seconds into the video - frame ("first" | "last", optional): first or last frame, instead of timeSeconds
arcads_watch_asset
ChatGPTReturn the current state of an Arcads asset and, when ready, its signed download URL. INTERNAL TOOL: This tool is only callable by the inline generation widget (via callServerTool) to poll asset status. It is hidden from the agent because every generation tool already shows the result inline via that widget — the agent never needs to call this directly. Asset statuses: created → pending → generated (success) or failed. Uploaded media sits at 'uploaded', which is also ready. Args: - assetId (string): UUID of the asset Returns: - id, type, status, productId, createdAt, updatedAt - downloadUrl (string, present once status is 'generated' or 'uploaded' AND the asset is a media asset) — signed S3 URL of the file. - data (object, optional) — for LLM (text) assets, the response text lives in data.generatedText.
library
ChatGPTBrowse the brand's Arcads library: every generated or uploaded video, image and audio, newest first.
library_download
ChatGPTSigned link that downloads one asset's file from the Arcads library.
