Compose Video

Create branded videos from Remotion templates

Try Video Editor in the playground

Last updated View as MarkdownAgent setup

Compose Video

Node type: video:remotion
Category: Editing

Description

Compose Video is Wireflow's video assembly node, labelled Video Editor in the app: it renders a finished video, plus a thumbnail, from the clips, images, audio and text you wire into it. It works in one of two modes: template mode fills a pre-built composition (config.templateId), and sceneGraph mode renders a composition you write yourself as JSON (config.props.sceneGraph), with scenes, tracks, overlays and captions. Its node type is video:remotion. Read what a node expects with GET /api/v1/remotion/templates or GET /api/v1/remotion/scene-graph (Video Compositions), run the saved workflow with POST /api/v1/workflows/{id}/run, or read and edit its timeline from an agent over the Wireflow MCP server. Rendering it costs 0 credits at current pricing, and render usage limits apply on every plan.

Canvas ports

These appear as port handles on the left side of the node.

ID Label Details
hookImage Image IMAGE
avatarVideo Video VIDEO
text Text TEXT

These render as form fields in the right-side config panel when the node is selected.

No sidebar config fields.

Outputs

ID Label Type
video Video VIDEO
thumbnail Thumbnail IMAGE

Verify before you render

Preview any scene graph for cents (no credits) before a full render: POST /api/v1/render/remotion/preview with {"sceneGraph": {...}} responds with { "data": { "frames": [{frame, url}], "issues": [...], "warnings": [...], "diagnostics": {...}, "renderable": bool } }. Default samples land on scene boundaries and midpoints (up to 5); pass "frames": [0, 150, 450] for exact frames. Fix every data.issues entry, re-preview, and only then run the paid render.

For side-by-side or video-over-video edits inside this node, use a split scene (50/50, top/bottom keys) or a composite scene (positioned layers). For one-shot compositing of separately generated clips, use the Video Composite node instead.

Transitions over track clips

A scene's transitionFx blends the two scenes only, and timeline track clips stay above it, untouched: a card crossing a glitch cut floats clean over the glitching background. Add "scope": "frame" to send the whole timeline frame, scenes and track clips, through the transition during its window: "transitionFx": {"id": "glitch_memories", "durationInFrames": 10, "scope": "frame"}. The track clips are live in both halves, so a clip that spans the cut does not ghost. Graphic overlays and captions stay above in both scopes. A crossfade looks the same either way; a dip, a mosaic or a glitch now hits the cards too.

Delivery size

By default the render is encoded at high quality, and a grain-heavy 10s 1080x1350 cut comes out around 20 MB. Ad uploads and email attachments want under 8 MB, so set the node's config.output:

  • "ad" or "email": the file lands under 8 MB.
  • "high", or nothing: today's default quality.
  • { "maxSizeMB": 15 }, { "crf": 28 } (1 to 51, higher is smaller, default 18) or { "videoBitrate": "4000k" }, ONE of them, for anything else.

In the Video Editor this is the Delivery select next to Render. A size target is turned into a video bitrate from the render's duration, with 15% kept back for the container and rate-control overshoot and 320k for audio, so it is the duration that limits it: 8 MB holds a watchable cut of up to about 95 seconds. A longer one, or a bad value, fails the run with the reason before anything is rendered, shadow runs included. If the finished file still comes out over its target, the result says so: sizeBytes, overTarget: true and a warning, never a silent success. POST /api/v1/render/remotion/render takes the same output field.

Outline text

A text clip takes "stroke": {"color": "#ffffff", "width": 6} for outline type. The width is in composition pixels, centred on the letter edge and drawn under the fill, so a filled title keeps its weight and shows half the width outside each letter. For a hollow title set the clip's "color" to "transparent"; the full width then shows. Colors are hex only (#rgb, #rgba, #rrggbb, #rrggbbaa), widths run up to 64, and the stroke is static (not keyframeable). It renders the same in the editor preview, preview stills and the MP4. There is no inspector field for it yet: set it through the API, an agent, or the scene graph JSON.

Green-screen plates and screen inserts

Composite layers support chroma key and four-point perspective through the scene graph JSON, API and MCP. Put the recording first, pinned to the screen, then the green-screen plate above it:

{
  "type": "composite",
  "durationInFrames": 120,
  "layers": [
    {
      "src": "{{recording}}",
      "kind": "video",
      "cornerPin": {
        "tl": [180, 280], "tr": [880, 320],
        "br": [840, 780], "bl": [210, 740]
      }
    },
    {
      "src": "{{plate}}",
      "kind": "image",
      "matte": "chroma",
      "chroma": {
        "keyColor": "#00FF00", "tolerance": 0.3,
        "softness": 0.1, "spill": 0.5
      }
    }
  ]
}

Those chroma values are the defaults; matte: "chroma" alone enables them. keyColor is a six-digit hex color. The other controls run from 0 to 1. Tolerance removes pixels within that sRGB channel distance of the key; softness feathers the boundary, and spill reduces the key-color fringe. Keying preserves existing alpha and runs before layer effects.

Corner coordinates are stage pixels from the top-left, ordered top-left, top-right, bottom-right, bottom-left. The quad must be convex with no collapsed edges. The source's full frame maps onto the four corners without cropping or letterboxing. fit is ignored when cornerPin is set. Existing transforms run after the pin: give both layers identical keyframeTracks and transformOrigin to move the plate and recording together. This is a static pin with animated whole-layer motion, not automatic tracking.

Both features use the shared renderer for the editor preview, preview stills and the final MP4, including the DOM and GL paths. These fields are accepted on composite layers only; other surfaces refuse them. chroma options require matte: "chroma".

Thumbnail

Every successful run of the node also fills the thumbnail output with a JPG still of the composition, stored on the CDN, so a wire from it reaches an image node without a frame extractor. By default the still is the frame at 10% of the duration, which skips a black intro. Set config.thumbnailFrame to a frame number (from 0, clamped to the last frame), "first" or "middle" to pick another. A bad value fails the run before anything is rendered. The still costs no credits, and if it fails the video is still delivered: thumbnail is left empty and a warning says why.

3D clip transforms

Timeline clips can turn in depth: set rotateX / rotateY (degrees) and z (px, positive toward the viewer) on a clip, statically or in keyframeTracks. Perspective comes from the track: "camera": {"perspective": 3000, "originX": 0, "originY": 0} on the track object gives every clip on it one shared camera (perspective at least 100 px; origin is an offset from the frame centre), so a row of cards converges to a single vanishing point. "transformOrigin": "left" turns a clip on its left edge, like a door. Back faces are hidden: to flip a card to a new face, put two clips back to back (the first turns 0 to 90, the second starts on its last frame and turns -90 to 0). Without a camera, 3D renders flat (orthographic). In the Video Editor, open the "3D" section of the clip inspector for the rotate, depth, pivot and track camera fields.

Gradient map: duotone, negative and solarize looks

The gradient_map effect maps each pixel's luminance onto a 2 or 3 color ramp. It is the look pro launch films use on cards and faces: a pink negative, a magenta duotone, a solarize. Put it on the image or video clip (or a scene, or a composite layer), not on the type above it:

"effects": [{ "effect": "gradient_map", "preset": "pink_duotone" }]

Presets: pink_negative, pink_duotone, solarize_pink, hot_pink_tint. Any params you also set win over the preset's. The params are the stops (stops "2" or "3", color0/color1/color2 with pos0/pos1/pos2), invert ("on" flips the ramp, a negative), solarize (the fold point; 1 is off, 0.44 is the reference solarize), input levels black/white, gamma (1 to 3; a value outside repairs to the nearest bound. To lift the shadows, lighten color0 or lower white: raising black darkens them) and amount (the mix with the original). Adjacent stop positions must be at least 1/16 (0.0625) apart; closer stops are spread to that minimum, because the DOM path draws the ramp through a 256-step table. For a hard edge, put the two stops 0.0625 apart. In the Video Editor it is Gradient Map in a clip's effects, with a Look dropdown and a stop editor.

Unlike most effects it renders on BOTH render paths, so it survives edits with shape clips, typewriter text, crops and blend modes, which render without the GPU path. On the steepest legal ramps the DOM and GL paths can differ on transition pixels, by up to half a table step times the steepest slope: for a full-range color pair 1/16 apart that is 8 of 255 per channel at gamma 1 and 24 at gamma 3, twice that under a solarize at 0.5, and proportionally less for wider stops. Near an equal mix of two colors the dominant channel can differ there.

Posterize Time: footage on twos and threes

The posterize_time effect steps the footage to a lower frame rate by holding each source frame for several composition frames, like Posterize Time in After Effects or Premiere. Use it for anime on twos or threes, stop-motion, claymation, choppy motion graphics or a lo-fi look:

"effects": [{ "effect": "posterize_time", "params": { "fps": 12 } }]

Set ONE of fps (the target footage rate: at a 24 fps composition 12 is on twos and 8 is on threes) or hold (composition frames per footage frame, 1 to 6). offset shifts where each step lands. Only the video steps: film grain, dust, gate weave, light leak and every other effect keep changing every frame, the way real grain does over a held drawing, and position, scale and keyframes stay smooth. Audio is never stepped. Put it on a video clip, a composite layer or a video or composite scene (a scene steps every video in it). It renders the same on both render paths and does not change which path a render takes. In the Video Editor it is Posterize Time in a clip's effects.

Compression: the phone-upload look

Clean AI pixels read as fake next to real phone footage, which always carries the damage of an upload. The compression effect puts it back: fine texture flattened into blocks, banding in smooth gradients, colour bleeding past edges and faint ringing on hard edges:

"effects": [{ "effect": "compression", "params": { "intensity": 0.15 } }]

intensity is the master control: 0 is off, 0.1 to 0.2 is a tasteful phone upload, 0.5 and up is a re-shared repost. block_size is the macroblock size in pixels (8 is a phone upload, 16 older or re-shared video), and the blocks sit on the frame grid from the top-left, like an encoder's. chroma, banding and ringing (each 0 to 1) tune the colour bleed, the gradient banding and the edge halos on top of that. Put it last in the effects list, after the grade and the grain, the way an upload squeezes the finished video. It renders on the GPU path only: in a composition the GPU path cannot draw, it is skipped and the render says so by name. In the Video Editor it is Compression in the effects list.

Keyframed effect params

Any number param of any effect can animate with paramTracks, the same waypoints as keyframeTracks, with frames counted from the start of the scene, layer or clip that carries the effect:

{
  "effect": "gradient_map",
  "preset": "pink_duotone",
  "paramTracks": {
    "amount": [
      { "frame": 0, "value": 0.2 },
      { "frame": 4, "value": 1 }
    ],
    "solarize": [
      { "frame": 4, "value": 1 },
      { "frame": 8, "value": 0.44, "easing": "easeOutQuad" }
    ]
  }
}

A track wins over the param's static value. Color and enum params cannot be keyframed: stack a second effect and ramp its amount instead.


Auto-generated from the Wireflow node registry.

For AI agents: the full documentation index is at /llms.txt, and most docs pages are available as Markdown by adding .md to the URL.

© 2026 Wireflow. All rights reserved.