Ping Ableton Live Remote Script TCP bridge, report connection status, script version, and available capabilities.

Read properties of the Song, a Track, Scene, ClipSlot, Clip, Groove, cue point, the app, or a device, rack chain, drum pad or device parameter. Addresses: 'song', 'master', 'tracks/N', 'returns/N', 'scenes/N', 'tracks/N/slots/M' (clip slot) and 'tracks/N/slots/M/clip', 'tracks/N/arrangement/M' (arrangement clips in time order), 'tracks/N/take_lanes/K', 'tracks/N/devices/M' (also returns/N and master; then '/parameters/P', '/sample' for a Simpler, '/chains/C/devices/...', '/drum_pads/NOTE', '/mixer/volume'), 'grooves/N' (groove pool), 'cue_points/N' and 'app' (the Live application). Indices are 0-based. A name selector works anywhere a number does, e.g. 'tracks/name:Drift' (exact match; several matches is an error that lists their indices). Give names for specific properties, or omit it to read every readable property (properties that do not apply to the object, e.g. audio-only ones on a MIDI clip, are listed under unavailable). Enum values come back as names. Use list_properties to see what exists.

Set properties on the Song, a Track, Scene, ClipSlot, Clip, Groove, cue point, device, rack chain, drum pad or device PARAMETER (property value, checked against the parameter's own range). A clip's groove is set to a groove address (grooves/N). Addresses: 'song', 'master', 'tracks/N', 'returns/N', 'scenes/N', 'tracks/N/slots/M' (clip slot) and 'tracks/N/slots/M/clip', 'tracks/N/arrangement/M' (arrangement clips in time order), 'tracks/N/take_lanes/K', 'tracks/N/devices/M' (also returns/N and master; then '/parameters/P', '/sample' for a Simpler, '/chains/C/devices/...', '/drum_pads/NOTE', '/mixer/volume'), 'grooves/N' (groove pool), 'cue_points/N' and 'app' (the Live application). Indices are 0-based. A name selector works anywhere a number does, e.g. 'tracks/name:Drift' (exact match; several matches is an error that lists their indices). Values are checked strictly (booleans must be true/false, integers whole numbers, enums given by name; see list_properties). Interdependent properties (e.g. loop_start/loop_end) can be set together in any order, and the call is all-or-nothing: if one write fails, the others are restored. Returns each property's previous and new value. Each call is one undo step in Live. Give address + properties, or items to change several objects in one call. expect ({name}) refuses to write if the object is not the one you meant.

What this Live and this bridge can do: script version and build id, Live version and variant, unavailable features, and feature probes (Max for Live present, Conversions, note probabilities, Suite devices such as Meld/Roar). A beta build reports variant 'Beta' and edition 'unknown' because the edition is not readable: rely on features, never on the edition. Also lists every bridge command.

A compact map of the whole Set: song settings, every track (regular, return, master) with its address, kind, mixer state, devices and clips, and every scene. Each track has a hash and the Set has a fingerprint that only change when the Set really changes (playhead, play state and meters are ignored): compare fingerprints to detect edits, or hashes to see which track changed. Set include_clips=false for a lighter summary (clip counts and hashes stay).

Transport and playhead actions: play, continue, stop, stop_all_clips, tap_tempo, jump_by (needs amount: beats, negative jumps back), next_cue / prev_cue (jump to a cue point), toggle_cue (add or remove a cue point at the playhead while playing, or at the arrangement insert marker while stopped, which only the user controls), capture_midi (keep recently played MIDI) and capture_and_insert_scene. Returns the resulting transport state. To change tempo or loop settings use set_properties on 'song'. For undo/redo use the history tool.

Undo or redo in Live. Every writing tool call is one undo step, so undo reverts exactly the last call (exceptions: Live records a track rename and every device parameter write as their own entries, so a call or batch that writes several parameters takes that many extra undos). Undo is global: it also reverts edits the user made by hand, so use it deliberately. steps (1-50, default 1) repeats it; returns the names of what was undone and whether more undo/redo is available.

Create a track, return track, scene, MIDI clip, audio clip, arrangement clip or take lane and get back its address. kind: audio_track, midi_track, return_track (always appended), scene, audio_clip (address of an EMPTY slot on an audio track and path: an absolute path to an audio file; it is auto-warped by Live's settings and the result reports its length), arrangement_midi_clip (address of a track or take lane, time in beats on the timeline, length default 4) and arrangement_audio_clip (address, time, path), take_lane (address of a track), midi_clip (address of an EMPTY clip slot like 'tracks/2/slots/0', length in beats, default 4). Cue points cannot be created (Live only toggles them at the arrangement insert marker, which is UI state). For tracks and scenes index is the insertion position (0-based; omit or -1 to append; existing objects shift, so re-read addresses afterwards). Optional name and color (RGB integer; Live snaps it to the nearest palette colour and the result reports the colour it applied) are applied immediately. One undo step.

Duplicate a regular track ('tracks/N', with its devices and clips), a scene ('scenes/N') or a clip slot ('tracks/N/slots/M', with its clip). The copy lands right after the source (a duplicated slot goes into the next scene); returns the new address. Return tracks and the master cannot be duplicated.

Delete a track ('tracks/N'), return track ('returns/N'), scene ('scenes/N'), clip ('tracks/N/slots/M/clip' or an arrangement clip 'tracks/N/arrangement/M'); cue points cannot be deleted (Live only toggles them at the arrangement insert marker). DESTRUCTIVE (one undo step brings it back). expect is mandatory: {"name": <the object's current name>}. Indices shift after every create/delete, so read the object first; if its name no longer matches, nothing is deleted (GUARD_FAILED). The master track cannot be deleted, and a Set always keeps at least one scene.

Fire or stop things in the Session view. address is a clip slot or clip ('tracks/N/slots/M[/clip]': fire starts the clip, or the slot's stop button when empty; stop stops it), a scene ('scenes/N': fire only) , a track ('tracks/N': stop all its clips), a cue point ('cue_points/N': jump there) or 'song' (stop all clips, transport keeps running). Options for a slot: quantization overrides the launch quantization for this launch (q_no_q, q_bar, q_half...), legato starts the clip in sync with the one playing, record_length (beats, empty slot only) starts a recording that ends by itself. Scenes take legato and select (false keeps the selection where it is). Stops take quantized (default true; false stops immediately). Launching does not change the Set's content. Arrangement clips cannot be launched (use transport).

Edit a clip in place: crop (discard everything outside the loop), duplicate_loop (loop twice as long, notes and envelopes copied; MIDI only), quantize (grid: rec_q_quarter, rec_q_eight, rec_q_eight_triplet, rec_q_sixtenth, rec_q_thirtysecond...; amount 0-1, default 1; on audio clips it aligns warp markers), quantize_pitch (like quantize for one pitch, 0-127; MIDI only), scrub (position in beats) / stop_scrub, move_playing_pos (amount beats, negative goes back; clip must be playing), and on AUDIO clips add_warp_marker (beat_time; sample_time = seconds in the file, default: where it changes nothing), move_warp_marker (beat_time of an existing marker, distance in beats: this is how audio is retimed) and remove_warp_marker (beat_time); current markers are the clip's warp_markers property. to_arrangement copies a SESSION clip onto its track's arrangement timeline at time (beats) and returns the new clip's address; a clip that carries automation envelopes turns them into arrangement track automation (the envelopes do not stay on the copy; the result lists the parameters now automated), which is how arrangement automation is written: draw_automation on the Session clip first. address must be a clip. crop and quantize rewrite content: one undo step each, and expect ({name}) refuses to act on the wrong clip. Returns the clip's length and loop after the action.

Read the MIDI notes of a clip (address: 'tracks/N/slots/M/clip', MIDI clips only) with every field Live stores: id (stable while the note exists; use it with edit_notes), pitch, start_time and duration (beats), velocity (1-127), mute, probability (0-1), velocity_deviation (-127..127) and release_velocity (0-127). Sorted by start_time then pitch. Without filters it returns all notes (capped by limit, default 2000; truncated says if more exist). Filter by a range (from_time/time_span in beats, from_pitch/pitch_span), by ids, or with selected: true for the notes selected in Live's editor. Also returns the clip's length and loop.

Add MIDI notes to a clip (additive: existing notes stay). Each note: pitch (0-127), start_time and duration (beats, duration > 0) and optionally velocity (1-127, default 100), mute, probability (0-1, default 1), velocity_deviation (-127..127, default 0), release_velocity (0-127, default 64). Every note is validated before anything is written, so a bad note rejects the whole call (up to 5000 notes per call). Live never lets notes of one pitch overlap: a new note shortens an earlier note of that pitch that runs into it, and one starting at exactly the same time replaces it, so note_count in the result can be lower than expected. Returns the new note ids. One undo step. To replace or change existing notes use edit_notes.

Change notes that already exist in a MIDI clip. action: modify (changes: [{id, }] or ids + set: {field: value}; keeps note ids and per-note events), remove (exactly one of ids, a range from_time/time_span/from_pitch/pitch_span, or all: true), replace (swap the notes in a range, or all notes, for notes in one step; if Live refuses the new notes the old ones are restored; omit notes to clear the range), duplicate (ids, optional destination_time and transposition semitones), duplicate_region (start, length, destination_time, optional pitch and transposition) and select (ids, all: true or none: true, for the editor's selection). Get ids from get_notes; unknown ids are refused (NOT_FOUND) with nothing changed. expect ({name}) guards against the wrong clip. One undo step; DESTRUCTIVE (remove, replace).

Read a device with all its parameters (index, address, value, min, max, display as Live shows it, default, value_items labels for quantized ones, is_enabled) and, for racks, its chains, return chains, occupied drum pads (each with the addresses of the devices it holds) and macro state. address: 'tracks/2/devices/0', 'returns/0/devices/1', 'master/devices/0' or nested 'tracks/2/devices/0/chains/1/devices/2' (a name selector works too: 'tracks/2/devices/name:EQ Eight'). Device names per track are in describe_set. Change a parameter with set_properties on its address ('.../parameters/5' or '.../parameters/name:Frequency', field value; a quantized parameter also takes its label such as 'Low-pass'); many at once with items. Devices also have properties (name, on, collapsed) and racks chains, pads and mixers have theirs: see list_properties. Simpler, Wavetable, Drift, Meld, Eq Eight, Looper, Hybrid Reverb, Roar, Spectral Resonator, Shifter, Drum Cell and plug-ins also have their own properties and methods: the result's specific block lists them (choices such as a wavetable or voice mode are properties that take the label the device shows; ..._options lists the labels), and a Simpler's sample is at '/sample'.

Change device structure. action: insert (address of a track, return track, master or rack chain; name as in Live's browser, e.g. 'EQ Eight', 'Drum Rack', 'Audio Effect Rack'; optional position, default end; Live refuses bad placements such as effects before an instrument and says why), delete (address of a device; expect {name} mandatory), duplicate (a device; the copy goes right after it), move (address of a device, to a track or chain, optional position; returns where it landed), save_ab (store the current preset in the A/B compare slot), and for racks: insert_chain (optional position), add_macro, remove_macro, randomize_macros, store_variation, recall_variation (index selects the variation first; else the selected one; which last = the last recalled), delete_variation (index or the selected one; Live does nothing when none is selected, so this refuses), re_enable_automation (address of a parameter whose playing clip automation was overridden, by hand or by any write through this bridge such as set_properties or ramp_parameter, or 'song' for all: hands it back to the automation), call (address of a device or of a Simpler's '.../sample': method and args object, one of the methods get_device lists for it: crop, reverse, warp_as, replace_sample on a Simpler; insert_slice, move_slice, remove_slice on its sample; record, overdub, stop, clear, export_to_clip_slot on a Looper; set_modulation_value on a Wavetable), copy_pad (Drum Rack: from_note and to_note), clear_pad (address of a drum pad, e.g. 'tracks/1/devices/0/drum_pads/36'; expect {name} mandatory). Returns the new address where one is created. One undo step. DESTRUCTIVE for delete, clear_pad, remove_macro, delete_variation.

Read or change a track's (or a side-chain device's) input or output routing by the display names the mixer shows. address: 'tracks/N', 'returns/N', 'master' or a device with a side-chain such as a Compressor ('tracks/2/devices/1', input). direction: input or output. action get (default) returns the current type and channel and everything available_types / available_channels (category: external, resampling, master, track, parent_group_track, none...). set takes type and/or channel (exact display names; channels depend on the type, so set both in one call); Live only offers valid choices. Feedback guard: routing a track's INPUT from the master or from resampling while its monitoring is not Off can loop the sound back at full level, so it refuses unless allow_feedback: true (or monitoring is set to OFF first with set_properties current_monitoring_state). One undo step.

Draw a clip automation envelope for a device or mixer parameter, inside Live (tempo-locked, sample-accurate). clip: a Session clip address ('tracks/2/slots/0/clip'); parameter: a parameter address on that clip's track ('tracks/2/devices/0/parameters/5', 'tracks/2/mixer/volume', 'tracks/2/mixer/sends/0'). points: [{time, value, curve?}] with time in beats from clip start and value in the parameter's own units (get_device shows min/max). The default style 'breakpoints' writes real envelope breakpoints (straight lines between them; smooth/ease curves get a breakpoint every resolution beats, default 0.25; step curves make jumps), so it is editable in Live and light. 'steps' writes a staircase of fine steps instead (resolution default 0.125). curve: linear (default), step, smooth, ease_in, ease_out (a point's own curve shapes the segment after it). mode replace (default) rebuilds the parameter's envelope, merge rewrites only the drawn range (breakpoints outside connect to it by straight lines). With hold (default true) the clip edges are filled with the first/last value. The result includes a readback of Live's stored values. Arrangement clips have no envelopes in Live's API. One undo step per call.

Read a Session clip's automation: every envelope on the clip (or only parameter's) as breakpoints in the parameter's own units: {time, value, jump_from?} (jump_from marks a step: the value just before it), with the parameter's address, name and range. max_points caps each envelope (default 500; truncated says if more exist). Use it to inspect what a clip already does before drawing over it.

Clear one parameter's envelope on a Session clip (clip + parameter), or every envelope on the clip when no parameter is given. Returns whether an envelope existed. One undo step.

Sweep a device or mixer parameter (parameter address) to to over beats or seconds, driven inside Live at about 100 updates per second. For live gestures; use draw_automation for motion that belongs to a looping clip. from defaults to the current value; curve: linear, smooth, ease_in, ease_out. A new ramp on the same parameter replaces the old one. Values are in the parameter's own units. Ramps are not undoable and cannot run inside a batch.

Cancel the ramp on one parameter, or every active ramp when no parameter is given. The parameter stays wherever the ramp had taken it.

Clip follow actions, which Live's API does not have, emulated inside Live on the Remote Script's 10 ms timer. set (address of a Session clip; actions: names or {action, weight} objects, chosen by weight each pass: next, previous, first, last, any, other, again, stop, all relative to the clip's own track; after_bars or after_beats, default one pass through the clip) launches the chosen clip when the clip has played that long. It only acts while the transport runs and the clip plays, once per pass, and launches through Live's normal clip launch, so Live's launch quantization decides the exact moment (the trigger fires ~40 ms early to catch the grid point; use q_none or a matching quantization for tight timing). clear (an address, or everything) stops them at once; status lists them. Configurations live in memory only: they are lost when Live restarts or the script reloads. Not undoable, not batchable.

List the properties get_properties/set_properties know for an object kind: type, whether it is writable, allowed enum values and ranges. Give an address (its kind is used) or a kind: song, track, scene, slot, clip, lane, groove, cue, app, device, chain, pad, parameter or sample. With an address of a device or sample the listing includes its device-specific properties (choices show their labels) and methods.

Change notes already in a MIDI clip with a music transform: reads the notes, transforms them, writes the result in ONE undo step. address: a MIDI clip; transform + params. Transforms: transpose, fit_to_scale, invert, reverse, stretch, shift, humanize, swing, quantize, legato, gate, velocity_shape, strum, recombine, arpeggiate, chop, stack, grace_notes, trill, repeat. Use transform 'help' for every transform's parameters and kind. Select notes with a range (from_time/time_span/from_pitch/pitch_span) or, for in-place transforms, ids from get_notes; default is every note. dry_run previews without writing. In-place transforms keep note ids and settings; rebuilds replace the selected notes in one step; additions keep them. Notes that would land outside MIDI range or before beat 0 refuse in-place transforms. Times are beats, pitches C3 = 60.

Compose notes into a MIDI clip from a generator, in one undo step. address: a MIDI clip (create one with create kind midi_clip; the result warns if the music runs past its loop end); generator + params. Generators: euclidean, drum_pattern, chord_progression, bassline, melody, scale_run, random_notes. Use generator 'help' for every generator's parameters (keys, chord progressions by roman numeral or symbol, drum step strings, seeds...). start_time offsets everything (beats). mode: add (default; keeps existing notes), replace_span (replaces notes inside the generated span) or replace_all. dry_run previews.

Run several tools in ONE round trip and ONE undo step (history undo reverts all of it; Live records each device parameter write as its own extra undo entry). ops: [{tool, args}] with each tool's usual arguments, run in order on Live's main thread. Later ops can use earlier results: '$0.address' is the address op 0 returned (a whole-string reference keeps its type, e.g. a number; inside a longer string it is inserted as text; '$1.ids[0]' indexes lists). Example: [{tool:'create',args:{kind:'midi_track',name:'Bass'}},{tool:'device_action',args:{action:'insert',address:'$0.address',name:'Drift'}}]. on_error: stop (default; ops already applied stay applied as one undo step, later ones do not run) or continue. A failure returns BATCH_FAILED with every op's outcome. Up to 100 ops. Batchable tools: get_properties, set_properties, list_properties, describe_set, get_capabilities, get_notes, get_device, create, duplicate, delete, write_notes, edit_notes, clip_action, device_action, routing, draw_automation, get_automation, clear_automation, load_item. Not batchable: transport, launch, history, ramp_parameter, cancel_ramps, record, follow_actions (not undoable edits), transform_notes, generate_notes, browse, analyze_audio_clip and convert (they combine calls or wait).

Explore and search Live's browser (instruments, presets, effects, drum kits, packs, user library...). action list (default): path like 'instruments/Drift/Bass' (no path lists the roots), kind all|folders|loadable|devices, paged with limit (default 100) and offset; every item has a path to browse deeper or load. search: query words (all must appear in the item's path, e.g. 'drift bass sub') over the preset and device names of roots (default: instruments, audio_effects, midi_effects, drums, sounds, max_for_live, user_library, packs); kind loadable (default), devices or folders; ranked with exact and prefix name matches first. The first search builds an index by walking the browser in short slices (a few seconds, Live stays responsive) and keeps it until refresh: true; the big sample libraries ('samples', 'clips') are only indexed if you name them in roots. index: (re)build the index for roots. Load what you find with load_item.

Load a browser item (from browse) by path, or by uri (fast when it is in the search index, otherwise slow: it walks the whole browser). target: a track ('tracks/2', 'returns/0', 'master') loads an instrument, effect or preset onto it and returns the addresses of the devices it added; a clip slot ('tracks/2/slots/0') loads a sample into it; a device ('tracks/2/devices/0') hot-swaps it for the item. Loading selects the target in Live's window. action preview plays an item on the preview channel without loading it (stop_preview stops it; audible, and it needs no target). Folders and categories cannot be loaded: browse into them. One undo step.

Analyze the source file of an audio clip (address: 'tracks/N/slots/M/clip') locally with ffmpeg: format metadata, integrated loudness (LUFS), sample and true peak, RMS and an approximate six-band frequency profile, next to the clip's own settings (warping, gain, pitch). Needs ffmpeg and ffprobe on the MCP host. Compressed Ableton .aif files and REX files cannot be analyzed and say so.

Live's audio conversions (edition dependent: Live's own refusal comes through). action: check (can this audio clip become MIDI?), audio_to_midi (type harmony|melody|drums: a new MIDI track with the extracted notes), simpler_track (a new MIDI track with a Simpler playing the clip), drum_rack_from_clip (a new track with a Drum Rack, the clip on the first pad), pad_to_track (address of a drum pad: its chain becomes its own MIDI track), slice_to_drum_rack (address of a Simpler in Slicing mode: every slice gets a pad). address is the audio clip (or pad, or Simpler). Returns the new tracks with their addresses, devices and clips; audio_to_midi finishes in the background in Live, so this waits for the new track (up to 15 s). One undo step.