Node support

The API supports all 26 node types with the same execution semantics as the visual editor. Composition-heavy nodes (voiceover, captions, audio mixing, clip selection) accumulate composition metadata server-side, and a single render at the end of the run assembles the final MP4.

One render per run, no matter how many audio/caption/clip layers are present. You pay for the generations that produce the assets, plus a single final render.

Full support matrix

Text & AI
Image
Video
Audio
Flow control

Node	Description	Credit cost basis	API inputs
`text_input`	Hardcoded text source.	Free	`prompts[step]`
`text_editor`	User-editable text pass-through.	Free	`prompts[step]`
`ai_transform`	Text-to-text via the configured LLM engine.	LLM tokens	`prompts[step]`, `model_overrides[step]._bg_instruction`
`script_generation`	Long-form script writing.	LLM tokens	`prompts[step]`, `model_overrides[step]._script_instructions`
`mixed_media`	Multi-input text analysis.	LLM tokens	`prompts[step]`, `model_overrides[step]._mixed_media_instruction`
`parse_scenes`	Split script into numbered shots.	LLM tokens	`prompts[step]`
`continuity_enhance`	Enforce visual consistency across scenes.	LLM tokens	`prompts[step]` for style

Node	Description	Credit cost basis	API inputs
`image_generation`	Generate one image from a prompt.	Per-megapixel pricing	`prompts[step]`, `model_overrides[step]._model_options`
`multi_angle`	Generate the same subject at multiple angles.	Per-angle × image cost	`model_overrides[step]._selected_angles`
`media_input`	Supply an existing image/video/audio URL.	Free	`media[step]`

Node	Description	Credit cost basis	API inputs
`text_to_video`	Video from a prompt (Kling 3.0, Seedance 2.0, Veo 3.1, Wan 2.7, Happy Horse, Grok Imagine).	Per-second video pricing	`prompts[step]`, `model_overrides[step]._model_options`
`image_to_video`	Animate a source image.	Per-second video pricing	`prompts[step]`
`animation`	Motion transfer (Kling Motion Control, Wan Animate).	Per-second video pricing	—
`clipping`	LLM-pick the best N clips from a long video.	Transcription + LLM analysis	`model_overrides[step]._clip_count`
`frame_extractor`	Grab the first or last frame of a video as an image.	Free	`model_overrides[step]._frame_position` (`"first"` \| `"last"`)
`video_editor`	Stitch multiple clips together.	Free (executes at final render)	—

Node	Description	Credit cost basis	API inputs
`voiceover`	TTS via ElevenLabs or MiniMax Speech.	Per-character pricing	`prompts[step]`, `model_overrides[step]._voiceover_default_voice`
`auto_captions`	Transcription + animated captions at final render.	Per-minute transcription	`model_overrides[step]._caption_style_id` or `._caption_style_overrides`
`background_audio`	Royalty-free track search.	Free	`model_overrides[step]._audio_default_query / _tags`
`ai_music`	Generate music (MiniMax Music 2.6, ElevenLabs Music, Lyria 2).	Per-track pricing	`prompts[step]`
`audio_overlay`	Attach a user-supplied audio asset.	Free	`media[step]` with `type: "audio"`

Node	Description	Credit cost basis	API inputs
`split`	Fan out an array into per-item iterations.	Free	`model_overrides[step].split_mode: “parallel"	"sequential”`
`collect`	Merge per-item results back into arrays.	Free	—
`review`	Pass-through in API (no UI in headless runs).	Free	—

How DOM-dependent nodes work server-side

These seven node types rendered inline in the browser. In the API they accumulate layer metadata that gets consumed by the final render:

voiceover — adds an audio track

The executor calls ElevenLabs TTS, polls until done, and appends the audio URL to the artifact’s audioTracks array with the correct offset/duration. At final render, every track is mixed over the video.Options:

Field	Type	Default	Notes
`prompts[step]`	string	required	Script to read aloud.
`_voiceover_default_voice`	string	`"Roger"`	A voice ID supported by the chosen `engine_1`. See lists below.
`engine_1`	string	`"fal-elevenlabs-v3"`	TTS model. One of `fal-elevenlabs-v3`, `fal-elevenlabs-turbo`, `fal-minimax-speech`.

ElevenLabs voice IDs (work with both fal-elevenlabs-v3 and fal-elevenlabs-turbo):Roger, Sarah, Laura, Charlie, George, Callum, River, Harry, Liam, Alice, Matilda, Will, Jessica, Eric, Bella, Chris, Brian, Daniel, Lily, Adam, Bill.MiniMax Speech voice IDs (work with fal-minimax-speech):male-qn-qingse, male-qn-jingying, male-qn-badao, presenter_male, audiobook_male_1, female-shaonv, female-yujie, female-chengshu, presenter_female, audiobook_female_1.Any unrecognized voice ID is silently rejected and the node no-ops — the rest of the run still executes but the voiceover track is missing from the final mix.

{ "prompts": { "1": "Hook line, then payoff." },
  "model_overrides": { "1": { "_voiceover_default_voice": "Bella" } } }

auto_captions — captions at render time

The executor transcribes the video (word-level timestamps) and stores the word array + caption style on the artifact. Animated captions are rendered as a text layer at the final composition step — no rasterization at the node level.Two ways to style captions — both go under model_overrides[step]. Mix and match: overrides win field-by-field over a style ID.

_caption_style_id — a cs_… blob produced by the Caption Designer. Self-contained, no DB lookup, no expiry. The fastest path when you’ve already designed a look you want to reuse.
_caption_style_overrides — a partial CaptionStyle object (see fields below). Any field you omit falls back to the default style.

Field	Type	Default	Notes
`fontFamily`	string	`"Inter"`	CSS `font-family` value. See the font list below — only those load reliably at render time.
`fontSize`	number	`64`	Pixels.
`color`	string (hex)	`"#FFFFFF"`	Main text fill.
`highlightColor`	string (hex)	`"#FFCC00"`	Color of the currently-spoken word.
`strokeColor`	string (hex)	`"#000000"`	Text outline.
`strokeWidth`	number	`6`	Outline thickness in px.
`bgColor`	string (hex)	none	Optional pill background behind the text.
`bgRadius`	number	none	Pill corner radius in px.
`animation`	enum	`"pop"`	One of `pop`, `fade`, `slide`, `bounce`, `shake`, `zoom`, `none`.
`animationScope`	enum	`"group"`	`"word"` (karaoke) or `"group"` (whole line).
`wordGroupSize`	number	`3`	Words shown per line.
`position`	number	`80`	Vertical position 0–100 (% from top of frame).
`uppercase`	boolean	`true`	Force upper case.
`shadowColor`	string (hex)	none	Optional drop shadow color.
`shadowBlur`	number	none	Drop shadow blur radius in px.

Available fonts — the renderer preloads a fixed set of fonts. Any other value falls back to a system font (usually unreliable), so stick to this list unless you self-host a font:Display: Anton, Bebas Neue, Oswald, Archivo Black, Bowlby One, Bangers, Luckiest Guy, Permanent Marker. Sans: TikTok Sans, Inter, Poppins, Montserrat, Nunito, Open Sans, Raleway, DM Sans, Space Grotesk, Fredoka. Serif: Lora. Mono: Geist Mono, Courier New. Script: Comic Neue, Pacifico, Caveat.The font-family string may include fallbacks, e.g. "Anton, Impact, sans-serif".Example:

{
  "model_overrides": {
    "3": {
      "_caption_style_overrides": {
        "fontFamily": "Anton, Impact, sans-serif",
        "fontSize": 80,
        "highlightColor": "#FF3366",
        "animation": "bounce",
        "animationScope": "word",
        "wordGroupSize": 2,
        "position": 75,
        "uppercase": true
      }
    }
  }
}

background_audio — royalty-free track search

The executor searches the royalty-free track library, picks the first matching track, and stores it in the artifact’s audioOverlay.backgroundAudio field. It’s added as a background bed at final render.Options (under model_overrides[step]):

Field	Type	Default	Notes
`_audio_default_query`	string	none	Free-text keyword for the search. At least one of `query` or `tags` must be set or the node no-ops.
`_audio_default_tags`	string	none	Comma-separated mood/genre tags (e.g. `"upbeat,electronic"`).
`_background_audio_volume`	number	`0.3`	Bed volume `0`–`1`. Kept low by default so it sits under voiceover.

{ "model_overrides": { "4": {
  "_audio_default_query": "cinematic uplifting",
  "_audio_default_tags": "epic,piano",
  "_background_audio_volume": 0.25
}}}

ai_music — audio track

Generates music, polls for completion, and appends the track to audioTracks. Same plumbing as voiceover — consumed at final render.Engine — set via engine_1 on the step. Treat engine IDs as opaque tokens; the canonical list is returned by GET /flows/:id for any saved flow. Today’s IDs:

`engine_1` value	Model	Per-track cost
`fal-ai-minimax-music`	MiniMax Music 2.6 (default)	3 credits
`fal-ai-lyria2`	Lyria 2	10 credits per 30s
`fal-ai-elevenlabs-music`	ElevenLabs Music	80 credits per minute

Options:

Field	Type	Default	Notes
`prompts[step]`	string	required	Music description (genre, instruments, mood, tempo).
`_ai_music_volume`	number	`0.5`	Track volume `0`–`1`.

audio_overlay — user asset

Takes a user-supplied audio URL (from inputs.media[step] with type: "audio", an upstream media_input, or the literal _audio_url field) and adds it as a track. No generation, no polling.Options:

Field	Type	Default	Notes
`_audio_url`	string	none	Direct fallback URL if no upstream audio input. Prefer `inputs.media[step]`.
`_audio_overlay_volume`	number	`0.8`	Track volume `0`–`1`.
`_audio_overlay_offset`	number (seconds)	`0`	When the track starts inside the final video.
`_audio_overlay_duration`	number (seconds)	`prev.audioDuration		60`	How long the track plays.
`_audio_overlay_title`	string	`"Audio overlay"`	Display label only; does not affect render.

{ "inputs": { "media": { "5": { "url": "https://...sfx.mp3", "type": "audio" } } },
  "model_overrides": { "5": {
    "_audio_overlay_volume": 0.6,
    "_audio_overlay_offset": 12.5,
    "_audio_overlay_duration": 8
}}}

clipping — LLM clip selection

The source video is transcribed, then an LLM picks the top-N viral segments from the timestamped transcript and emits a clipTrims array. At final render, the source video is trimmed to exactly these windows and stitched.Options:

Field	Type	Default	Notes
`_clip_count`	number	`5`	How many clips the LLM should rank and return.
`engine_1`	string	`"grok-fast"`	LLM used for ranking. Any value accepted by the shared `text_llm_engines` list works (Grok, Gemini, GPT, Claude family).

The LLM is hard-pinned to clips of 15–60 seconds; values outside that range are dropped before stitching. If transcription fails or the LLM returns nothing parseable, the node falls back to a single 60 s clip from the start of the source video.

multi_angle — parallel image generation

Runs image generation N times with angle-prefixed prompts and the same reference image. Emits a sceneImages array identical in shape to what a split → image_generation → collect would produce, so downstream image_to_video nodes see a uniform input.Options:

Field	Type	Default	Notes
`_selected_angles`	string[]	required	One generation per entry. Node no-ops if empty.
`_image_engine`	string	`"fal-nano-banana"`	Image model. Overridden by `engine_1` if set on the step.

Suggested _selected_angles values (these are the chips the visual editor exposes — server treats them as free-text suffixes, so any descriptive string works):Front, Left Side, Right Side, Back, Top, Bottom, Isometric, Close-up.The executor templates each angle into "<base prompt> — <angle> angle, consistent subject and lighting." so values that read naturally in that sentence give the best results.

{ "model_overrides": { "2": {
  "_selected_angles": ["Front", "Left Side", "Close-up"],
  "_image_engine": "fal-nano-banana"
}}}

Final render composition

After the last step executes, the worker assembles the final composition by walking every step’s artifact in reverse order:

Pick clips

Last-written clipTrims. Falls back to stitching sceneVideos if no explicit trims. Falls back to a 60-second slice of the last videoUrl if neither is present.

Pick caption words and style

Last-written captionWords + captionStyle.

Pick audio overlay

Last-written audioOverlay — the background music bed.

Union of audio tracks

All audioTracks arrays concatenated. Voiceover + music + user overlays all layer together.

One POST /api/render call

The worker POSTs the composition spec to the Vercel render endpoint, which triggers Remotion Lambda. Polls /api/render-progress until the MP4 is ready, stores the URL on the run.

This is exactly the logic the browser’s export step uses — same code path, same output MP4.

Checking which nodes a flow uses

curl $BASE/flows/<flow_id> -H "Authorization: Bearer $HYPERCLIP_API_KEY" \
  | jq -r '.flow_schema.nodes[].type' | sort -u

Unsupported node types

The only way to get a node-support error is with an unknown node type (one not in the list above). This fails with error_code: "unknown_node_type" at validation time, before credits are reserved:

{
  "id": "6f2c1c9a-...",
  "status": "failed",
  "error_code": "unknown_node_type",
  "error_message": "Unknown node type: my_custom_node",
  ...
}

This only happens if you pass an inline flow_schema with a handwritten node type. Every type produced by the visual editor is supported.

Introduction

Endpoints

Reference

Examples

AI tooling

Full support matrix

How DOM-dependent nodes work server-side

Final render composition

Checking which nodes a flow uses

Unsupported node types

​Full support matrix

​How DOM-dependent nodes work server-side

​Final render composition

​Checking which nodes a flow uses

​Unsupported node types

Full support matrix

How DOM-dependent nodes work server-side

Final render composition

Checking which nodes a flow uses

Unsupported node types