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 toward a neighbour by a weight

amount 0 is a no-op; 1 sets each key to its next neighbour; -1 to its previous.

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

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

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.

Verdict for the rig tracks: rig class resolvable, every control has channels, mask consistent

Returns verdict = pass | pass_with_warnings | fail plus findings (code, severity, target, message). Errors: missing_control_rig_class, no_sections, wrong_section_class, control_without_channels. Errors also: space_key_missing_element, constraint_unresolved, constraint_handles_unresolved. Warnings: masked_control_has_keys, orphan_channel_map_entry, all_controls_masked, constraint_never_keyed.

Key a space switch on a rig control (world, default parent, another control, or a bone)

space_type world and default_parent need no target; control and bone need space_target. world keys the WorldSpace sentinel, default_parent keys Parent with no element, and a control or bone target keys ControlRig with that element - even when it is the control's own parent. The space channel is created on first use. No compensation is applied - the engine only compensates the surrounding transform keys through an open Sequencer window.

cfa add_control_rig_space_key --asset-path /Game/Cine/Shot010 --track-index 0 --control-name Hand_L_ctrl --space-type world --frame 30

Space keys per control: keyed frames, the unique space list, and the resulting intervals

Epic exposes no space read at all. Each control reports its keys (frame + space), the unique spaces it ever switches to with whether each still resolves, and the frame intervals each space covers.

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

Delete one space key from a control's space channel

Deletes by time, never by value: only the key at that exact frame goes, reported as keys_removed. The editor's own space delete compensates the surrounding transform keys. This one does not - the compensation path needs an open Sequencer. The output says so on every call.

cfa remove_control_rig_space_key --asset-path /Game/Cine/Shot010 --track-index 0 --control-name Hand_L_ctrl --frame 30

Constrain a rig control or actor to another, with an activation channel on the rig section

Child and parent are each either a rig control on the track (child_control_name / parent_control_name) or an actor binding (child_binding_guid / parent_binding_guid). The constraint is registered on the world's constraints manager and its activation channel is added to the section, so it can be keyed with set_constraint_active_key. No automatic compensation is applied.

cfa add_timeline_constraint --asset-path /Game/Cine/Shot010 --track-index 0 --constraint-type parent --child-control-name Hand_L_ctrl --parent-binding-guid <guid>

Constraints on a rig section: name, type, child, parent, and their activation keys

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

Key a timeline constraint on or off at a frame

cfa set_constraint_active_key --asset-path /Game/Cine/Shot010 --track-index 0 --constraint-name ParentConstraint --active --frame 30

Delete one constraint activation key

cfa remove_constraint_key --asset-path /Game/Cine/Shot010 --track-index 0 --constraint-name ParentConstraint --frame 30

Bake an AnimSequence onto a Control Rig section, headless

Needs a Skeletal Mesh Component the engine baker can sample: the rig's bound component, or the actor behind binding_guid. anim_start and anim_end are frames of the SOURCE animation, not the timeline. Reports the section key count before and after.

cfa load_anim_into_control_rig --asset-path /Game/Cine/Shot010 --track-index 0 --animation /Game/Anims/AS_Run

Bake a skeletal binding's animation onto a new Control Rig track (needs an open Sequencer)

The engine function behind this crashes when no Level Sequence is open, so the sequence is opened first and the command refuses with requires_sequencer_window rather than calling in blind. Name the rig with exactly one of control_rig_asset_path or control_rig_class; control_rig_class FKControlRig is the editor's "Bake To FK Control Rig". The bake is destructive to the binding's existing Control Rig tracks. On UE 5.8 the engine removes every Control Rig track on the binding and adds a fresh one; on 5.6 and 5.7 it keeps them, mutes their sections and reuses the first one for the new rig. The binding's skeletal animation track survives either way, but 5.8 disables the whole track while 5.6 and 5.7 only mute its sections. removed_tracks lists the rig tracks (by object identity) that were there before and are gone after, replaced_tracks counts how many came back with the same name and rig class, which is what a same-class re-bake on 5.8 looks like. animation_track_state reports present / disabled / muted / removed / none as observed, so expect disabled on 5.8 where 5.6 and 5.7 say muted. When tracks were removed the reply carries a warning saying their keys went with them. The engine always renames the baked track to the rig class name, so the reply puts track_name back, or the name of the one rig track that was there before when you pass none.

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

Export a binding's animation back out to an AnimSequence (needs an open Sequencer)

The reverse bake Epic never exposed to the CLI. The destination AnimSequence is created against the binding's skeleton when it does not exist yet.

cfa export_control_rig_to_anim_sequence --asset-path /Game/Cine/Shot010 --binding-guid <guid> --anim-sequence-path /Game/Anims/AS_Take01

Key reduction tuned for rig channels (needs an open Sequencer)

cfa smart_reduce_control_rig --asset-path /Game/Cine/Shot010 --track-index 0 --tolerance-percentage 5

Snap controls onto an actor or another control over a frame range (needs an open Sequencer)

Name the target with exactly one of target_control_name, target_binding_guid or target_actor_name. A key is written per frame across the interval.