NodeTool Cloud is in alpha. Direct films and run workflows in the browser, on your own keys.NodeTool Cloud is in alpha. Try it →
AI workflow templates
Ready-to-run NodeTool workflows for image, video, audio, agents, and marketing. Open one in Studio, connect your keys, and run it, then rearrange it to suit your own work.
Templates are editable workflow graphs: inspect the nodes, change the connections, and make them your own. To learn more, read how node-based AI workflows work.
Looking for the whole job?
A recipe chains several of these templates in order and ships that chain inside Studio, with the keys each step needs and where the money goes.
AI mini apps
A mini app is a screen over one or more workflows. The person running it sees fields, a Run button, and a result instead of the graph. These ship with Studio, and you can build your own from any workflow. Read the mini apps guide.
Photo Studio
A live photo editor and a batch retoucher. The single-photo grade runs on GPU filters with no API key.
Directed Campaign Kit
Upload one product image, approve a hero, then build two formats and one revision.
Dubbing Desk
Transcribe a presenter clip, translate the script, then voice and subtitle the translation.
Model Arena
Three models answer side by side, then a judge model scores them without knowing which wrote which.
Catalog Motion
Upload a product catalog as CSV and every product photo becomes a short video.
Trailer Room
One agent writes the beats and the shot list, renders every shot, cuts them together, and adds a score.
Image & Design

Draw a studio pass card as vector art, with an aurora of blurred gradients, film grain and a sparkline, then rasterise it to a 1600×960 PNG. Runs with no model or key.

Generate a 3:4 portrait poster from a prompt. Change the subject, colors, and style to make your own.

A seamless tile for backgrounds. Prompting for the tiling explicitly matters — an unseamed texture is visibly wrong the moment it repeats.

Square cover art. The aspect ratio is the requirement here — every platform crops to it, so generating anything else creates work.

Turn a brand name and vibe into a whole social kit in one run: the graph fans out to two branches at once — a streamed gallery of four on-brand, text-overlaid social images (Instagram, LinkedIn, X, product launch) and a one-page brand brief (voice, palette, tagline options). Differentiator: structured multi-asset outputs from a single fan-out graph. Each model step uses your default model for its type, and the image steps are paid.

An orbital poster drawn from circles, ellipses and lines in one Code node. The array order is the paint order, so the planets pass in front of the sun.

Fan one creative brief into a gallery of concept-art variations. An art-director agent turns your brief, style, and mood into a detailed direction, then a list generator writes N distinct image prompts that all render into an append-style variant gallery. Differentiator: one run, many on-brief variations you can compare side by side and regenerate. Each model step uses your default model for its type, or the one you pick on the node.

Remove the background and adjust edge softness without blurring the product. Set edge softness to 0 to keep the original cutout.

Strip an image down to its subject on transparency, ready to composite over any background. The usual first step for a product cut-out or a cast of characters that has to sit on brand colour.

Draw a gold release seal from SVG paths, circles and rotated letters instead of generating an image. Every shape stays editable, with no regeneration and no resampling.

Low-poly dungeon models for adventure games: modular stone rooms, doors, gates, traps, torches, tombs and treasure. Includes seven animation clips. Run to expose each GLB as a named output. No provider or API key required.

Change an image by describing the change. The model edits in place rather than regenerating, so composition and subject survive - the instruction should name what to alter and leave the rest unsaid.

One line of subject text becomes a finished editorial photograph. A Template node holds the house look so the caller only supplies the subject. Billed per image.

Generate small and cheap, then pay for resolution only on the frame you keep. Iterating at 1K and upscaling once at the end costs a fraction of generating every draft at full size.

A live photo editor: four GPU filters chained into one pipeline, each exposing a numeric property the app binds to a slider. Drag Denoise, Brightness, Contrast, Saturation, and Sharpen and the preview updates in place — the filters run in-browser, so there is no model, no API key, and no per-run cost.

Low-poly woodland models for adventure games: a ranger, an animated slime, trees, camp props, treasure and modular scenery. Run to expose each GLB as a named output. No provider or API key required.

Low-poly coastal models for games: boats, dock pieces, a lighthouse, a beach hut, fishing props and shore collectibles. Run to expose each GLB as a named output. No provider or API key required.

One frame of a moodboard, generated from a described direction. Cheap enough to run a dozen times and pick, which is how moodboards actually get made.

Turn a title, genre, and visual style into finished theatrical one-sheet posters. An art-direction agent first writes a key-art brief (positioning, palette, typography), which drives every generated poster — the differentiator is the agent-authored creative strategy, not a raw prompt.

Batch-enhance a list of photos through a fixed retouch chain — auto-contrast, color, sharpening, and an AI cinematic-grade pass — with no folder path required, just drop images in.

Low-poly playground models for platform games: floating islands, platforms, spring pads, checkpoints, switches, hazards and collectibles. Includes nine animation clips. Run to expose each GLB as a named output. No provider or API key required.

Generate a poster-style image on a Kie model that you pick on "Render". Kie fronts several model families behind one key, so this is the shortest path to checking a Kie credential actually works.

Turn one product photo into a whole set of polished lifestyle mockups. An LLM art-director designs a varied shot list from your product description, then an image-to-image step composites your product photo into each scene, finished with a brightness/contrast polish. Differentiator: the model invents the scenes, so a single input fans out into a coordinated mockup set — not one prompt, one image.

The starter pattern behind almost every NodeTool workflow: typed inputs fill a reusable prompt template, an LLM answers it, the output renders. Explains a topic for any audience — swap the prompt to reuse the pattern for anything.

Remove the background, soften the cutout edge, and place the product in a new studio scene.

Same product, different season, no reshoot. Relighting keeps the geometry and materials and changes only where the light comes from.

Keep the composition, change the medium. Strength is the dial: low preserves the photograph, high redraws it into something new.

Reusable sci-fi GLB models: a scout robot with an idle animation, a drone, cargo, crystals, and modular station pieces. Run to expose each model as a named output. No provider or API key required.

Generate an image with a Replicate model rather than a fal one. Pick a Replicate model on Render. Same graph shape as the fal and Kie variants - swapping provider is a model-field change, not a rewrite, which is the point worth demonstrating.

Upscale the approved product photo, then sharpen fine detail with an adjustable, light finishing pass. Set sharpness to 0 to disable it.

A raster logo cannot be set on a billboard or embroidered. Tracing to SVG paths gives a mark that scales to any size a supplier asks for.

Enlarge an image without the softness a plain resize gives you. An upscaling model reconstructs detail rather than interpolating it, which is what makes a 4x blow-up hold together in print. Billed per image.

Generate a flat mark, then trace it to true vector art. Raster generators cannot produce clean vectors, so the two steps are separate: one model draws the shape, and a vectorizing model converts it to SVG paths that scale without resampling.

Hand the model the photograph rather than a description of it. Marketplace copy written from the actual image catches details a spec sheet omits — finish, proportion, what it sits next to.

The model writes its own image prompt from a plain description. Useful when the person with the idea does not want to learn prompt craft — and the intermediate prompt stays visible, so it can be corrected rather than guessed at.

Lay one accepted hero out as finished 4:5 and 9:16 ads, as PNGs and editable SVGs, then export a portable campaign record. Ships with a sample hero and contract.
Validate one product brief and optional role-labelled reference, then propose exactly three written campaign directions before any image generation.
Select one captured direction deterministically, edit the product reference into a 16:9 hero, and emit its creative contract only after the image succeeds.
Paste a website and an agent researches the brand behind it: it opens the site with a browser, searches the web for what the site leaves out, and writes cited notes. An extractor turns the notes into a brand name, audience, voice, description and tagline that a brand kit can use. The researcher uses browser and web search tools. Pick a language model for the researcher and the extractor.
Apply one bounded revision to the accepted campaign hero while recording the exact change, preservation instructions, allowed response, and parent contract.
Build a reusable character identity from a reference portrait, a trigger token, and a wardrobe descriptor, then generate a multi-angle character turnaround sheet ready for downstream storyboards or Flux LoRA fine-tuning. Estimated cost is about $0.05 to $0.15 for the turnaround sheet on fal (or ~$2 for a full Flux LoRA run), or $0 locally.
Video

Turn a single product photo into a short looping ad. A prompt node writes the motion brief, an image-to-video model animates the still, and a speed pass slows it into a hero loop. The video step uses your default video model, or the one you pick on the node, and is billed per generation.

Turn a script into speech, normalise the volume, and soften the audio edges before syncing it to your presenter clip.

Turn a product catalog into product videos. Each row's own photo is animated with image-to-video, and the prompt is filled from that row's columns, so a whole range of products shares one camera move and light while every clip stays true to its product.

One line of direction becomes a two-shot b-roll reel. Prompt nodes expand the brief into a wide establishing shot and a matching detail shot, text-to-video renders both, and a crossfade cuts them together. Two paid video generations per run.

Turn one image into a short moving shot. The brief forbids restyling so the model may move the camera and add atmosphere but not redraw the subject - the same constraint the product templates rely on.

Generate a short clip on a Kie video model. The Kie counterpart to Single Shot from a Line - useful for comparing what the same direction yields across providers before committing a template to one.

Grade a video by splitting it into frames, applying exposure/contrast and saturation/vibrance adjustments per frame, then reassembling the result — differentiator: bring your own clip and a single Grading Intensity slider drives the saturation pass live, no per-node tweaking.

Design the frame first, then animate the one you kept. Committing to a still before paying for video is the cheapest way to work — video calls cost many times an image.

Footage arrives 16:9 and the channel wants 9:16. Resizing to the vertical frame is the unglamorous step between having a film and being able to post it.

Turn a one-line brief into an editable rough cut. A Director agent writes a screenplay of shots, each shot is fanned out into a keyframe prompt, rendered as a still, animated into a clip, then all clips are collected, appended to a timeline sequence, and rendered to a single video you can keep editing.

A paragraph of explanation becomes narration and a matching visual. The agent writes the shot description, so the picture follows the words rather than being prompted separately and drifting from them.
One video topic in, a full thumbnail pack out: scroll-stopping hook lines plus a color-graded, ready-to-post thumbnail for each. The differentiator is the fan-out — one hook stream drives a whole gallery of matching images in a single run.

Generate a high-quality still from text, then animate it into a short cinematic clip. The animation step costs more per run than image-only templates.

Sync your presenter clip to a voice track you already have. The audio is levelled and its edges are softened first. Lip-sync is billed per second of footage.

Type a single logline and get back a cinematic teaser. The Director node writes the storyboard — a screenplay of shots with camera direction and one style bible — Screenplay Shots turns each shot into an image prompt, and the frames are rendered, animated, and cut together. Cost note: each shot runs through image-to-video, which is usually metered per second of generated video and is the most expensive step in the pipeline. A 6-shot trailer makes 6 video generations.

Turn a track into a sequence of AI visuals. Read the lyrics, generate matching scenes, fit each frame to 720p, and time the sequence to the audio.

Turn a product description into a short commercial spot — no photo needed. A prompt assembles a studio hero-shot brief, an image step renders the still, then an image-to-video step animates that exact frame following only the camera notes. Cost note: the animation step is billed per second of output, so this costs more per run than an image-only template.

Turn a campaign brief, audience, features, and a product photo into a realistic 16:9 launch video — an agent writes the motion prompt, then an image-to-video model animates the shot. Cost note: the video step is a paid generation, so this run costs noticeably more than an image-only template.

Grab a single frame at a given timestamp - the quick way to get a thumbnail or a reference still out of footage you already have. Runs on your machine with the built-in media engine.

The agent watches nothing — it reads your description of the mood and writes the music prompt. Splitting it this way means you can adjust the mood in words rather than re-describing the music.

Generate a soundtrack to match your clip. Trim the music to the video length, normalise the volume, and add gentle fades before mixing.

The smallest complete video pipeline: a written line becomes a voice, and a described scene becomes footage, then the two are married. Generating the voice and the picture separately is what lets you re-record one without paying for the other.

Full production spine: a Director agent turns your brief into a direction document (characters, style bible, shot list, narration, music). A style frame anchors every keyframe for consistency, keyframes form a cheap storyboard you can approve before video spend, then each shot is animated, cut together, and mixed with voiceover and music.

A synopsis becomes numbered shots with framing and duration — the document a generation pipeline can iterate over, where prose is not.

The smallest possible text-to-video graph: a line of direction, a template that adds the house look, one render. Useful as a smoke test for video credentials before running a template that bills several generations per run.

A still becomes motion for the product page. Image-to-video keeps the product identical and adds only the camera move, which a text-to-video model would not.

The beat structure a trailer needs — hook, setup, escalation, turn, title card — written before any footage is paid for.

Cut a clip down to an in and out point. `accurate` re-encodes so the cut lands on the exact frame instead of the nearest keyframe. Runs on your machine with the built-in media engine - no API key and no per-run cost.

Repaint an existing clip in a new visual style while its motion stays put. A prompt node turns a short style note into a full restyle brief, then a video-to-video model applies it. Strength is the dial: low keeps the original read, high commits to the new look.
Scrape a product URL once, generate a batch of distinct ad angles and camera directions (up to 50 variants), and loop through every variant with no rate-limit queue or automation ban. Estimated cost is about $0.30 per variant on fal at provider list price, or $0 locally with Ollama and Wan 2.2.
Turn a product catalog into product videos made from reference images. Each row's own photo is image 1, and an optional background and decoration image follow it for the whole range. The prompt is filled from that row's columns, and its role placeholders become image 1, image 2 and image 3.
Keep the creator on camera for the full vertical testimonial and place the product demonstration over her as a silent picture-in-picture proof moment.
Turn one continuous vertical creator clip into a polished branded reel. The workflow extracts the native audio, transcribes it with word timestamps, groups the words into short animated phrases, builds an editable NodeTool timeline with MORROW motion graphics, and renders the finished video.
Animate a still photo with one of 30 named camera movements — dolly in, crane up, orbit, crash zoom, FPV fly-through, or bullet time — at your chosen speed and duration. Estimated cost is about $0.30 to $0.85 per clip on fal at provider list price, or $0 locally with Wan 2.2 through ComfyUI or Wan2GP.
Batch-render one still image across six camera movements — dolly in, crane up, orbit left, crash zoom in, pull back reveal, and low-angle hero rise — so you can compare coverage side by side before committing to a hero take. Estimated cost is about $1.80 for six 5-second clips on fal at provider list price, or $0 locally with Wan 2.2.
Place a reference character into a new environment while preserving facial identity and wardrobe, then animate the shot with a named camera move. Estimated cost is about $0.08 for the reference-guided still plus $0.35 to $0.85 for the video clip on fal, or $0 locally with Flux and Wan 2.2.
Direct a 6-shot narrative storyboard around a locked character entity, render every shot still and motion clip with identity preservation, and assemble the cut onto a multi-track timeline. Estimated cost is about $2.50 to $5.00 for a 6-shot board on fal at provider list price, or $0 locally with Ollama, Flux, and Wan 2.2.
Type a brief, get a cut film. A language model directs — it writes the screenplay, the shot list and the narration — then each shot is filmed and the clips are assembled into a timeline and rendered. Two video models, not one, and that is deliberate: shot 1 has nothing to seed from so it is text-to-video, while every later shot is seeded from the previous clip's last frame for continuity, which is image-to-video. Some providers publish those as separate model ids, so Continuation Model carries the second. On a provider where one id does both you can leave it empty. Cost scales with shot count and with the video models you pick. Text costs pennies.
Extract speech from a source video, transcribe it, translate the spoken phrasing into five target languages in parallel, synthesize each localized voice track, and re-sync the speaker's lips for every language. Estimated cost is about $0.45 per language on fal at provider list price.
Apply one of 17 visual effects presets — levitation, glass shatter, liquid chrome melt, slow-motion embers, frost freeze, balloon inflate, or floral explosion — to any product or subject photo. Estimated cost is about $0.30 to $0.85 per clip on fal at provider list price, or $0 locally with Wan 2.2.
Turn creator and product references plus one short script into a continuous 15-second testimonial with native voice and lip-sync.
Dial focal length (14mm to 135mm, macro, or anamorphic), aperture depth of field, film stock grain, and camera motion before generating a keyframe still and its animated shot. Estimated cost is about $0.05 for the keyframe plus $0.35 to $0.85 for the clip on fal, or $0 locally with Flux and Wan 2.2.
One brief, one narrator and one approved b-roll board become an explainer in every language you list. WriteScript writes the words with the narrator as its cast, VoiceScript pays only for the lines whose text moved, and the board is read and never written — its stills become the picture under the voiceover.

One approved board becomes one ad per product. CreateEntity upserts the SKU's entity on its stock code, RecastStoryboard copies the board onto it and keeps every frame whose prompt did not change, the render nodes pay only for the stale ones, and the assembled cut inherits the template's titles and music before the overlay is filled with this product's name and price. Run it once per SKU — from a CSV loop, a webhook, or by hand.
Scrape a live product page URL to extract its form factor, materials, and brand palette, generate a studio packshot keyframe, and animate a directed CGI-style tabletop commercial shot. Estimated cost is about $0.08 for the studio packshot plus $0.35 to $0.85 for the motion clip on fal, or $0 locally with Ollama, Flux, and Wan 2.2.
Paste a product page URL to extract its headline, value props, and proof points, write a 15-second spoken creator script, synthesize the voiceover, and lip-sync a creator portrait into a vertical UGC ad. Estimated cost is about $0.45 to $1.10 per ad on fal at provider list price.
Turn a single portrait photo and a written script into a lip-synced talking avatar video: synthesize and level the voice track, animate natural head movement from the portrait, and lock mouth shapes to the audio. Estimated cost is about $0.40 to $0.95 per clip on fal at provider list price.

One approved cut, three deliverables. RetargetTimeline derives a new sequence per aspect ratio and never writes the source, so the trims and placements a person signed off carry over unchanged — only the frame moves. `cropped` names the clips the 9:16 crop cuts into, which is where a shot may need a board of its own.
Audio & Music

A recording becomes a list of commitments with owners. Anything without a clear owner is listed separately rather than assigned to someone the model guessed at.

Speak an image into existence: no keyboard needed. A speech-to-text model transcribes your audio, then an image model renders the description as an image — the whole pipeline runs from a single voice note.

Long audio is unnavigable without chapters. The model proposes the topic boundaries; you keep the ones that match how the conversation actually moved.

The repair chain for a recording made in a real room: gate the noise floor, cut the rumble below speech, even out the level, then stop it clipping. Every step is cheap and local — no model involved.

Transcribe a clip and count the tokens. Worth knowing before you feed a transcript to a model that bills per token or caps context.

Upload any photo and a vision agent narrates a spoken story about it — one image in, one audio clip out

Translate a script into Spanish, generate speech, and even out the volume. Short fades soften the start and end without changing the timing.

The three-stage chain a voice gets before it ships: compress to even out the peaks, lift the level, then limit so nothing clips. Order matters — limiting first would leave nothing for the compressor.

Summarize a meeting from a recording or a pasted transcript — either input works, and action items come back as structured rows instead of another paragraph to scan.

Transcribe a clip and turn the first words into a URL-safe slug. A small chain that shows speech becoming a filename rather than a document.

Turn written copy into a voice track. Pair it with Score a Silent Clip to build a narrated cut from text alone. Billed per character.

Voice a script over a quiet music bed. Match the music to the voiceover and fade the start and finish.

The job every podcast has and nobody enjoys. Transcribe, then write the notes — summary, topic bullets, and the resources mentioned.

Drop in one podcast episode and ship the whole content pack: episode titles and show notes, a newsletter edition, five social posts, and quote cards rendered as square images. It transcribes once; four writer branches fan out from the transcript.

Five verbatim quotes, chosen for standing alone. Insisting on verbatim is what makes the output usable — a paraphrased quote is worse than none.

Voice a script over a quiet music bed. Match the music to the voiceover and fade the start and finish.

Synthesise speech and strip the dead air off both ends. TTS often leaves padding; RemoveSilence gives you a tight clip you can drop into a timeline.

Transcribe, then break into subtitle-length lines. The line-length rule is what separates a subtitle file from a wall of text.

The summary someone reads instead of listening again: what was decided, what is open, what happens next.

Generate music and slice a short section out of it. Cheaper than regenerating when you only need a sting rather than a full bed.

Pull the spoken words out of a video. Audio is extracted locally, then transcribed. Note the provider choice: fal and Replicate both list speech-to-text models in their manifests, but neither provider implements the transcription capability, so those entries cannot execute. OpenAI, Gemini, HuggingFace, MiniMax and Together do implement it.

Instant speech-to-text: drop in an audio clip, get a clean text transcript back — one step, auto-runs on upload.

Spoken delivery and written prose are different registers. The instruction to restructure rather than transcribe is what stops the output reading like a transcript with paragraphs.

A two-hander needs two voices. Synthesising each part separately and joining them is what lets you re-record one line without re-rendering the whole exchange.

Synthesise a mono voice and place it in a stereo field. Most TTS returns mono; anything mixed for stereo playback needs both channels.
A native top-down game asset pack. LoadGameTemplate streams the slots; SlotPrompt sizes each asset request; each result is checked before StageGameAssets writes content-addressed candidates. Install selected bindings into a game revision to play them.
Agents & Research

Turn a one-line topic into a structured dataset — define the columns once, get validated rows back instead of paragraphs of prose.

Scrape the Hacker News front page and get a topic-filtered digest written directly as Markdown — no separate formatting step.

One brief, three frontier models, answered side by side, then a fourth model judges them blind. The same prompt fans out to three model lanes in a single pass, each answering in the same structure. A judge reads the three answers as A, B and C without knowing which model wrote which, scores them against a fixed rubric, and names a winner. Swap the model on any lane, or the judge, to build your own bracket.

Give it a topic and an audience; the agent runs real web searches, opens the best sources, and streams back a cited markdown briefing. Differentiator: genuine multi-step tool use (search + browse) with inline citations — not a single prompt call.

Composition demo: an orchestrator agent delegates to two specialist sub-agents wired in as callable tools via control edges — Research gathers the facts, Copy Editor polishes the draft, and the manager decides when to call each. Shows how a self-contained unit of work becomes a tool another agent can invoke, all inside one graph.
The trigger you reach for when nothing external should decide the timing — a person does. It waits, and whatever payload you hand it comes out of `data`, with the caller in `source` so two senders stay distinguishable. Useful as the front of a pipeline you want to fire by hand, from a script, or from another workflow.
A clock, and the two numbers a schedule actually needs: which tick this is, and when it fired. Set `interval_seconds` and the trigger emits on its own — no input, no caller. Everything downstream of it becomes a cron job. Leave `max_events` at 0 to run forever, or set it to stop after N.
A drop folder as an interface. Point `path` at a directory, narrow it with `patterns`, and the graph wakes whenever a matching file appears or changes — you get the event kind and the full path. The agent here just names what arrived; replace it with the work you actually want done on the file. `debounce_seconds` exists because editors write a file more than once.
Marketing & Content

An autonomous agent researches a prospect on the web and drafts a personalized cold email — opening with a real, specific detail — as structured fields (subject, body, follow-up) instead of one prose blob, ready to drop straight into a CRM or email tool.

One topic in, a keyword-targeted article batch out — each article lands as typed fields (title, meta description, keywords, body) instead of one markdown blob, ready to paste straight into a CMS. A strategist agent plans the topic cluster, a list generator turns it into briefs, and every brief becomes a full article with an editorial hero image.
Text & Data

The same offer written plain, playful and premium. Register is usually the variable a team argues about, so produce all three and let the work settle it.

Retrieval-augmented Q&A over your own documents. Index a small knowledge base into a vector collection, pull the passages matching a search keyword, and get a Markdown answer that cites its sources and refuses to guess when the answer isn't in the docs. NodeTool's first RAG example. The answer step uses your default language model; the collection is configured for Ollama nomic-embed-text embeddings.

Headline variants for a test. Asking for a stated angle per line makes the set genuinely different rather than five rewordings of the first idea.

Turn any mix of real animals into a gallery of original collectible creatures. A style dropdown restyles the whole batch, so one Run yields four cohesive variant designs instead of a single image.

Ask questions about your own notes and documents — fully local, no API keys. It is meant to run on a local Ollama model, so the text never leaves your machine. Requires Ollama running with a model pulled, such as llama3.2 (`ollama pull llama3.2`), picked on the agent node.

Check a product catalog before you render it. Reads a CSV, finds the image and name columns, and fills the video prompt template for every row, so a wrong column or a missing image shows before any video is paid for.

A matching sci-fi model pack with a rover, sentry turret, reactor, satellite dish, airlock and station props. Run to expose each GLB as a named output. No provider or API key required.
An HTTP POST arrives and the graph replies in prose. The trigger hands you the request body, headers and method; this one reads the body and writes a one-line summary a human can act on. Register the workflow to get a delivery URL, or drive it from the CLI with `--trigger-event '{"node_id":"hook","payload":{"body":{...}}}'`.
Validate a portable schema-version-1 campaign record and restore its accepted original and optional revision without calling a model.
A finished script broken into numbered subtitle captions of at most two short lines, split at natural phrase boundaries.
A spoken script translated into the language you name, kept close to the original length so the new voice track fits the same footage.
