MCP server

FilmLab

com.thefilmradar/filmlab

Checked 28 Oct 2026, 09:03 UTC · Connected to it and listed its tools

AI film lab for filmmakers: generate and review images/clips with input provenance, cost preflight

Website

At a glance

Type

MCP server

Publisher

thefilmradar.com (verified by the MCP Registry)

Status

Working at last check

Tools

141

Token cost

About 80,660 tokens per request

Sets up in

Claude Code, Claude Desktop, Codex, Gemini CLI, Cursor, VS Code, Antigravity, ChatGPT, OpenAI API, Grok

Last checked

28 Oct 2026, 09:03 UTC

Connect it to your agent

Add to CursorAdd to VS CodeVS Code Insiders

Opens the app, which shows the server and asks you to confirm. For other apps, copy the setup below.

Claude Code

claude mcp add --transport http filmlab https://mcp-lab.thefilmradar.com/mcp

Claude Desktop

Settings → Connectors → Add custom connector, and paste the URL.

Codex (config.toml)

[mcp_servers.filmlab]
url = "https://mcp-lab.thefilmradar.com/mcp"

Gemini CLI

{"mcpServers":{"filmlab":{"httpUrl":"https://mcp-lab.thefilmradar.com/mcp"}}}

Cursor

{"mcpServers":{"filmlab":{"url":"https://mcp-lab.thefilmradar.com/mcp"}}}

VS Code

{"servers":{"filmlab":{"type":"http","url":"https://mcp-lab.thefilmradar.com/mcp"}}}

Antigravity

agy mcp add filmlab https://mcp-lab.thefilmradar.com/mcp

ChatGPT

Settings → Apps & Connectors → Advanced settings: turn on Developer mode, then Create a connector and paste the URL. Which plans can do this varies.

OpenAI API (Responses tools)

{"type":"mcp","server_label":"filmlab","server_url":"https://mcp-lab.thefilmradar.com/mcp","require_approval":"always"}

Grok (xAI API tools)

{"type":"mcp","server_label":"filmlab","server_url":"https://mcp-lab.thefilmradar.com/mcp"}

Tools

• lab_abgleich ~348 tokens
  Prompt check of ONE generated image or clip: does the result show what its prompt asked for? The backend first DESCRIBES the result without seeing the prompt, then splits the prompt into checkable claims (counts as digits, quoted text, identity, place, framing, style; for clips the motion) and score
• lab_add_clip ~765 tokens
  Append a shot to a sequence's timeline. Call it once per shot, in cutting order — `start_time` is computed from the clips already there, so appending in order is enough. The continuity pass reads exactly this timeline: a shot missing here is a shot nobody checks. Returns the new clip's index and the
• lab_add_media ~688 tokens
  Bring your own video, audio or image into a project — not generated, yours. Two ways: `media_url` (a public http(s) address; the server fetches it, max 100 MB) or `file_name` + `content_type` (you get a signed `upload_url` and the `header` that are part of its signature: PUT the file's raw bytes the
• lab_analyze_location_image ~263 tokens
  Read a photo and extract location fields from it (Gemini Vision, costs credits — exact price via get_cost: true). Returns the fields — it does NOT create a board; feed the result into lab_create_location yourself. Note the payload: the image travels as base64 inside the call, so keep it small (a dow
• lab_animate ~4626 tokens
  Animate a completed image into a clip with a video model. Pick the model from lab_list_models; check the price with get_cost or let the user confirm a card via lab_propose. Costs credits when called without get_cost.
• lab_animate_batch ~2279 tokens
  Animate MANY images into videos in ONE call (max 25 jobs). Prefer this over looping lab_animate: it validates every job BEFORE spending any quota, so an invalid job 12 of 15 does not leave 11 paid-for generations running. Quota is spent once, collectively (one ledger row); refunds stay per-clip, so
• lab_apply_rhythm ~662 tokens
  Compute the sequence's clip durations from the project's cutting preset and — when the tempo allows it — pull the cut points onto the measured beat grid. WRITES the timeline; costs nothing. The old duration of every changed clip is kept in `clip.metadata.dauer_vorher`, so one undo step exists (a sec
• lab_aufloesung ~610 tokens
  Break one scene down into a STRUCTURED shot list of 2, 4 or 6 shots — each with shot size, camera angle, purpose and its own ready prompt, plus one shared floor plan (anchor, axis, light) so the shots cut together. Two families: an 'aufloesung' shows ONE moment from several angles (coverage, dialog,
• lab_auto_lauf ~480 tokens
  Auto run with a hard spending cap: the person approves ONE run with an upper limit in credits; inside it you may generate without asking per item, but never above the cap. aktion: anlegen (project_id + deckel_credits → status 'angelegt', nothing can be spent yet) · freigeben (ONLY after the person e
• lab_auto_storyboard ~1174 tokens
  Auto-generate a storyboard from either script OR situationen (mutually exclusive). An LLM splits script into scenes; situationen bypasses that LLM entirely and generates exactly one frame per entry, ignoring max_scenes. situationen requires figur_id of an existing character sheet with a reference im
• lab_batch_status ~213 tokens
  Aggregated progress of a video batch started by lab_animate_batch. Returns {total, completed, failed, pending, done, items[]} — poll this ONCE per batch instead of calling lab_job_status per clip. `done: true` means nothing is pending any more (some items may still have failed). Each item carries re
• lab_beat_clips ~460 tokens
  Turn the still-image clips of a sequence into video clips that exactly fill their beat-snapped slots. Free — this tool itself generates nothing. aktion plan: one job per image clip, ready for lab_animate_batch — start image, the frame's motion (bewegung_en), and the SMALLEST duration the model can d
• lab_beatgrid ~751 tokens
  Measure the TEMPO of the sequence's bound music track and store the beat grid — opens the real file with ffmpeg and analyses it, no guessing and no provider, so it costs nothing but a few seconds. Writes `bpm` and `metadata.beat_grid` on the audio row; it does NOT touch the timeline (`timeline_geaen
• lab_bilder ~440 tokens
  See a clip at EXACT seconds: up to 12 frames, in the order you list them, tiled into one image and shown. Use it to check what is on screen where you plan a cut, whether a motion has ended, or whether a face drifted between two moments — lab_contact_sheet spreads frames evenly and cannot answer 'wha
• lab_bind_audio ~608 tokens
  Bind the project's generated audio to a sequence's tracks — ONE call that does both halves of the job, because doing only the first half silently produces a silent film. Half one (`POST …/soundmix`) creates the four empty tracks (dialog, music, sfx, atmo); half two (`POST …/soundmix/resolve-stems`)
• lab_capture ~464 tokens
  See the CUT at exact seconds of the finished film: up to 12 frames, tiled into one image and shown. Each second is mapped like the export maps it — which clip is on screen, where in its source (src_in_s counts), the export's framing (scaled and letterboxed), title cards drawn. A video whose source i
• lab_cast_autopopulate ~236 tokens
  Create character sheets for the people found in a project's material — the writing counterpart to lab_cast_gaps. Creates at most 6 per call and binds each to the project. Costs an LLM run per call. Run lab_cast_gaps first if you want to see what it would create. The sheets it creates have NO referen
• lab_cast_gaps ~220 tokens
  Find people who appear in a project's material (script / cast module) but have NO character sheet yet. Returns up to 6 `missing` entries, each with a name and a short hint from the text. It creates nothing — lab_cast_autopopulate does that. Costs an LLM run, so it is credit-gated. Fail-open by desig
• lab_contact_sheet ~434 tokens
  Build a contact sheet for a generated clip — N frames spread evenly over its runtime, tiled into ONE image — and show it. This is how a clip gets judged at all: MCP has no video content type, so without a sheet a clip is just a URL and a promise. It is also the fastest way to SEE camera drift: measu
• lab_continuity_check ~432 tokens
  Start the continuity pass over a sequence — every shot is compared against its PREDECESSOR and, with check_references, against the character and location reference boards. This is the pass that catches drift (the flat that changed between two shots, the cardigan that turned into a coat), which is th
• lab_create_character ~686 tokens
  Create a character sheet for a human, animal or creature in the cast register. The backend derives an English `prompt_prefix_en` from the fields you give — that prefix is what later describes this character in every image, so the richer the description, the more stable the identity. This is step 1 o
• lab_create_location ~431 tokens
  Create a location board. The backend derives an English `prompt_prefix_en` from the fields you give — that prefix is what later anchors every image and clip shot there, so the richer the description, the more consistent the place. Pass project_id to bind the board to a project (recommended: unbound
• lab_create_project ~214 tokens
  Create a new FilmLab project. Returns the new project id and its `datenmodus`. Optionally set a title and the data mode: 'eu' keeps the project on models whose data path is proven inside the EU (lab_list_models eu: true lists them; other models are refused with alternatives), 'frei' allows every mod
• lab_create_prop ~197 tokens
  Create a named prop (Requisite) in this project. Free, no model call: its prompt prefix is built deterministically from the fields. Returns its @prop_ tag for shot prompts. To generate views use lab_prop_ansichten separately (costs credits).
• lab_create_sequence ~211 tokens
  Create a sequence (Stage 9 timeline) inside a project — START HERE to turn generated shots into something the continuity pass can read. The new sequence is EMPTY: add shots with lab_add_clip before anything else works. lab_continuity_check rejects an empty timeline with 400. Returns the sequence rec
• lab_create_stil_kit ~297 tokens
  Create a style kit in this project: rules (English text), palette (#RRGGBB) and up to three reference images taken from this project's own images (image ids). Free, no model call. Set als_standard to make it the project default, which then runs in every image and clip of the project (switch it off p
• lab_delete_location Deletes data · ~205 tokens
  DELETE a location board permanently. There is no undo and no soft-archive — the row is removed. Images and clips that were generated with this `location_id` keep their already-rendered prompt, but the board they point at is gone: nothing can be re-anchored to it, and lab_get_location will 404. Confi
• lab_depth_map ~631 tokens
  Create or read a depth map for a project video in FilmLab: use it for fog, depth of field, relighting or occlusion. Near is white, like Resolve's Depth Map. Free on our own CPU, no credits; processing takes minutes. modell: v2 (default) is Depth Anything V2, sharpest edges. vda is Video Depth Anythi
• lab_diagnose ~230 tokens
  Is everything wired? Backend reachability and latency, identity, credit check, catalog age, last error of this account, host widget support. Traffic light plus one sentence per point. Read-only, free.
• lab_dossier ~484 tokens
  Build a dossier of a project's takes: one ZIP with an offline index.html (no external resources) plus the media files, named Project_SceneNN_YYYYMMDD-Tnn.ext. modus 'kunde' is for a client and NEVER shows seed or costs, whatever the switches say; 'intern' shows everything that helps to rebuild a tak
• lab_dub ~1211 tokens
  Dub a sequence into another language: either a ready audio track (en_audio_url — e.g. the one lab_dub_tts just produced) OR a cloned voice reading a line of text (voice_id + dub_text), then a controlled visual lipsync runs over the sequence's own footage (ROI-crop + composite for a long static talki
• lab_dub_tts ~464 tokens
  Generate the EN-dub audio track for a sequence via ElevenLabs TTS — SYNCHRONOUS, returns a ready audio_url immediately, no job_id and nothing to poll. Optionally pads the track with silence up to the sequence's own length so a shorter reading doesn't shorten the final cut. Feed the resulting audio_u
• lab_dub_voices ~144 tokens
  List the ElevenLabs TTS voices available for lab_dub_tts's `voice_id` — this is the EN-dub-track text-to-speech voice list, NOT a project's cloned voices (those are lab_list_voices). Reads only — no state changes, no credits. If ELEVENLABS_API_KEY isn't configured on the backend the list comes back
• lab_enrich_location_prefix ~258 tokens
  Append context to a board's `prompt_prefix_en` (plain string concatenation server-side — no AI call, no quota). Idempotent: context already present in the prefix is not duplicated. This does NOT rewrite or regenerate the prefix — for a board whose prefix is empty, too thin or a raw field dump, use l
• lab_export_profiles ~197 tokens
  List the available export delivery profiles (web, social_vertical, social_youtube, streaming_hdr, cinema, master, alpha_prores4444, alpha_png_sequence) and quality presets (draft, standard, high). Call this before lab_start_export to pick a valid profile/quality. The two alpha profiles keep transpar
• lab_fassungen ~715 tokens
  Use when the person asks about earlier states of a cut, wants to go back to a previous version, compare versions, name a version, or create a second cut (e.g. a short version next to the long one). The history and the versions of ONE cut (sequence). Every timeline write (lab_timeline_apply, the edit
• lab_feedback ~461 tokens
  Tell the FilmLab team about a bug or a missing feature — it reaches the people who can fix it, the chat does not. Use art 'fehler' when a tool returned something wrong, failed without a clear reason, or contradicted its own description; 'wunsch' when a step you needed does not exist. Write what you
• lab_fertigstellen ~352 tokens
  Finish an accepted DRAFT (a lab_reference_motion run with draft: true) in 1080p — same motion, same seed, same sound, sharper picture. A NEW video row comes back; the draft stays. Works only while the draft is valid and only through the account that ordered it; otherwise the backend refuses with a n
• lab_flow_angebot ~556 tokens
  Use when the person wants a saved flow, pipeline or multi-step workflow priced, costed, calculated or checked against the balance BEFORE anything runs. Price a whole Flow (Pipeline) before running it: one quote over every node, checked against the credit balance and the project's cost cap. `workflow
• lab_flow_fortsetzen ~338 tokens
  Use when a flow/pipeline run is waiting for approval or a price confirmation and the person gives the go-ahead to continue. Resume a Flow (Pipeline) run that stopped and waits (status 'wartet' with a reason like 'Wartet auf Freigabe'). A run stops when a clip node needs a start image the person has
• lab_flow_starten ~436 tokens
  Use when the person has seen the quote for a flow/pipeline and says to run, start or execute it. Run a Flow (Pipeline) that was quoted with lab_flow_angebot. Pass the SAME workflow and inputs plus the angebot_id — a changed workflow, an expired quote (24 h) or a quote that was already used is refuse
• lab_flow_status ~333 tokens
  Use when the person asks how far a flow/pipeline run is, whether it finished, why it stopped or hangs, or what a step returned. State of a Flow (Pipeline) run started with lab_flow_starten: the run's status (wartet, laeuft, fertig, fehlgeschlagen, abgebrochen) and, per node, its status, attempts, re
• lab_freigeben ~394 tokens
  Release a paused PERSON-reference run (lab_reference_motion with use_depth: 'personen') after the human has looked at its mask preview: this starts the paid model run. Until now only the mask was charged. Show the preview (metadata.personen_referenz_url of the paused clip) first — holes in hair or h
• lab_generate ~3060 tokens
  Generate an image on the production pipeline (fal.ai, quota-tracked, persisted to the project's gallery). Waits up to `wait_s` seconds (default 45) for the image and then answers with the finished rows — image_url set, inline previews attached, so the picture is in the answer like lab_job_status wit
• lab_generate_character_reference ~844 tokens
  Generate the reference sheet for a character — six core views rendered from the sheet's `prompt_prefix_en`: detail (three-quarter close-up, the identity anchor), frontal (frontal close-up), profile, fullbody (front), fullbody_back (back view: hair and the back of the costume) and costume (the outfit
• lab_generate_location_variants ~262 tokens
  Generate time-of-day reference images for a location board (costs credits per variant — check the price with get_cost first). Without `variants` the backend renders all four. The images are what makes a board usable as a visual reference.
• lab_generate_music ~822 tokens
  Generate a MUSIC track for a project — the first step of the rhythm chain, and the only one that costs credits. Default engine: ElevenLabs Music v2.5 (produced, contemporary instrumental beds, 3-300 s, priced per second). Stable Audio stays selectable with tool 'stable_audio' (flat per run, up to 19
• lab_get_character ~340 tokens
  Get ONE character sheet in full — every descriptive field plus the three that decide what you can do with it. `prompt_prefix_en` is the text block describing this person; it is what the backend prepends wherever the sheet is used. `reference_images` decides whether the sheet is usable at all: lab_ge
• lab_get_character_sheet ~426 tokens
  The character sheet PREPARED FOR PROMPTING: base prefix, the state sheets by name, which reference views exist, and the ready-made sentence to paste into a lab_generate prompt. Same source as lab_get_character, different shape — use this one when you are about to generate, and lab_get_character when
• lab_get_context ~152 tokens
  Read the accumulated context/output for one pipeline module of a project (e.g. the IDEE, STORYBOARD or SHOTS stage). Needs project_id and module name.
• lab_get_dossier ~162 tokens
  Poll a dossier job by job_id (from lab_dossier). status is queued|processing|done|failed. When done, result.archiv_url is a signed https link to the ZIP that loads WITHOUT a login and expires after 24 h — call again for a fresh one. result.fehlend lists takes that could not be loaded.
• lab_get_export ~420 tokens
  Poll an export render job by job_id (from lab_start_export). status is queued|processing|done|failed; when done, the result (output url) is included. Call repeatedly until done|failed. NB: this is the EXPORT poll — different from lab_get_generation. Where the address sits depends on the profile: a r
• lab_get_job ~337 tokens
  Get the status of a background job by job_id (status is queued|processing|done|failed). Poll this after starting a long-running generate/export. Returns the job record; its payload and result are objects (for a clip chain: result.zusammenfassung, result.ketten, result.clips). For an Umzug import (la
• lab_get_location ~201 tokens
  Get ONE location board in full — all descriptive fields plus its reference images and `prompt_prefix_en`. Use it to check what a board actually anchors before generating with it.
• lab_get_project ~162 tokens
  Use when the person asks where a project stands: its current stage, what is finished, what comes next, or wants the project's state before continuing. Get a single FilmLab project with its full stage state, including its `datenmodus` ('eu' or 'frei'). Needs the project_id (from lab_list_projects).
• lab_get_sequence ~162 tokens
  Get ONE sequence in full — timeline (the shots in order), audio_tracks, transitions, duration_seconds and render status. Check `timeline` here before starting a continuity pass: an empty one is the single most common reason the pass refuses.
• lab_get_state ~134 tokens
  One call, the whole picture: account (tier, credits, reset), default models with price, jobs in flight, catalog freshness, project count. Pass project_id for that project's sequences, assets and review-queue length. Read-only, free.
• lab_grade ~1412 tokens
  Apply a deterministic colour grade to an image already in the project gallery — no re-generation, no provider, no credits. The look is computed pixel-exact (exposure, saturation, hue, lightness, contrast, film grain) and lands as a new gallery image the sequencer and export pick up. For full control
• lab_grade_clip ~790 tokens
  Set the colour grade of ONE clip in the edit (Murnau), or of the whole programme with `programm: true`. It is the same grade a colourist sets in Murnau's colour workspace, and the export uses it: Murnau bakes the export LUTs when you set it. Only the fields you send change (`zuruecksetzen: true` sta
• lab_grade_from_resolve ~281 tokens
  Suggest a FilmLab grade look from a Resolve LUT name or path — read-only, no cost. First call resolve_node_graph_lesen on the local FilmLab bridge (filmlab_bruecke_mcp.py), a SEPARATE MCP server, and pass its lut field here. The agent connects these two calls: this Cloudflare Worker cannot reach the
• lab_grade_suggest ~209 tokens
  Suggest a grade look for a project — read-only, no cost. With image_id, includes the image prompt; without it, uses only the colorist crew brief. Returns a recommended look name with a reason and alternatives; apply it with lab_grade(look: …) once the user agrees.
• lab_herkunft ~329 tokens
  Declare or list where a project's material comes from: 'eigen' (made by people) or 'ki' (AI-generated or AI-altered). Exports decide the EU AI Act Art. 50 disclosure per clip from this — undeclared material counts as AI. With asset_key + herkunft: declare (the file is checked for an AI mark; one fou
• lab_identitaet_pruefen ~414 tokens
  Check whether still images of a project show the SAME character as its character sheet — before paid clips are made from them. Each image is compared against the sheet's detail and fullbody views. It judges identity (species, build, colouring, head shape, large markings), NOT style, light, pose, pla
• lab_job_status ~921 tokens
  Poll the status of an image or video generation started by lab_generate/lab_animate. There is no single-item status endpoint on the backend — this fetches the project's full image/video list and filters by id, so it needs BOTH project_id and id (the id alone is not enough). status inside the returne
• lab_jobs_inflight ~548 tokens
  Are any FilmLab generations running RIGHT NOW, across ALL projects? Use this before anything that restarts the backend (a deploy recreates the container and kills running jobs, losing paid credits), or to answer 'is the lab busy?'. Unlike lab_job_status/lab_batch_status this needs no id — it lists e
• lab_layers ~846 tokens
  Produce ONE element on a transparent background: generated, then cut out and stored as an alpha PNG in the project's gallery. This is the counter-move to the one-shot lottery — cast, props and foreground pieces are made SEPARATELY, arranged as a set afterwards and only then unified, so a wrong hand
• lab_letzter_frame ~214 tokens
  Extract the LAST frame of a finished clip as a new image (returns image_id, image_url, zu_dunkel). Use it as source_image_id to continue one unbroken take, or as a still. A frame that is too dark (zu_dunkel: true) makes a bad start image — say so instead of animating from black. Free (no credits). C
• lab_list_assets ~376 tokens
  List a project's media assets (image/video/audio) with their URLs. Optionally filter by asset_type. Returns up to 20 with a total count. Each row carries its address as `url` (with `type` and `key`). Project assets come back as SIGNED addresses on https://thefilmradar.com/api/lab/assets/abruf/… — va
• lab_list_audio ~448 tokens
  List a project's generated audio rows, newest first — this is the POLL for lab_generate_music. Read two fields: `metadata.status` ('pending' | 'completed' | 'failed') and `audio_url`. A pending row has no url, and nothing downstream works with it: lab_bind_audio silently leaves the track empty (reso
• lab_list_characters ~437 tokens
  List the character sheets in the FilmLab cast register (id, name, age, gender, project_name, prompt_prefix_en). Call this BEFORE lab_generate whenever a person must look the same across several images: pass the id you find here as `character_refs` instead of re-describing the person in every prompt.
• lab_list_exports ~150 tokens
  List past export jobs for a project (each with job_id, status, profile). Returns up to 20 with a total count. Finished rows carry the same signed, login-free result addresses as lab_get_export (download_url, herkunft.pdf_url, …; valid 24 h).
• lab_list_location_scans ~224 tokens
  List a project's location scans with their reconstruction state — this is the POLL for lab_location_recon and the place the scan ids come from. Read `status`: 'pending' (clip uploaded, nothing reconstructed yet), 'reconstructing', 'done' (splat_url/glb_url/board_url are filled), 'failed' (error says
• lab_list_locations ~350 tokens
  List location boards, newest first — START HERE to find a `location_id` for lab_generate / lab_animate. Each entry carries its `prompt_prefix_en`: that is the exact text appended to your prompt as 'Location: …', so you can judge whether the board fits BEFORE spending quota. A board with an EMPTY pre
• lab_list_models ~617 tokens
  The model catalog: what every video or image model can do — resolutions, durations, aspect ratios, audio, reference limits, price per second or per image — grouped by capability class with a one-line explanation per group. Read this before choosing a `tool` for lab_generate/lab_animate/lab_propose;
• lab_list_project_locations ~177 tokens
  Location boards bound to ONE project. Narrower and more correct than lab_list_locations when you already know the project: it cannot leak boards from a different project with the same title. Boards created before the project binding existed (project_id NULL) deliberately do NOT appear here — use lab
• lab_list_projects ~140 tokens
  List FilmLab projects (id, title, current pipeline stage). Call this first to find a project_id for the other tools. Shows up to 20 items; `total` counts your active projects (up to 200) and `truncated: true` means the list is cut off — sorted by last change, so older projects drop out of the shown
• lab_list_props ~162 tokens
  List the props (Requisiten) of this project, including @prop_ tags, descriptions and generated views. Free. Use the tags in image and video prompts: the description always goes into the prompt, the front view goes along as a reference image in lab_generate and lab_reference_motion.
• lab_list_sequences ~182 tokens
  List a project's sequences: the main sequence (the film, `ist_haupt: true`, also in `haupt_sequenz_id`) first, then newest first. Trailers, opening titles and blocks are sequences too — edit the main sequence unless the person names another. Use it to find a `seq_id` instead of creating a second seq
• lab_list_stil_kits ~155 tokens
  List the style kits of this project (rules, palette, up to three reference images, @stil_ tag) and which one is the project default (standard_id). Free. Write the tag into an image or video prompt to use that kit for this one call instead of the default.
• lab_list_voices ~291 tokens
  List a project's cloned voices (lab_voice_clone results) — id, label, voice house, sample and preview URLs. This is where a `voice_id` for lab_voice_tts or lab_dub comes from, and where you look up which house a voice belongs to before pricing it. Both houses are listed unless you narrow it. Reads o
• lab_lizenz_ablehnen ~139 tokens
  Decline an offered license addressed to your account. Free.
• lab_lizenz_anbieten ~428 tokens
  Offer a license for your own asset or an asset of a studio you can edit. The recipient must be an existing account. No charge until the recipient accepts. On acceptance, the owner receives floor(80% of the price) as non-expiring, spend-only credits; the platform retains the remainder (20% commission
• lab_lizenz_annehmen ~300 tokens
  Accept a license addressed to your own account (studio: owner account). First call get_cost:true, show the exact credits, and obtain confirmation before accepting. Acceptance spends credits through the platform and creates a private PDF certificate. The owner receives floor(80%); the platform retain
• lab_lizenz_nachweis ~150 tokens
  Get a private PDF certificate URL, valid for five minutes. Only for the parties to this license.
• lab_lizenz_widerrufen ~286 tokens
  Owner only: revoke a license, preserving its PDF. First call get_cost:true, show the refund and owner debit, and obtain confirmation. Fixed terms refund remaining inclusive days (full before start); unlimited terms refund fully through day 14 after acceptance, then zero. The owner's 80% share is rev
• lab_lizenz_zurueckziehen ~138 tokens
  Withdraw your license offer before acceptance. Free.
• lab_lizenzen ~75 tokens
  List received and offered asset licenses with their status in the current workspace. Free.
• lab_location_panorama ~270 tokens
  Generate a 360° equirectangular HDRI panorama of a place (costs credits — exact price via get_cost: true). Pass loc_id to persist it on that board, so the viewer finds it again; without loc_id it is a one-off.
• lab_location_recon ~617 tokens
  Reconstruct a real place in 3D from a scan clip: keyframes are pulled from the clip server-side and turned into a point cloud / splat on the location board, so a scouted room can be looked at from angles nobody filmed. THE SCAN IS NOT MADE HERE — it is a walk-around clip uploaded by the FilmLab came
• lab_look_in_post ~349 tokens
  Read or set a project's 'look in post' flag. Use it when the person grades in DaVinci Resolve with the FilmLab Look plugin and wants the lens and film look applied there instead of baked into the generated pictures. With project_id only: read. With look_in_post true, image and video prompts of the p
• lab_look_match ~508 tokens
  Check the colour CONTINUITY of a scene in the edit (Murnau): every shot is compared with the scene's reference shot (the first, or `referenz_clip_id`) at the SAME scene points — found by feature matching (ORB + homography) between the two frames, each rendered through its export path. Image-wide sta
• lab_mix ~812 tokens
  Set the sound mix of a sequence: per track `volume_db`, `pan`, `mute`, `solo` and `effects`. Every field you send is rendered — the backend rejects what it cannot render (422 with the reason), so a saved mix is the mix you hear. Tracks are the stems `dialog`, `music`, `sfx`, `atmo`, plus `master` (e
• lab_mix_messen ~310 tokens
  Measure the RENDERED mix: integrated loudness (LUFS), true peak (dBTP) and loudness range (LU) of the master, measured on the mixdown file itself. Per stem the same values, speech-gated (under the dialog / in its pauses), and how many LU each stem sits under (or over) the dialog in dialog passages —
• lab_mix_render ~458 tokens
  Render the sequence's mixdown, normalised to a loudness target: `broadcast` (EBU R128), `web` or `youtube`. With `auto_preset` it runs the AUTO-MIX instead: it measures every stem speech-gated (under the dialog vs. in its pauses), sets faders, ducking and a master limiter by the preset (`spielfilm`:
• lab_neue_winkel ~1496 tokens
  Re-shoot one clip from NEW camera angles: same people, same words in the same timing, same place — only the camera changes, cutting on the spoken lines, as if several cameras had been rolling. This tool plans and checks; it never generates and never charges. Workflow: look at the clip with lab_bilde
• lab_playbook ~250 tokens
  The rules of one working surface, generated from the code: what the surface is, what an agent can trigger itself, what exists but only by hand, and what does not exist at all. Call this BEFORE answering what is possible on a surface — the three lists come from a table with a code reference per entry
• lab_prompt_transform ~1797 tokens
  Turn a loose idea into a production-ready image or video prompt — the same Dreamer engine the FilmLab web UI uses (modes: beautify, storyboard, polish, format, shorten, expand, simplify, custom, stiluebernahme). beautify GENERATES (a 50-character thought comes back as a full prompt); polish/format/s
• lab_prop_ansichten ~225 tokens
  Generate product-photo views of a prop using Flux 2 Pro. Costs credits per view: front is text-to-image, side/back/top/detail edit the front anchor. First call with get_cost:true, name the exact credits to the person, and obtain confirmation before generating. Missing images are refunded.
• lab_propose ~1984 tokens
  Propose a generation for the user to confirm: validates the parameters against the catalog, computes the price, and shows a card (widget hosts) or returns the same object as text. Every prompt goes through the Dreamer first: run it through lab_prompt_transform before proposing (lab_generate/lab_anim
• lab_reference_motion ~4651 tokens
  Render a new clip FROM the motion of an existing one: your reference clip leads (camera move, blocking, timing), the model restyles what happens in it. Pass the clip's URL directly — the one you already have from lab_list_assets (asset_type 'video'), lab_job_status or lab_review_queue; nothing is lo
• lab_referenz_aus_bild ~520 tokens
  Attach an existing project image (an image_id from lab_umzug, lab_get_job result.bildzeilen or lab_generate) as reference: `ziel: 'figur'` makes it a view of a character (default view 'detail', the face anchor). `personenbezug` is REQUIRED for a character and has no default: 'keine_reale_person' or
• lab_regie_techniken ~475 tokens
  Use when the person asks HOW to stage or shoot a feeling or effect (which angle, movement, framing or light makes a scene feel tense, tender, triumphant, uneasy) or wants directing options for a shot. Directing techniques: camera angle, framing, composition, movement, lighting and atmosphere (haze,
• lab_render_frames ~473 tokens
  See the DELIVERED film: up to 12 frames from the finished export (lab_start_export → lab_get_export status done), tiled into one image and shown. This is the rendered picture WITH everything the render adds — lens/grade, lower thirds, title cards and the AI badge — so use it to check the result, e.g
• lab_restyle_location ~285 tokens
  Restyle an existing board towards a wish (costs credits — exact price via get_cost: true) — same place, different look, e.g. 'the same flat, twenty years later'. Changes the board itself, so images generated afterwards follow the new style. Also the repair path for a board whose prompt_prefix_en is
• lab_review_asset ~441 tokens
  Review generated assets: set verdict (accepted|rejected|pending) and/or selected. Pass ONE id, or `ids` for a bulk review — after a generation run there are usually dozens to sort, and clicking through them one by one is why the review fields went unused. Rejected assets drop out of the default list
• lab_review_queue ~798 tokens
  Browse GENERATED rows (images or videos) — newest first, each with the INPUTS it ran on. Every row carries `inputs[]` (start/reference images, reference videos, character refs — role + url) and `params` (model, mode, resolution, seed…). Read those before comparing two runs: a run without its inputs
• lab_rezept_montage ~958 tokens
  The Montage recipe: one recurring character in 8–16 independent everyday gags, cut on the beat into a 9:16 reel of about 6–11 seconds with a music bed. It runs the existing steps in order — gags (lab_situationen), stills with the character and the phone-flash look (auto-storyboard 9:16), identity ch
• lab_run_module ~255 tokens
  Run ONE pipeline module for a project (context is injected from upstream modules + crew agents). SYNCHRONOUS and LLM-heavy: light modules return in seconds; heavy ones can exceed ~55s and then time out (504) — run those in the FilmLab web app instead. Pass an invalid module name to get the list of v
• lab_run_proposal ~563 tokens
  Run a proposal exactly as shown — same model, same parameters, same price. Called by the card's button, or by you after the user confirmed. Single use: the proposal is consumed BEFORE the run, so a second call is refused instead of paying twice. Valid 15 minutes, for the account that created it. Cos
• lab_schnitt_export ~355 tokens
  Export ONE sequence as an editing file for DaVinci Resolve, Premiere or Final Cut, so the cut can be finished there. Costs nothing. fcpxml (recommended for Resolve): V1 as the main storyline with gaps, the sequence's transitions as centered cross dissolves (dropped where the next clip has no head or
• lab_scopes ~410 tokens
  Measure ONE clip of the edit as numbers instead of a picture: a frame is rendered through the clip's export path (input profile, grade LUT, secondary correction) and measured — luma percentiles (P1/P50/P99, Rec.709), mean R/G/B, green excess (G minus the mean of R and B: >0 green cast, <0 magenta),
• lab_search_catalog ~122 tokens
  Search the FilmLab universe catalog of AI tools, news and companies. Query must be at least 2 characters. Returns up to 20 matches with a total count.
• lab_sfx ~1535 tokens
  Generate or CLEAN UP a SOUND track other than music — sound effects, ambience/atmosphere, dialog, a voiceover, FOLEY scored to an existing clip, or the repair kinds that take an EXISTING recording apart instead of inventing one: denoise (take the noise out), split (separate it into stems), isolation
• lab_shots ~424 tokens
  Read the SHOT layer of a sequence — which clips form one shot, which scene it plays in, who is in it, and what the continuity pass found. This is the layer above the timeline: lab_get_sequence gives you clips in a row, this one gives you the cut. Costs nothing, writes nothing. Use it before changing
• lab_shots_ableiten ~354 tokens
  Derive the shot layer from what the clips already say about themselves — consecutive clips of the same scene become one shot, and a scene that returns later becomes a second one (one location cut into twice is two shots). Costs nothing: it groups rows and reads titles, it generates nothing. Titles c
• lab_shots_setzen ~787 tokens
  State the shot cut yourself: which clips form one shot, what it is called, which scene it plays in. This is the counterpart to lab_shots_ableiten — that one groups by the scene the clips already name, this one is for the judgement no field carries. Costs nothing. Use it where derivation cannot reach
• lab_situationen ~302 tokens
  Suggest independent visual gags for a character and theme. Free text generation, no images or credits spent. Returns anzahl entries with titel, bild_en and bewegung_en: one moment and one strong action each, no story sequence or references between entries. figur accepts a character-sheet id (uses it
• lab_start_export ~1172 tokens
  Start an ASYNC export render of a project sequence. Returns a job_id immediately (status 'queued') — does NOT block. Then poll lab_get_export with that job_id until status is done|failed. Needs the sequence_id to render (an integer from the project's sequences). `derivatives` asks for extra cut-down
• lab_stems_export ~340 tokens
  Hand the sound over to whoever mixes next (Resolve/Fairlight, Pro Tools, a dubbing studio): every stem of the sequence (dialog, music, sfx, atmo) as a 24-bit / 48 kHz stereo WAV, rendered the way it goes into the mix — effects, fader, pan and ducking baked in — plus an M&E file (music + effects + at
• lab_stil_kit_standard ~138 tokens
  Set the project's default style kit (it then runs in every image and clip of the project), or clear the default by omitting stil_kit_id. Free.
• lab_suggest_durations ~308 tokens
  Ask what clip durations the project's cutting preset WOULD give a sequence — and change nothing (`angewendet: false`). Use it to see the consequence before lab_apply_rhythm writes it, or to size a sequence that has no clips yet (pass `anzahl`). It knows nothing about the measured beat grid: the temp
• lab_timeline_apply ~1627 tokens
  Write a WHOLE cut into a sequence in one call — clips in order with their lengths, an optional dissolve between them, an optional bed underneath. This is the counterpart to lab_get_sequence: that one reads the timeline, this one writes it. Prefer it over a chain of lab_add_clip calls whenever you al
• lab_ton_durchlauf ~546 tokens
  Generate SOUND EFFECTS for a whole sequence, shot by shot — Simon Meyer's pass: every shot is muted, padded with black frames up to the model's minimum length, re-rendered by Seedance 2.5 in editing mode at its low resolution with sound on, and only the generated sound is kept, stretched back to the
• lab_transform ~832 tokens
  Relight and restyle an EXISTING clip while the performance stays untouched (Beeble Switch X): lighting, background and props change, the subject and its motion do not. The source is the clip of a generated-video row — or, with asset_id, an uploaded file that stands in for it. in_sec/out_sec cut the
• lab_umzug ~736 tokens
  Bring Midjourney exports into a project (FilmLab calls this 'Umzug'). Midjourney has no API, so the person downloads their images or ZIP and this tool carries them on. Give EXACTLY ONE of: `dateien` (names/types/sizes of local files → signed PUT addresses with a ready curl line; PUT the raw bytes, t
• lab_upscale ~624 tokens
  Enlarge an EXISTING clip (Topaz, passed through fal): same shot, same length, same sound — more pixels. There is no prompt here; nothing is re-imagined, the frames are scaled. The source is the clip of a generated-video row. Both the length and the source height are measured server-side before anyth
• lab_verkettung ~1204 tokens
  Render several clips as CHAINS: within a scene one after another (continuity), across scenes in parallel (speed) — the plan follows scene_ref of each job in order. aktion: plan (free: shows the chains) · preis (free: same checks as a real start; returns preis_geschaetzt_credits, preis_hoechstens_cre
• lab_vfx ~874 tokens
  Run a VFX operation on an image already in the project gallery — the same pipeline the Resolve bridge uses. inpaint (clean plate: what is inside the box disappears, the surroundings close over it) · replace (same path, other intent: something new goes into the box) · relight (no box — the light chan
• lab_vfx_preset ~373 tokens
  Run a video VFX preset on a whole clip. Today only 'gesichter_verpixeln' (pixelate every face) is live. Costs credits per frame — call with dry_run=true first to see the price. With rerender_from (a finished job_id) it re-renders for free with other settings, e.g. exceptions: object ids that stay sh
• lab_vfx_preset_status ~176 tokens
  Poll a video VFX preset job. status is queued|proxy|spur|render|done|failed; progress shows frames done. When done: result_url is the finished clip (give it to the person as karte_ansehen), kontakt_url is the review contact sheet, spur.objekte lists detected faces with ids usable as exceptions in la
• lab_vfx_status ~143 tokens
  Poll a VFX operation started with lab_vfx. status is pending|processing|done|failed; when done, result_url carries the finished image. Call repeatedly until done|failed — an image run usually takes under 30 seconds.
• lab_voice_clone ~913 tokens
  Clone a voice from real audio or video material into a project (fal.ai minimax voice-clone) — the source for lab_voice_tts and for lab_dub's voice_id+dub_text path. SYNCHRONOUS: the clone runs inside the request and can take a while to return; there is no job_id to poll. The source needs a clean spe
• lab_voice_tts ~516 tokens
  Speak text in a project's cloned voice (via lab_voice_clone) — SYNCHRONOUS, returns a ready audio_url, no job_id. The voice house is whichever one cloned this voice; you do not pick it here. Consent-sensitive like the clone itself: only speak text you have the right to put in that voice's mouth.
• lab_wellenform ~366 tokens
  Read the sound of a clip (video_id), an audio track (audio_id) or an uploaded file (project_id + asset_key from lab_add_media) as numbers: peak level 0..1 per channel, 16 values per second, up to 60 s per page. Use it to find where music or speech starts, where silence is (below `stille_unter`), and
• lab_welt ~514 tokens
  Build a walkable 3D WORLD (Gaussian splat, World Labs Marble) from ONE location picture (costs credits — exact price via get_cost: true). Source: a location board's time variant (loc_id + variante) OR a gallery image of the project (quell_bild_id). stufe 'entwurf' is a cheap draft (about a minute),
• lab_welt_status ~216 tokens
  Status of a world from lab_welt: processing | completed | failed. When completed, `studio` is the link to walk it and save angles (free). A failed world has been refunded. Read-only, free. Pass wait_s (up to 15) to wait inside the call.
• lab_whoami ~167 tokens
  Who is connected: the FilmLab account (email, user id, name, tier, credits) and how this connection signed in (oauth, oauth_geraet, bridge_key, legacy service user, or anonym). For a device sign-in it also lists the device limits (projects, credits, end date). Call it when results look like someone
• lab_widerruf ~375 tokens
  Record a correction in the FilmOS knowledge layer when the user contradicts something you asserted from it. Use this the moment a contradiction is stated — not at the end of the session, and not instead of accepting the correction in your answer. It stores the claim AND what is actually true, owned
• lab_wissen ~386 tokens
  Use when the person asks a film-craft question: what a term means, which rule or convention applies, how something is usually done in camera, editing, sound or production — answer from here, not from memory. Ask the FilmOS knowledge layer — measured craft knowledge from vetted sources, with the KNOW
• lab_wortzeiten ~480 tokens
  Every spoken word with its start and end time, for a clip (video_id), an audio track (audio_id) or an uploaded file (project_id + asset_key). Use it to cut pauses without cutting into a word, to time captions, or to land a graphic on an exact word — instead of guessing seconds from the waveform. Up
• lab_zielgruppe ~579 tokens
  Read or set a project's audience (zielgruppe) and target markets (zielmaerkte). With project_id only: read. Set zielgruppe 'kinder' or 'jugendliche' whenever the project is made for children, families or teenagers — do it BEFORE creating characters or generating. That switches on blocks for the whol

Browse

• Website monitoring
• Video generation and editing
• Music and audio
• Calling other AI models

Related MCP servers

• PageToVid
  Turn any web page into a narrated video: films the real site, writes, voices and captions it
• Director's Lookbook
  670+ named visual and music styles: deal a look for a feeling, get paste-ready AI prompts.
• aicut
  Generate AI videos, images, audio and staged AI Video Story episodes, and publish them to social.
• Uwear
  AI photoshoot studio: garments, avatars, locations, and art direction
• footage.cool: 4K Drone & Aerial Stock Footage
  Search and license 54,000+ drone, aerial, and ocean clips, mostly 4K, from filmmaker Phil Maher.
• Vidreno
  Publish films, monetise them, earn money, and host and embed videos on sites and apps.
• nanoodle
  Your saved nanoodle workflow graphs as MCP tools — BYOK or pay per call in Nano (x402)
• oriiion
  Your marketing, a message away

Badge for your README

[![AptLynx](https://aptlynx.net/badge/com.thefilmradar/filmlab.svg)](https://aptlynx.net/servers/com.thefilmradar/filmlab)

Listing text is written by the maker; AptLynx lists tools and does not vouch for them. Find another tool · Browse by topic · For agents