Flashloop

Edit clips, voiceover takes, burned captions and music into ONE MP4 on a timeline (free, no credits). `clips` play in order with hard cuts; each is one of your completed videos (`video_id`, or its `video:<id>` job_id) or a Flashloop CDN `src`. A clip's slot is its own length unless `duration` is set; `fit` decides what a shorter clip does and `scale` how it fills the canvas. Anchors (`at`) place voice, captions and music: {clip: i} spans clip i, {clips: [i, j]} spans clips i through j, {start, end} are seconds on the output timeline. A take longer than its window is sped up to `max_speed`, then fails with VOICE_TOO_LONG unless `overflow` is 'trim'. A caption with `voice: k` follows take k, and with a voice_generation_id take its words are synced to the speech automatically. Music ducks under the voice. `canvas.quality: 'preview'` is a quick draft for checking timing. Submitting an edited timeline again makes a new video and re-renders only the clips that changed, so small fixes come back fast. Returns a `job_id`; wait_for_job returns the MP4 and `warnings[]` (for example a clip shorter than its slot). A failed job's message starts with a code such as VOICE_TOO_LONG, SOURCE_DOWNLOAD_FAILED or RENDER_FAILED. flashloop_assemble_video is the simpler fixed-block form.

flashloop_edit_video

Estimate the credit cost of a planned video, image or music generation before running it (for kind 'music', pass the music model and optionally max_mode: 1050 credits, or 2000 with max_mode), so you can check it against the balance from get_credits. Costs are derived from the model's pricing (pricing_tiers or pricing_per_second from list_models). This is an estimate; the server is authoritative and may differ (tiered duration/resolution, multi-shot, multi-image counts). `duration` accepts any whole second inside the model's `capabilities.duration` range when its mode is "range". For a multi-shot video pass the total of all shot durations as `duration`: per-second models bill that total. For a `type: 'upscale'` model (flashloop_upscale) this returns `estimated_credits: null` — that pricing is computed server-side from the source file's real duration/resolution, which is never known here; read credits_used from the completed job instead.

flashloop_estimate_cost

Register the finished video as the result of a project. First upload the mp4 (and optionally a cover image) from the sandbox with flashloop_upload_media and this project_id, run its curl command, then pass the returned `public_url`s here. Returns `video_url` and `studio_url`, the link to the video in the user's Faceless Studio. Safe to call again on a finished project.

flashloop_finish_video

Generate a full song with Flashloop Music from a description (simple mode) or from your own lyrics and style (custom mode). Every generation returns two tracks, each as an mp3 preview and a wav download. It costs 1050 credits, or 2000 credits with max_mode, and the price always includes both wav files. It is asynchronous: it returns a `job_id`, and wait_for_job returns `tracks[]` with `mp3_url`, `wav_url`, `title` and `duration_seconds` for each track once the song is ready.

flashloop_generate_music

Generate a voiceover from text using a chosen voice. Find `voice_id` values via list_voices. Optional `model_id`: 'eleven-v3-voiceover' (default; 5000-char cap, cloned voices), 'eleven-v4-voiceover' (most expressive, audio tags like [whispered]; 10000-char cap, cloned voices), 'eleven-v4-turbo-voiceover' (lower latency, half the credits; 10000-char cap) or 'gemini-3-1-voiceover' (multilingual 70+ languages, 10000-char cap, 2x cheaper; use the gemini voice names from list_voices, no cloned voices). 'gemini-3-8-flash-voiceover' and 'gemini-3-8-flash-lite-voiceover' (5000 spoken chars, 30 gemini voices from list_voices, no cloned voices) read `text` literally: delivery direction goes in `style` (e.g. 'warm, upbeat host'), not in the text, and the accepted angle tags are <laugh>, <sigh>, <short pause>, <breath>, <cough> ([brackets] are not tags on these models). They also do a 2-speaker dialogue: send `speakers` and `turns` instead of `text` and `voice_id`. Voiceover is ASYNC on every model: generation time scales with script length (seconds for short lines, several minutes for long scripts), so it returns a `job_id`; wait_for_job returns the audio URL (a timeout means it is still processing). If the result already has `audio_url`, the audio is done and there is no job.

flashloop_generate_voiceover

Read the Flashloop Faceless video guide before making a video. Call it first: it explains the full flow, including the style catalog, with flashloop_start_video, flashloop_exec, flashloop_generate_voiceover, flashloop_upload_media and flashloop_finish_video. Without `path` it returns the main instructions and the list of extra files. With `path` it returns that one file.

flashloop_get_instructions

Turn a generation's cdn.flashloop.app URL (from list_generations / wait_for_job output) into a time-limited direct-download URL (Content-Disposition: attachment, expires in ~1 hour). Use when the user wants to SAVE a video/image/voiceover to their device rather than just view it. Calls the Flashloop API (https://www.flashloop.ai/mcp).

flashloop_get_download_url

Check an async generation ONCE (no blocking) and return its current state: completed, failed, or still-processing. Use this for a non-blocking peek; use wait_for_job to block until done.

flashloop_get_job

Return the current credit balance. Cheap to call; comparing the balance before and after a batch of generations shows the spend.

flashloop_get_credits

Show the Faceless video styles as a gallery the user can pick from. Free. After the user picks one, pass its `id` as `style_id` to flashloop_start_video.

flashloop_list_styles

List the user's generations — videos, images, or both mixed (newest first). Renders a gallery widget. Serves history and browse requests: show my videos, show my images, show recent generations, find a past result. Each row carries a `job_id` (usable with get_job / wait_for_job) and its output URL — a completed url can be reused as a reference in create_image / create_video. Voice generations have no paginated list and are not included. A generation created in the current conversation is already shown live by its own card.

flashloop_list_generations

List the video/image/upscale/music models available, with the capabilities and pricing tiers of each. Returns the legal model/model_id values for create_video / create_image and which options (duration, sound, resolution, references, multi-shot) a model supports. Each model's `capabilities` block carries the per-model reference-image cap (max_reference_images), upload limits for validating reference files client-side (max_image_size_mb, max_video_size_mb, accepted_upload_formats), @-character support + caps, multi-shot limits, and special requirements (e.g. grok-imagine needs a first frame). `capabilities.duration` holds the legal duration domain, not the top-level `supported_durations`: when its `mode` is "range", ANY whole second between `min_seconds` and `max_seconds` is legal and `values` are just common presets — a duration like 20s on a 4-30s range model is valid even though 20 isn't in `values`. When `mode` is "enum", only the values in `values` are accepted. The top-level `supported_durations` field is the raw catalog preset list kept for backward compatibility only — `capabilities.duration` is authoritative.

flashloop_list_models

List the saved references the user can put in a generation — characters (people), locations (places) and elements (objects/props). Each kind spans BOTH the curated public library and the user's own rows; `owned_by_me` tells them apart and `owner` filters. Renders a gallery card. An id from here travels to a DIFFERENT field per kind AND per surface, and the wrong field is ignored silently — the render then costs full price and comes back WITHOUT the reference, with no error: create_image → character_ids | location_ids | element_ids create_video → character_mention_ids | location_mention_ids | element_mention_ids Ids are opaque values copied from the rows returned here, not derived from a name. A place in the character field attaches nothing, and describing a saved location in the prompt alone attaches nothing either. Only rows with `status: "ready"` can be referenced; one still generating has no image yet, so it attaches nothing either. The curated shelves are large and this endpoint cannot page or search server-side: `search` narrows the result, and `counts` and `truncated` show what was not returned. It applies when the user asks about their saved references or wants one in a generation; a subject with no saved reference is described in the prompt instead.

flashloop_list_references

List available voices: the built-in presets plus the user's own cloned voices. The returned `id` values feed `voice_id` in generate_voiceover and change_voice. Voices with `model: 'gemini-3-1-voiceover'`, `'gemini-3-8-flash-voiceover'` or `'gemini-3-8-flash-lite-voiceover'` only work with that generate_voiceover model_id (and vice versa — default/ElevenLabs voices don't work on the gemini models). Cheap to call.

flashloop_list_voices

Open an interactive upload widget where the user picks one or more local reference images from their device. It needs no sandbox network access, which makes it the option when the curl command of flashloop_upload_media is blocked or there is no code-execution environment. `model_id` (from list_models) sets the widget's limits: how many images, accepted formats and max file size for that model. Each file is uploaded and moderated immediately; when the batch finishes the widget posts all resulting URLs into the conversation by itself (a 'Done' button appears only when the host refuses that post). Those URLs are accepted by `reference_image_urls`. The widget accepts images only; video/audio references are uploaded with upload_media from a public URL.

flashloop_upload_widget

Rename one of the user's own saved references, and re-file an element's category or a character's role. Curated library rows and other people's rows cannot be edited. The PICTURE is deliberately not editable here. It is what every later generation references, and it was moderated when the row was created — a different look is a new reference, not an edit to this one. Save the new picture with upload_reference instead.

flashloop_update_reference

Save an image the user ALREADY has as a reusable reference. FREE and INSTANT — nothing is generated, the image is stored as-is and the row comes back ready to use immediately. This is the natural way to turn something you just made into something reusable: generate a portrait with create_image, show it to the user, and when they like it save it here. It costs nothing and there is no wait. kind 'character' — a PERSON. `name` is required (it is how the user will refer to them) and exactly one image is saved. There is no autofill on this path. kind 'element' — an OBJECT or prop. Saves a whole batch in one call; name and category are filled in server-side per image. Every URL is moderated and ONE blocked image rejects the WHOLE batch. There is no upload path for LOCATIONS — use create_reference to generate one. To generate a person from a description rather than save an existing picture, generate the portrait with create_image first and then save it here.

flashloop_upload_reference

Create a Faceless video project in the user's Faceless Studio, free of charge. Returns `series_id` and one `project_id` per episode. Pass that `project_id` to flashloop_exec to build the episode in its own sandbox, then upload the finished video with flashloop_upload_media and register it with flashloop_finish_video. A user can have at most 8 videos in progress.

flashloop_start_video

Translate spoken audio into another language while preserving the voice. Async — returns a `job_id` (kind `voice_generation`); call wait_for_job for the translated audio URL. `audio_url` accepts a raw public URL or a url returned by upload_media. `target_language` is a language code/name; `voice_id` (from list_voices) is an optional voice override.

flashloop_translate_audio

Upload a media file so it can be used as a reference in create_image / create_video, or registered as a finished video. Four input paths, by where the media lives: (1) a file in a code-execution environment (the Flashloop sandbox of flashloop_exec, or the chat's own: attachments on claude.ai and ChatGPT are written there as a real file): pass `filename` + `content_type` (no url, base64 or files) to get an `upload_url`, a `public_url` and a curl `command`; run that command in the environment, replacing <file> with the file's path, to send the bytes straight to storage (no size limit from the tool call, no token cost). The file is then served at `public_url`. Two outcomes: a reference or file the user brought (no `project_id`) belongs in the user's Assets, so call this tool again with `url` set to that `public_url` (and `kind`, `content_type`) to register it there and have it moderated; a file made for a Faceless video project (pass its `project_id` from flashloop_start_video) is never registered as an asset: hand the `public_url` to flashloop_finish_video, which files it under Faceless Studio. A client's own sandbox may need the storage host in the `command` allowed in its network settings; when the curl is blocked, use flashloop_upload_widget. (2) a public URL: pass `url` (up to 100MB); (3) files auto-populated by ChatGPT (openai/fileParams): pass them as `files`; (4) a tiny file (up to 100KB): pass `base64` + `content_type`. Base64 is emitted token by token, so it stalls for minutes above ~100KB and fails past 500KB. When there is no code-execution environment, flashloop_upload_widget lets the user pick the file. Returns an `asset_id` and a `url`; the `url` is accepted by `reference_image_urls` in create_image / create_video. Uploaded media is moderated; rejected media can't be used. Calls the Flashloop API (https://www.flashloop.ai/mcp).

flashloop_upload_media

Upscale an EXISTING image or video 2x or 4x with Topaz for sharper, higher-resolution output from a file the user already has, not a new generation. Applies to requests to enhance, upscale or enlarge a file; create_image / create_video take a `prompt` and have no source url or factor parameter. Pick a `model_id` from list_models — any entry with `type: 'upscale'` (its `upscale_input_type` field says whether it takes an image or a video; this tool reads that field to route the request, and the wrong kind of source for the model returns an error). `source_url` must already be a reachable https URL; a file attached in chat or in the code-execution environment becomes one through flashloop_upload_media (its description covers the sandbox curl and upload widget paths), which returns the url to pass here. Returns a `job_id`; call wait_for_job for the finished output url, exactly like create_image/create_video. Pricing is NOT something this tool (or estimate_cost) can quote up front: the real charge is computed server-side from the source's actual duration or resolution, not from anything passed to this call. credits_remaining before and after, or the completed job's credits_used, gives the real number.

flashloop_upscale

Wait until an async generation (returned as a job_id by create_video/create_image and the voice/character tools) reaches a terminal state, then return its result (status + URLs). A timeout means the job is still processing; calling wait_for_job again with the same job_id keeps waiting and nothing is lost. The card rendered by create_image/create_video already shows the generation to the user live.

flashloop_wait_for_job

Return the signed-in Flashloop user's identity, credit balance, and subscription. Shows which account is acting and how many credits it has.

flashloop_whoami