Sequencer

Create a new Level Sequence asset

Open a Level Sequence in the Sequencer editor

Read timeline settings + binding/track counts

Set the playback range (frames or seconds)

Set the display rate / FPS

Set the tick resolution (migrating)

Bind an existing level actor as a possessable

Add a spawnable binding from a class

Add a spawnable binding from a level actor template

List bindings (possessables + spawnables), filterable by type/name

Rename a binding by GUID

Remove a binding by GUID

Convert a possessable binding to spawnable

Convert a spawnable binding to possessable

List available track classes (reflection)

List tracks on a binding (or root tracks)

eval_disabled is only present when the track is evaluation-disabled, and muted only when the track is muted, so an ordinary track carries neither. Mute is read-only for now, and reported on UE 5.7 and 5.8 only: 5.6 stores it as outliner node-path strings that need the Sequencer view model.

Add an object-bound track to a binding

Add a root/master track (camera cut, audio...)

Remove a track by index

Add a section to a track

List sections on a track (display-rate frames; reports ease_in/ease_out and blend_type when set)

Set a section's range (frames or seconds)

Remove a section by index

Set a property on a track (universal writer)

Set a property on a section (universal writer)

List a section's animatable channels

Add a keyframe to a channel

List keys on a channel (compact: time + value, one shared interp)

Each key is {time, value} in the requested time_unit. The interpolation shared by most keys is reported once as the result's interp field, and only the keys that differ from it carry their own interp; cubic is the engine default, so an all-cubic channel reports no interp at all. Defaults to 30 keys; page a baked curve with --offset. The result carries offset, total_matched and truncated.

Remove a key from a channel by index or by frame

Give --frame (survives the index shift a prior removal causes) or --key-index. Frame wins when both are set.

Set or clear a channel's default value

DEPRECATED: use add_keys. Key location/rotation/scale on a transform section in one call

Deprecated. It forwards to add_keys with the Location/Rotation/Scale channels; call add_keys directly for anything else.

Spawn a cine camera and bind it in the sequence

Add a camera cut to the camera (auto-creates the cut track)

Render a Level Sequence to disk via Movie Render Queue (async)

Every override is checked before a render starts: width and height go together, and a bad format or time_unit, or an override the job cannot take, fails with nothing rendered. A Movie Graph job refuses the preset-only overrides (output_dir, format, width/height, fps, file_name_format, use_custom_range, override_existing); a 5.8 Basic-mode queue job is refused.

Report Movie Render Queue progress + written files

Lists every render job started this session with its job_id, started/finished state and output file count. Pass --job-id (returned by render_sequence) to get that job's full output file list.

cfa render_status
cfa render_status --job-id 3f1c9a2b

Set an existing key's value (float/double channel)

Move an existing key in time

Set a key's interpolation + tangent mode

Set a key's tangents (arrive/leave + weights)

Set channel pre/post-infinity extrapolation (looping)

Read a channel's keys into a portable payload

Returns {time, value, interp} keys in the requested time_unit. Feed the keys array to paste_keys.

Write a copy_keys payload onto a channel at an offset

keys is the array from copy_keys. Refuses a type-incompatible paste (float payload onto a bool channel).

Shift every key on a channel (or section) by a delta

Move keys explicitly, or scale a range about a pivot

Give key_frames + new_frames to remap named keys, or scale + pivot to stretch every key.

Key reduction / curve optimise within a tolerance

Blend selected keys with one of the editor's blend tools

Runs the editor's own blend maths on the keys at the given frames. Keys next to each other blend as one range, against the key before and the key after that range. mode: neighbor (toward the key before for a negative amount, after for a positive one), tween (between the two outer keys; 0 is halfway), push_pull (toward or away from the straight line between the outer keys), relative (shift the whole range), ease (as neighbor, on an S curve), smooth_rough (average out or sharpen against each key's own neighbours).

Key every channel of a binding at one frame (current value)

Sample a channel per frame over a range and write keys

With write false the samples are returned instead of written. Sampling steps one display frame.

Mute or unmute a track or one of its rows (headless)

Writes the outliner mute marker (a decoration on 5.7+, a node-path string on 5.6, echoed as node_path) and mirrors it into the saved eval-disabled flag, which is what muting in the Sequencer produces.

Solo or unsolo a track or one of its rows (headless)

Writes the outliner solo marker. The other tracks are silenced by the Sequencer while it evaluates; use set_track_eval_disabled for a saved, headless disable.

Disable or enable evaluation of a track or row (saved; not mute)

Mute/solo/eval-disabled/colour/sort/lock state per binding, track, row and section

Set a section's active, locked, row, colour, pre-roll and post-roll

Set a track's colour tint

Rename a track or one of its rows

Set a track's sort order among its siblings

Set a binding's sort order among its siblings

Create a folder nested under another folder

Rename a sequence folder

Set a sequence folder's colour

Unlink a binding or root track from a folder

Remove a folder (its contents return to the root)

Set the Sequencer selection (window-gated)

Opens the sequence in the Sequencer if needed. Channel and key selection are not exposed.

Read the Sequencer selection (window-gated)

Drive the open Sequencer: play, pause, play_to, speed, loop, lock (window-gated)

Current/focused sequence, playing, speed, loop, lock and camera-cut lock of the open Sequencer

Add a sub-sequence on a given row of the existing shot track

Reuses the first cinematic shot track (else sub track); creates a shot track only when none exists.

Set a sub-section's bias, time scale, loop, offsets, sequence or shot name

Rename a cinematic shot section

Sub-sequence/shot sections with ranges, bias, time scale and loop settings

Camera cuts with binding, range, ease, lock-previous, plus track blend settings and gaps

Retarget, retime, ease or lock-previous one camera cut

Camera cut track settings: can_blend, auto-manage sections, rearrange

Remove one camera cut

Edit the spawnable's template actor (any property, any component)

Works on the 5.6+ custom-binding template and on legacy spawnables. Changing the actor class is not supported. A property that cannot be set fails the whole call and nothing changes.

Spawn ownership, continuous respawn and net-addressable name of a spawnable

Convert a binding to a custom binding class (headless)

Custom binding class and properties per binding

Every binding tag and the bindings it marks

Unregister a binding tag sequence-wide

Find (and optionally prune) possessable references that no longer resolve

Returns findings with a verdict. Repair removes invalid object references and fixes up the possessed class; it never deletes a binding.

Report the sequence's director Blueprint and its functions

Put a condition on a section, track or track row (native on 5.6/5.7/5.8)

Read the condition on a section, track or track row

Remove the condition from a section, track or track row

Key an event bound to a director-Blueprint endpoint, with payload values

Only trigger sections carry per-frame keys. Creates the director Blueprint endpoint headlessly through the Sequencer scripting library.

Copy sections into a portable payload (also lands on the OS clipboard)

Paste a copy_sections payload onto a track at a frame

Copy tracks into a portable payload (also lands on the OS clipboard)

Paste a copy_tracks payload into a sequence (bound tracks need a target binding)

Bound tracks paste only onto the given binding and replace a same-class, same-name track there; root and camera-cut tracks go to the target root.

Create a director-Blueprint resolver function for a binding (dynamic binding)

Converts the binding to a director-Blueprint custom binding when needed, creates the function endpoint with Call In Editor set, and wires it as the resolver.

Point a binding's dynamic binding at an existing director-Blueprint function

Put a director-Blueprint condition on a section, track or row and create its function

Export a Level Sequence to FBX (headless)

Import an FBX onto a Level Sequence's bindings (headless, no dialog)

Bake a binding's animation to an AnimSequence asset

Bake to an AnimSequence after a delay (5.7+), letting spawnables settle first

Link an existing AnimSequence to a binding

Linked AnimSequences of a sequence, or the sequence an AnimSequence links to

Drop every AnimSequence link from a sequence

Import an FBX onto a binding's Control Rig track channels

Export a binding's Control Rig track channels to FBX

Uses the rig track's section-to-key (engine API); the reply reports which track and section were exported.

Jobs in the Movie Render Queue with config mode, presets and shots

Add a render job for a Level Sequence to the Movie Render Queue

Remove a job from the Movie Render Queue

Duplicate a job in the Movie Render Queue

Assign a preset, a graph preset, a config mode or setting values to a job

Settings are tried on a throwaway instance first: an unknown key, a bad value, an abstract or shot-only setting class, or a config_mode that cannot apply fails before the job changes.

Enable/disable a shot or give it an override config or graph preset

Save the Movie Render Queue as an asset and/or a manifest file

Replace the Movie Render Queue from a queue asset or a manifest file

Cancel the active render (editor queue and CLI-started renders)

Primary, shot and graph render config assets in the project

Start a headless Take Recorder take (the Sequencer window is not opened)

Needs the Takes plugin enabled in the project.

Stop the active take and report the recorded sequence

Cancel the active take

Take Recorder plugin/enabled/recording state and the pending sources

Add actor (or other) sources to the pending take

Pending take sources

Recorded takes for a slate

Set section ease-in/out (fade) length

Set section blend type (additive layering)

Add a sound on a master audio track

Add a sub-sequence (shot) on a cinematic shot track

Add an event track section (repeater/trigger)

Add a time-warp track with a fixed play rate

Add a timeline marker

List timeline markers

Remove a timeline marker by index

Add a root folder (organization)

List root folders

Add a binding or root track to a folder

Set evaluation type (framelocked/withsubframes)

Add a tag to a binding

Remove a tag from a binding

Deep report for one binding: tracks, sections, channels (filterable), optional keys

Evaluate channel value(s) at a frame/time (e.g. Location.X at frame 500)

Move the Sequencer timeline bar to a frame/time (sequence must be open)

Read the Sequencer playhead position (sequence must be open)

Play or pause the open Sequencer

List keyable properties of a binding's object/component (discover what you can animate)

Possess an actor's component as a child binding (needed to animate LightColor/Intensity)

Add a property track bound to a property (auto-picks track class); enables color/intensity/etc.

Batch-add keys to multiple channels of a section in ONE call

Verdict for a whole sequence: broken bindings, dead sections, missing assets, compile state

Returns verdict = pass | pass_with_warnings | fail plus a findings array (code, severity, message, target). Errors (fail): broken_possessable, null_spawnable_template, missing_subsequence, missing_control_rig_class, compiled_data_invalid. Warnings (pass_with_warnings): empty_track, section_outside_playback_range, overlapping_sections, camera_cut_gap, unbound_event_endpoint, compiled_data_dirty. counts_by_code is always complete; only the findings list is capped by --max-results.

cfa validate_sequence /Game/Cine/Shot010
cfa validate_sequence /Game/Cine/Master --recurse-subsequences --checks bindings,sections

Scrub a headless player to a frame and read back what the bindings actually evaluate to

Creates a transient Level Sequence player in the editor world, scrubs it to the requested time, and reports each bound object's name, class, world transform and any properties you ask for. The player, its actor and any spawned spawnables are destroyed before the call returns, so nothing is left in the level or the undo buffer. This is how you prove a key moved something: evaluate the same binding at two frames and compare.

cfa evaluate_sequence --asset-path /Game/Cine/Shot010 --frame 0
cfa evaluate_sequence --asset-path /Game/Cine/Shot010 --frame 2.5 --time-unit seconds --properties Intensity,LightColor

Add an animation to a skeletal-mesh binding; loops to fill the section by default

Control Rig tracks on a sequence, with their rig class and priority

The channel map: every control's channel indices, kinds, labels and mask state

This is the command that tells you how to address a rig channel. Never use the channel NAME: a Position control is Ctrl.X on UE 5.6 and Ctrl.Location.X on 5.7/5.8. Use control_name plus the channel index reported here. Index order is fixed per control type: float = [value], vector2d = [x,y], position/scale = [x,y,z], rotator = [roll,pitch,yaw], transform_no_scale = location xyz + rotation roll/pitch/yaw, transform and euler_transform = those nine with scale xyz last.

cfa list_rig_controls --asset-path /Game/Cine/Shot010 --track-index 0

Add a Control Rig track + section to a binding, headless

Builds the track the way the engine does but without the editor side effects: no DismissAllMenus, no Control Rig edit mode forced on in the level viewport. The section's blend type is left to the engine (first section Absolute, later ones Additive). Name the rig with exactly one of control_rig_asset_path (a Control Rig Blueprint) or control_rig_class (an engine rig class, e.g. FKControlRig). An FK rig takes its controls from the bound skeletal mesh, which is what set_control_rig_apply_mode and load-anim workflows need.

cfa add_control_rig_track --asset-path /Game/Cine/Shot010 --binding-guid <guid> --control-rig-class FKControlRig

Key one control at one frame

Pass a typed value for the whole control, or channel_index plus a plain number for one channel. Value shapes: float/bool/int = a bare value; vector2d = {x,y}; position/scale = {x,y,z}; rotator = {roll,pitch,yaw}; transform/euler_transform = {location:{x,y,z},rotation:{roll,pitch,yaw},scale:{x,y,z}}; transform_no_scale drops the scale block. A flat array of numbers in channel order also works. Components you leave out are not keyed.

cfa add_control_rig_key --asset-path /Game/Cine/Shot010 --track-index 0 --control-name Hand_L_ctrl --frame 30 --value '{"location":{"x":50}}'

Batch: N controls x M frames on a rig section in ONE call and one undo step

keys is [{control_name, channel_index?, interpolation?, frames:[...], values:[...]}]. frames and values must be the same length; each value uses the same shapes as add_control_rig_key. Every entry is validated before anything is written, so a bad control name late in the batch cannot leave a half-applied edit.

cfa add_control_rig_keys --asset-path /Game/Cine/Shot010 --track-index 0 --keys '[{"control_name":"Hand_L_ctrl","frames":[0,30],"values":[{"location":{"x":0}},{"location":{"x":50}}]}]'

Read a rig section's keys back per control and channel

Reports total_keys - every key on every channel of the section, unaffected by max_results truncation, max_keys or channel_index - plus controls_with_keys, the names that carry them. max_keys caps the keys each channel returns (default 30); every channel reports its own key_count and truncated, so a capped read is never mistaken for a short one.

Delete a control's keys, all of them or inside a frame range

Naming start_frame or end_frame restricts the delete to that range. Without either bound every key goes.

Set a control's channel defaults - the value it holds with no keys

Show or hide controls on a rig section

Set an FK Control Rig track's apply mode

Set a Control Rig track's evaluation priority order

Repoint a track's channels at renamed rig controls

Add an anim layer for some controls of a rig track

Makes a new animation layer that holds the named controls (the Anim Layers panel's + button). The first layer of a sequence also makes the base layer, so the new layer is index 1. A new layer is Additive with weight 1; --name, --weight and --type change that in the same call. The named controls are left selected on the rig. Needs the Level Sequence open in a Sequencer window; the command opens it when it can.

cfa add_control_rig_anim_layer --asset-path /Game/Cine/Shot010 --track-index 0 --control-names hand_l_ctrl,hand_r_ctrl --name Hands

Delete one anim layer and its sections

Deletes the layer at --index with the sections it owns. Layer 0 is the base layer and is never deleted; collapse_control_rig_anim_layers flattens every layer into one. Needs the Level Sequence open in a Sequencer window; the command opens it when it can.

cfa remove_control_rig_anim_layer --asset-path /Game/Cine/Shot010 --index 2

Copy one anim layer with its keys

Copies the layer at --index and replies with the new layer. The base layer and a layer with no controls are not copied. Needs the Level Sequence open in a Sequencer window; the command opens it when it can.

cfa duplicate_control_rig_anim_layer --asset-path /Game/Cine/Shot010 --index 1

Merge two or more anim layers into the lowest one

Merges the named layers onto the one with the lowest index and removes the others. --key-mode KeysOnly (default) merges on the frames that carry keys; AllFrames bakes every --frame-increment frames and can --reduce-keys after. Needs the Level Sequence open in a Sequencer window; the command opens it when it can.

cfa merge_control_rig_anim_layers --asset-path /Game/Cine/Shot010 --indices 1,2

Change an anim layer: name, weight, type, mute, lock, key target, controls

Changes only what you pass. --active=false mutes the layer, --locked=true locks it, --keyed makes it the layer that takes new keys, --type switches Additive / Override. --add-controls and --remove-controls change which controls of a rig track the layer holds (give --track-index for them). A locked layer refuses every other change, so an unlock is applied first and a lock last, and the command fails with the reason when the engine did not take a value. list_control_rig_anim_layers reads the result back. Needs the Level Sequence open in a Sequencer window; the command opens it when it can.

cfa set_control_rig_anim_layer --asset-path /Game/Cine/Shot010 --index 1 --weight 0.5 --name Offset

Move an anim layer to another index (UE 5.8+)

Moves the layer at --index to --new-index. The base layer stays at 0. UE 5.6 and 5.7 have no layer reorder, and the command says so there. Needs the Level Sequence open in a Sequencer window; the command opens it when it can.

cfa reorder_control_rig_anim_layer --asset-path /Game/Cine/Shot010 --index 3 --new-index 1

Read controls in WORLD space at given frames

Evaluates the sequence at each frame and returns the world transform of each control: location, rotation and scale as the viewport shows them, after parents, spaces, constraints and layers. list_control_rig_keys gives the LOCAL keyed values. The rig must be bound to an actor in the open level. At most 500 samples (controls x frames) in one call. Needs the Level Sequence open in a Sequencer window; the command opens it when it can.

cfa get_control_rig_world_transform --asset-path /Game/Cine/Shot010 --track-index 0 --control-names hand_l_ctrl --frames '[0,12,24]'

Key a control at a WORLD transform on given frames

Keys the control so it sits at a world transform, whatever its parent or space is at that frame: the engine works out the local value. --transform is one transform for every frame; --transforms is an array with one for each frame. The reply reads the control back and gives the largest distance from the transform asked for; verdict pass_with_warnings means a limit, a constraint or a later layer holds the control off it. On the frame of a space key the engine also keys the tick before it, so the control does not jump there. The rig must be bound to an actor in the open level. Needs the Level Sequence open in a Sequencer window; the command opens it when it can.

cfa set_control_rig_world_transform --asset-path /Game/Cine/Shot010 --track-index 0 --control-name hand_l_ctrl --frames '[0,24]' --transform '{"location":[50,0,120]}'

Move one space key of a control to another frame

Moves the space key at --frame to --new-frame. A frame that has a space key already is refused. No transform key is moved with it, so the control can jump at the new frame.

cfa move_control_rig_space_key --asset-path /Game/Cine/Shot010 --track-index 0 --control-name hand_l_ctrl --frame 10 --new-frame 14

Move one activation key of a timeline constraint to another frame

Moves the activation key at --frame to --new-frame. A frame that has a key already is refused. No transform key is changed: run compensate_timeline_constraint after if the child must not jump.

cfa move_constraint_key --asset-path /Game/Cine/Shot010 --track-index 0 --constraint-name Parent_hand_l_ctrl --frame 10 --new-frame 14

Add the transform keys that stop a control jumping at a space key

The editor's own space compensation at --frame, or at every space key with --all: it copies the control's world pose AT the space key onto the tick before it, so the control does not jump there. Use it for a space key that was put on a frame the control is keyed on already (a raw add_control_rig_space_key, or a moved space key). It is only right when the control has a transform key at the frame of the space key; the command refuses a space key that has none, because the copy would make a new jump. add_control_rig_space_key --compensate and set_control_rig_world_transform need no compensation after them. Needs the Level Sequence open in a Sequencer window; the command opens it when it can.

cfa compensate_control_rig_space --asset-path /Game/Cine/Shot010 --track-index 0 --all

Add the transform keys that stop a constrained control jumping at an activation key

Runs the editor's own constraint compensation at --frame, or at every activation key with --all, so the child keeps its place when the constraint turns on or off. set_constraint_active_key, move and remove do not compensate on their own. Only transform constraints are compensated. Needs the Level Sequence open in a Sequencer window; the command opens it when it can.

cfa compensate_timeline_constraint --asset-path /Game/Cine/Shot010 --track-index 0 --constraint-name Parent_hand_l_ctrl --all

Bake a timeline constraint into plain keys on the child

Writes the motion the constraint gives the child as transform keys, then keys the constraint off over the baked range. --frames names the frames; with none, the ranges where the constraint is active are baked. Only transform constraints are baked. Needs the Level Sequence open in a Sequencer window; the command opens it when it can.

cfa bake_timeline_constraint --asset-path /Game/Cine/Shot010 --track-index 0 --constraint-name Parent_hand_l_ctrl

Read the sequence's Control Rig anim layers (index, name, weight, type, controls)

Read-only and purely reflective: UAnimLayers is a private engine class stored as asset user data on the Level Sequence. Returns has_anim_layers=false and an empty list when the sequence has none - it never creates the layer container the way the engine's own getter does.

Select controls of a rig track

Sets which controls of a Sequencer rig are selected. --mode replace (default) clears the selection on every rig of the sequence first, add keeps it, remove takes the named controls off. --clear selects nothing. --mirrored replace moves the selection to the controls on the other side (hand_l to hand_r), --mirrored add keeps both sides; the left and right name parts come from the project's Control Rig pose mirror settings. --pose-path selects the controls a pose asset holds. --frame moves the level viewport camera to the selected controls (the Animation mode's Frame Selection; it opens the sequence and turns the mode on) and replies camera_location and camera_moved. Works with the sequence closed. get_control_rig_selection reads the result.