Remove ai objects. op.action (params; * = required):

• clear_audio_classification(clip, folder): Clear the audio classification of a clip or folder.

• clear_transcription(clip, folder, nested): Clear the transcription of a clip or folder (irreversible). First call returns a plan + confirm_token; repeat it with confirm_token to apply. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Read ai state, no side effects: use it to find ids and check results. op.action (params; * = required):

• get_transcription(clip*, nested, offset, limit, include_words): Read a clip transcription (segments, optional words), paginated.

Change ai state; may overwrite current values. Every change is read back from Resolve (receipt.verified=false means it did not take). op.action (params; * = required):

• analyze_for_intellisearch(clip, folder, identify_faces, better_mode): Run Intellisearch analysis on a clip or folder (blocking, needs AI Extras).

• analyze_for_slate(clip, folder, marker_color): Run Slate ID analysis on a clip or folder (job, needs the AI Slate ID Extras). [job]

• create_subtitles_from_audio(language, caption_preset, chars_per_line, line_break, gap): Create subtitles from the audio of the current timeline (job). [job]

• detect_scene_cuts(): Detect and make scene cuts along the current timeline (job). [job]

• generate_speech(text*, voice_model, custom_voice_file, speed, variation, pitch, generation_id, filename, +2 more): Generate speech audio from text into the Media Pool (needs AI Speech Generator).

• perform_audio_classification(clip, folder): Classify the audio of a clip or folder (blocking; works without Extras).

• remove_motion_blur(clip, folder, options): Render motion-deblurred copies of a clip or folder's clips (blocking, creates clips).

• smart_reframe(item*): Run Smart Reframe on a timeline item (job). [job]

• transcribe_audio(clip, folder, speaker_detection, as_nested_clip): Transcribe the audio of a clip or folder (job; read it with get_transcription). [job] Shortcuts (prefer them for whole tasks):

• workflow_write.build_vertical_reel: Build a vertical timeline from clips, add subtitles and optionally render it. One call instead of create_subtitles_from_audio. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Remove app objects. op.action (params; * = required):

• delete_preset(kind*, name*): Delete a layout, keyboard, user-preferences or burn-in preset.

• disable_background_tasks(): Disable background tasks for this Resolve session (irreversible).

• quit_resolve(): Quit the DaVinci Resolve application. First call returns a plan + confirm_token; repeat it with confirm_token to apply. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Read app state, no side effects: use it to find ids and check results. op.action (params; * = required):

• get_app_info(): Product, version, edition, current page and keyframe mode.

• list_presets(kind*): List layout, keyboard, user-preferences, burn-in or Fairlight presets.

Change app state; may overwrite current values. Every change is read back from Resolve (receipt.verified=false means it did not take). op.action (params; * = required):

• export_preset(kind*, name*, path*): Export a layout, keyboard, user-preferences or burn-in preset to a file.

• import_preset(kind*, path*, name): Import a layout, keyboard, user-preferences or burn-in preset file.

• load_preset(kind*, name*): Load a layout, keyboard or user-preferences preset.

• open_page(page*): Switch Resolve to a page (media, cut, edit, fusion, color, fairlight, deliver).

• save_preset(kind*, name*): Save the current layout or user preferences as a named preset.

• set_high_priority(enabled*): Raise or restore the Resolve process priority (needs a real bool on 21.1).

• set_keyframe_mode(mode*): Set the keyframe mode (all, color or sizing).

• update_preset(kind*, name*): Overwrite a layout preset with the current window layout. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Read audio state, no side effects: use it to find ids and check results. op.action (params; * = required):

• analyze_loudness(path, clip): Measure integrated LUFS, true peak and LRA of a file with ffmpeg (no Resolve needed).

• detect_silence(path, clip, noise_db, min_duration_s): Find silent intervals of a file with ffmpeg silencedetect (no Resolve needed).

• get_audio_mapping(clip, item): Read the audio mapping of a clip or the source channel mapping of an item.

• get_audio_properties(item*): Read audio properties of a timeline item (volume, pan, voice isolation, leveler).

• get_voice_isolation(item, track): Read voice isolation state of a timeline item or audio track.

• list_fairlight_presets(): List Fairlight preset names.

• list_normalize_modes(): List valid normalizationMode names for normalize_audio_level.

Change audio state; may overwrite current values. Every change is read back from Resolve (receipt.verified=false means it did not take). op.action (params; * = required):

• apply_fairlight_preset(name*): Apply a Fairlight preset to the current timeline.

• normalize_audio_level(items*, options): Normalize the audio level of timeline items (21.1, Studio).

• normalize_file(path, clip, target_lufs, true_peak_dbtp, lra, sample_rate, output, import_to_pool): Two-pass loudnorm of a file into a new file (job); optional Media Pool import. [job]

• set_audio_mapping(clip, item, mapping*): Write the audio mapping of a clip, or the source channel mapping of an item (21.1).

• set_audio_properties(item*, properties*): Set audio properties of a timeline item (volume, pan, voice isolation, leveler).

• set_voice_isolation(item, track, enabled*, amount): Enable/disable voice isolation on an item or audio track (active timeline only). Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Remove code objects. op.action (params; * = required):

• run_lua(code*): Run Lua through Fusion.Execute (off by default).

• run_python(code*): Run Python with resolve/project/fusion globals; set result (off by default). First call returns a plan + confirm_token; repeat it with confirm_token to apply. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Remove color objects. op.action (params; * = required):

• copy_grades(source*, targets*): Copy the current grade of one clip onto many (overwrites target grades).

• delete_color_group(name*): Delete a color group; its clips become ungrouped.

• delete_version(item*, name*, version_type): Delete a named color version of a clip.

• reset_all_grades(target): Reset all grades of a clip, group or timeline graph. First call returns a plan + confirm_token; repeat it with confirm_token to apply. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Read color state, no side effects: use it to find ids and check results. op.action (params; * = required):

• get_node_graph(target): Read node count, labels, tools, LUT and cache mode of a clip, group or timeline graph.

• list_color_groups(): List the color groups of the project with their clips in a timeline.

• list_versions(item*): List the local and remote color versions of a clip and the current one.

• validate_dctl(source, path): Validate DCTL source code (sensitive to formatting: one-line functions can fail).

Change color state; may overwrite current values. Every change is read back from Resolve (receipt.verified=false means it did not take). op.action (params; * = required):

• add_version(item*, name*, version_type): Add a color version to a clip (Color page; fails from the Edit page).

• apply_grade_from_drx(target*, path*, grade_mode, apply_to_all_layers, reset_first): Apply a DRX grade to a graph (Color page); replaces the current grade, no new version.

• assign_to_color_group(group*, items*): Assign clips to an existing color group.

• create_color_group(name*): Create a color group (the name must be unique).

• encrypt_dctl(input_path*, output_folder*, name, expiry): Encrypt a DCTL file into an output folder.

• export_lut(item*, path*, lut_type): Export the grade of a clip as a LUT file (works only from the Color page).

• load_version(item*, name*, version_type): Make a named color version the active one of a clip.

• remove_from_color_group(items*): Remove clips from their color group.

• rename_color_group(name*, new_name*): Rename a color group.

• rename_version(item*, name*, new_name*, version_type): Rename a color version of a clip.

• reset_node_colors(item*): Reset the node colors of every node in the active version of a clip.

• set_cdl(item*, node*, slope, offset, power, saturation): Set CDL slope, offset, power and saturation on a node of a clip.

• set_node_cache_mode(target*, node*, mode*): Set the render cache mode (auto, enabled, disabled) of a node.

• set_node_enabled(target*, node*, enabled*): Enable or disable a node of a clip, group or timeline graph.

• set_node_lut(target*, node*, lut_path*): Set (or clear) a node LUT; files outside the LUT root are installed into it first. Shortcuts (prefer them for whole tasks):

• workflow_write.apply_look: Apply a LUT to every video item, group them in a color group and grab a still. One call instead of set_node_lut, create_color_group, assign_to_color_group. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Remove fusion objects. op.action (params; * = required):

• clear_keyframes(item*, comp, tool*, input*): Remove the animation of an input, keeping its value at the current time.

• delete_comp(item*, name*): Delete a named Fusion composition from a timeline item.

• delete_tools(item*, comp, tools*): Delete tools from a comp (one undo step).

• install_fuse(filename*, source*, directory): Install a .fuse (Lua run by Resolve): needs code execution enabled + confirmation. First call returns a plan + confirm_token; repeat it with confirm_token to apply. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Read fusion state, no side effects: use it to find ids and check results. op.action (params; * = required):

• comp_info(item*, comp, include_connections): Flow structure of a comp: tools, connections, selection, time range, undo stack.

• list_comps(item*): List the Fusion compositions attached to a timeline item.

• list_fuses(directory, limit): List installed .fuse files in the user Fuses folder.

• registry_types(query, limit, offset): Search the ~1300 registered Fusion tool/modifier ids (Fusion.GetRegSummary), paginated.

• tool_inputs(item*, comp, tool*, names, time, include_keyframes, limit, offset): Inputs of a tool: ids, data types, values at a time, animation, keyframes (paginated).

Change fusion state; may overwrite current values. Every change is read back from Resolve (receipt.verified=false means it did not take). op.action (params; * = required):

• add_comp(item*): Add an empty Fusion composition to a timeline item.

• add_tool(item*, comp, tool_id*, name, x, y): Add a tool to a comp by registry id, with optional name and flow position.

• connect(item*, comp, tool*, input*, source_tool*, source_output): Connect a tool input to the output of another tool.

• create_text_title(item*, text*, comp, name, font, style, size, color, +2 more): Create a Text+ tool with text, font, size and color (connect it to MediaOut to render).

• disconnect(item*, comp, tool*, input*): Disconnect a tool input (one undo step; undo restores the link).

• export_comp(item*, comp, path*): Export a Fusion composition of an item to a new .comp file.

• import_comp(item*, path*): Import a .comp file as a new Fusion composition of a timeline item.

• load_comp(item*, name*): Make a named Fusion composition the active one of a timeline item.

• load_tool_settings(item*, comp, tool*, path*): Load a .setting file onto an existing tool (replaces its parameters).

• paste_settings(item*, comp, text*): Paste a Fusion .setting snippet (text) into a comp; reports the tools it created.

• rename_comp(item*, old_name*, new_name*): Rename a Fusion composition of a timeline item.

• rename_tool(item*, comp, tool*, new_name*): Rename a tool of a comp (expressions referring to the old name keep working in Fusion).

• save_tool_settings(item*, comp, tool*, path*, overwrite): Save a tool (or Group, as a macro) to a new .setting file.

• set_expression(item*, comp, tool*, input*, expression*): Set (or clear, with an empty string) the expression of a tool input.

• set_inputs(item*, comp, sets*): Set many tool inputs in one undo step (the comp is not locked: renders need it).

• set_keyframes(item*, comp, tool*, input*, keys*): Animate an input: add a BezierSpline when needed, then key each (time, value).

• set_tool_enabled(item*, comp, tool*, enabled*): Enable a tool or set it to pass-through (TOOLB_PassThrough). Shortcuts (prefer them for whole tasks):

• workflow_write.title_overlay: Add an animated Text+ title (and Merge over the clip) to a timeline item's Fusion comp. One call instead of create_text_title, add_tool, connect, set_inputs, set_keyframes. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Remove gallery objects. op.action (params; * = required):

• delete_stills(album, stills*): Delete stills from an album. First call returns a plan + confirm_token; repeat it with confirm_token to apply. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Read gallery state, no side effects: use it to find ids and check results. op.action (params; * = required):

• list_albums(): List still and PowerGrade albums with their still counts.

• list_stills(album): List the stills of an album (default: current) with their labels.

Change gallery state; may overwrite current values. Every change is read back from Resolve (receipt.verified=false means it did not take). op.action (params; * = required):

• create_album(kind): Create a still album or a PowerGrade album.

• export_stills(album, stills, folder*, prefix, format): Export stills to a folder (needs the Gallery panel open in Resolve).

• grab_still(scope, frame_source): Grab a still from the current clip, or from all clips, into the current album.

• import_stills(album, paths*): Import still files into an album (default: current).

• rename_album(album*, new_name*): Rename a still or PowerGrade album.

• set_current_album(album*): Make a still album the current one.

• set_still_label(album, still*, label*): Set the label of a still. Shortcuts (prefer them for whole tasks):

• workflow_write.apply_look: Apply a LUT to every video item, group them in a color group and grab a still. One call instead of grab_still. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Read interchange state, no side effects: use it to find ids and check results. op.action (params; * = required):

• read_cube_lut(path*): Read a .cube header: title, dimension, size, domain and entry count.

• read_edl(path*): Parse a CMX3600 EDL into events.

• read_fcpxml(path*): Parse an FCPXML file: assets, clips and markers.

• read_marker_csv(path*): Read a marker CSV (header names are matched leniently).

• read_otio(path*): Parse an OpenTimelineIO JSON file: tracks, clips, gaps and markers.

Change interchange state; may overwrite current values. Every change is read back from Resolve (receipt.verified=false means it did not take). op.action (params; * = required):

• write_cube_lut(path*, title, dim, size, domain_min, domain_max, values, transform, +2 more): Write a 1D/3D .cube LUT from explicit values or a declarative grade transform.

• write_edl(path*, title, fps, drop_frame, events*, overwrite): Write a CMX3600 EDL from a structured event list (fps / drop-frame aware).

• write_fcpxml(path*, items*, name, fps, drop_frame, width, height, start_timecode, +2 more): Write a minimal FCPXML 1.10 (assets, spine of clips / gaps / titles, markers).

• write_marker_csv(path*, fps, drop_frame, markers*, overwrite): Write markers to a CSV (#, Timecode, Name, Color, Duration, Notes).

• write_otio(path*, name, fps, start_timecode, drop_frame, tracks*, markers, overwrite): Write an OpenTimelineIO JSON timeline (tracks of clips / gaps, external refs). Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Remove item objects. op.action (params; * = required):

• delete_item_markers(item*, frame, color, custom_data): Delete item markers by frame, by color ('All' allowed) or by custom data.

• delete_take(item*, index*): Delete a take by 1-based index. First call returns a plan + confirm_token; repeat it with confirm_token to apply. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Read item state, no side effects: use it to find ids and check results. op.action (params; * = required):

• get_fades(item*): Read fade-in / fade-out durations (frames).

• get_item(item*): Full details of a timeline item (timing, source range, track, flags, links).

• get_output_blanking(item*): Read the output blanking of an item and whether the timeline one is used.

• get_properties(item*): Read all item properties (transform, crop, composite, retime, audio...).

• get_speed(item*): Read clip speed options (Percentage, PitchCorrection...).

• get_takes(item*): List the takes of an item (count, selected index, take info).

• list_item_markers(item*): List the markers attached to a timeline item.

Change item state; may overwrite current values. Every change is read back from Resolve (receipt.verified=false means it did not take). op.action (params; * = required):

• add_flag(items*, color*): Add a colored flag to items.

• add_item_marker(item*, frame*, color, name, note, duration, custom_data): Add a marker on a timeline item.

• add_take(item*, clip*, start_frame, end_frame): Add a Media Pool clip as a new take (creates the take selector if needed).

• add_transition(item*, options*): Add a transition at the start or end of an item (needs source handles).

• clear_flags(items*, color): Clear flags of one color, or all flags, on items.

• copy_properties(source*, targets*, keys): Copy properties from one item to many (timeline snapshot taken first).

• finalize_takes(item*): Finalize the take selection (the selected take replaces the selector).

• flatten_multicam(item*, grade): Flatten a multicam item into its active angle (timeline snapshot taken first).

• select_take(item*, index*): Select a take by 1-based index.

• set_clip_color(items*, color): Set the clip color on items, or clear it when no color is given.

• set_enabled(items*, enabled*): Enable or disable clips.

• set_fades(items*, fades*): Set fade-in / fade-out durations (frames) on one or many items.

• set_name(item*, name*): Rename a timeline item.

• set_output_blanking(item*, blanking*): Set per-item output blanking in pixels (Top/Bottom/Left/Right).

• set_properties(items*, properties*): Set properties on one or many items; each key is read back per item.

• set_speed(items*, speed*): Set clip speed (Percentage, PitchCorrection...) on one or many items.

• set_use_timeline_blanking(item*, use_timeline*): Choose between the timeline output blanking and the item's own.

• smart_switch(item*, settings): Run Multicam Smart Switch on a multicam item (synchronous, may take minutes).

• stabilize(items*): Run the stabilizer on items (can be slow; no read-back exists).

• update_marker_custom_data(item*, frame*, custom_data*): Update the custom data string of an item marker. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Remove media objects. op.action (params; * = required):

• clear_clip_metadata(clip*, keys*, third_party): Blank metadata keys of a clip (values are overwritten with empty strings).

• delete_clip_markers(clip*, frame, color, custom_data): Delete clip markers by frame, color ('All' allowed) or custom data.

• delete_clip_mattes(clip*, paths*): Delete mattes of a clip by file path.

• delete_clips(clips*): Delete clips from the Media Pool.

• delete_folders(folders*): Delete Media Pool folders (with their content).

• unlink_clips(clips*): Unlink clips from their media files (they go offline).

• unlink_proxy_media(clip*): Remove the proxy link of a clip. First call returns a plan + confirm_token; repeat it with confirm_token to apply. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Read media state, no side effects: use it to find ids and check results. op.action (params; * = required):

• browse_storage(path*, limit, offset): List subfolders and (paginated) files of a Media Storage folder.

• get_audio_mapping(clip*): Audio mapping of a clip (raw JSON string plus parsed value).

• get_clip(clip*, keys, all_properties): Full details of one clip: properties, metadata, flags, color, proxy, markers.

• get_clip_markers(clip*): List the markers of a Media Pool clip.

• get_clone_status(): Status of the current or most recent clone job.

• get_selection(): Current Media Pool folder and selected clips.

• list_clips(folder, recursive, name_contains, type, clip_color, flag, keys, limit, +1 more): List clips of a folder with filters, pagination and selectable properties.

• list_mattes(clip, folder): List the mattes of a clip, or the timeline mattes of a folder.

• list_volumes(): List the volumes mounted in Media Storage.

• media_pool_tree(max_depth): Media Pool folder tree with ids, paths and clip counts.

Change media state; may overwrite current values. Every change is read back from Resolve (receipt.verified=false means it did not take). op.action (params; * = required):

• add_clip_marker(clip*, frame*, color, name, note, duration, custom_data): Add a marker to a Media Pool clip at a frame offset.

• add_clip_mattes(clip*, paths*, stereo_eye): Add matte files to a clip.

• add_flag(clip*, color*): Add a flag of the given color to a clip.

• add_timeline_mattes(paths*): Add matte files as timeline mattes in the current folder.

• auto_sync_audio(clips*, settings): Auto-sync audio of clips (needs at least one video and one audio clip).

• clear_flags(clip*, color): Clear one flag color, or all flags, of a clip.

• clear_mark_in_out(clip*, mark_type): Clear the mark in/out of a clip.

• clone_media(source_dir*, target_dirs*, preserve_folder_name, checksum_type): Clone media with checksum verification (21.1+, long-running job). [job]

• create_folder(name*, parent, set_current): Create a subfolder in the Media Pool.

• create_multicam_clip(clips*, options): Create multicam clip(s) from clips (21.1+); options use live constants.

• create_stereo_clip(left*, right*): Create a stereoscopic 3D clip from a left and a right clip.

• export_folder_drb(folder*, path*): Export a Media Pool folder as a DRB file.

• export_metadata(path*, clips): Export clip metadata to a CSV file.

• import_folder_drb(path*, source_clips_path): Import a DRB folder export into the Media Pool.

• import_media(items*, folder, via_media_storage): Import files/folders/sequences into the current or a chosen Media Pool folder.

• link_full_resolution_media(clip*, path*): Link full-resolution media to a proxy-only clip.

• link_proxy_media(clip*, path*): Link a proxy media file to a clip.

• monitor_growing_file(clip*): Monitor a clip's file while it keeps growing.

• move_clips(clips*, target*): Move clips to another Media Pool folder.

• move_folders(folders*, target*): Move folders into another Media Pool folder.

• refresh_folders(): Refresh Media Pool folders (collaboration mode).

• relink_clips(clips*, folder_path*): Relink clips to media found in a folder.

• replace_clip(clip*, path*, preserve_sub_clip): Replace the underlying media of a clip with another file.

• reveal_in_storage(path*): Reveal a path in Resolve's Media Storage panel.

• select_clip(clip*): Select a clip in the Media Pool.

• set_clip_color(clip*, color): Set a clip color (16 clip colors) or clear it when color is null.

• set_clip_metadata(clip*, metadata*, third_party): Set clip metadata (or third-party metadata) key/value pairs.

• set_clip_name(clip*, name*): Rename a clip (MediaPoolItem.SetName).

• set_clip_properties(clip*, properties*): Set clip properties (key -> value), reading each one back.

• set_current_folder(folder*): Make a folder the current Media Pool folder.

• set_mark_in_out(clip*, mark_in*, mark_out*, mark_type): Set the mark in/out of a clip.

• update_marker_custom_data(clip*, frame*, custom_data*): Update the custom data of a clip marker. Shortcuts (prefer them for whole tasks):

• workflow_write.conform_from_edl: Import media + EDL as a timeline, fix offline events via Start TC, report linkage. One call instead of import_media, relink_clips. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Remove project objects. op.action (params; * = required):

• delete_folder(name*): Delete a project folder of the current folder.

• delete_project(name*): Delete a (non-current) project from the current folder.

• delete_settings_preset(name*): Delete a project settings preset. First call returns a plan + confirm_token; repeat it with confirm_token to apply. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Read project state, no side effects: use it to find ids and check results. op.action (params; * = required):

• get_current_project(): Name, unique id, folder and database of the open project.

• get_settings(keys): Read project settings (all, or a list of keys).

• list_databases(): List the databases known to Resolve and the current one.

• list_projects(): List projects and folders of the current database folder.

• list_settings_presets(): List project settings presets (name, width, height).

Change project state; may overwrite current values. Every change is read back from Resolve (receipt.verified=false means it did not take). op.action (params; * = required):

• apply_settings_preset(name*): Apply a settings preset to the current project (saved project only).

• archive_project(name*, path*, with_stills_and_luts, archive_src_media, archive_render_cache, archive_proxy_media, force): Archive a project (broken by script on 21.x; needs force=true).

• close_project(save_first, discard_untitled): Close the current project (saved first by default).

• create_folder(name*): Create a project folder in the current database folder.

• create_project(name*, media_location_path, discard_untitled): Create a project and make it current (saves the current one first).

• export_project(name*, path*, with_stills_and_luts): Export a project of the current folder to a .drp file.

• export_settings_preset(name*, path*): Export a project settings preset to a file.

• goto_folder(to*): Go to the root or the parent project folder.

• import_project(path*, name): Import a .drp project file into the current folder.

• import_settings_preset(path*, name): Import a project settings preset file.

• load_project(name*, discard_untitled): Load a project from the current folder (saves the current one first).

• open_folder(name*): Enter a sub-folder of the current project folder.

• rename_project(new_name*): Rename the current project.

• restore_project(path*, name): Restore a project from an archive (.dra folder) into the current folder.

• save_project(): Save the current project (refused for 'Untitled Project').

• save_settings_preset(name*): Save the current project settings as a new preset.

• set_database(database*, discard_untitled): Switch the current database (DbType, DbName, optional IpAddress).

• set_settings(settings*): Set project settings one key at a time, verified by read-back.

• update_settings_preset(name*): Overwrite a settings preset with the current project settings. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Remove render objects. op.action (params; * = required):

• delete_all_render_jobs(): Delete every render job in the queue.

• delete_render_jobs(job_ids*): Delete specific render jobs from the queue.

• delete_render_preset(name*): Delete a render preset.

• update_render_preset(name*): Overwrite a render preset with the current render settings (21.1+). First call returns a plan + confirm_token; repeat it with confirm_token to apply. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Read render state, no side effects: use it to find ids and check results. op.action (params; * = required):

• get_render_config(): Current render format, codec, mode and whether a render is running.

• get_render_resolutions(format, codec): List the resolutions available for a render format and codec.

• list_render_formats(audio, format): Render formats; their codecs only with format (natural names work everywhere).

• list_render_jobs(): List queued render jobs with progress (derived from percentage and error).

• list_render_presets(): List render presets and Quick Export presets.

Change render state; may overwrite current values. Every change is read back from Resolve (receipt.verified=false means it did not take). op.action (params; * = required):

• add_render_job(): Queue a render job from the current render settings; returns its id.

• export_render_preset(name*, path*): Export a render preset to a file.

• import_render_preset(path*): Import a render preset from a file and select it.

• load_render_preset(name*): Load a render preset as the current render settings.

• quick_export(preset*, target_dir, name, video_quality, enable_upload): Render the current timeline with a Quick Export preset (21.1+, long-running). [job]

• render_timeline(preset*, target_dir*, name*, format, codec, settings): One-shot: load preset, set target and name, queue and start (long-running). [job]

• save_render_preset(name*): Save the current render settings as a new preset.

• set_quick_export_preset(name*, enabled): Enable or disable a render preset for Quick Export (21.1+).

• set_render_format(format*, codec*): Set the render format and codec (validated against the live list).

• set_render_mode(mode*): Set the render mode (single clip or individual clips).

• set_render_settings(settings*, base_preset): Apply render settings (on top of the loaded preset).

• start_rendering(job_ids, interactive): Start rendering queued jobs (long-running; poll with job_wait). [job]

• stop_rendering(): Stop any current render. Shortcuts (prefer them for whole tasks):

• workflow_write.build_vertical_reel: Build a vertical timeline from clips, add subtitles and optionally render it. One call instead of render_timeline.

• workflow_write.deliver: Render one or more outputs (preset/format/size) and report the real files produced. One call instead of set_render_settings, set_render_format, add_render_job, start_rendering, render_timeline. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Change snapshot state; may overwrite current values. Every change is read back from Resolve (receipt.verified=false means it did not take). op.action (params; * = required):

• snapshot_project(label): Save the project and export it as a .drp file in the snapshot directory.

• snapshot_timeline(label): Duplicate a timeline as a safety copy (current timeline by default). Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Remove timeline objects. op.action (params; * = required):

• delete_clips(items*, ripple): Delete timeline items (Edit page); linked audio is not removed automatically.

• delete_marker(frame*): Delete the timeline marker at a frame offset.

• delete_markers_by_color(color*): Delete all timeline markers of a color, or every marker with 'All'.

• delete_timelines(timelines*): Delete timelines from the project.

• delete_track(track*): Delete a track and the items on it. First call returns a plan + confirm_token; repeat it with confirm_token to apply. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Read timeline state, no side effects: use it to find ids and check results. op.action (params; * = required):

• current_timecode(): Return the playhead timecode.

• current_video_item(): Return the video item under the playhead, if any.

• get_mark_in_out(): Return the video/audio mark in and out (frames relative to timeline start).

• get_marker_by_custom_data(custom_data*): Find the first marker whose custom data matches.

• get_output_blanking(): Return the timeline output blanking in pixels (Resolve 21.1+).

• get_settings(keys): Read the timeline settings (project settings when custom settings are off).

• list_items(track, name_contains, limit, offset): List timeline items of a track or of the whole timeline (paginated).

• list_markers(color): List timeline markers, optionally filtered by color.

• list_timelines(): List the timelines of the current project with their ids.

• list_tracks(): List tracks of every type with name, enabled, locked and item count.

• selected_clips(): List the currently selected timeline items (Resolve 21.0.4+).

• timeline_info(): Name, id, frame range, start timecode, fps/resolution and track counts.

Change timeline state; may overwrite current values. Every change is read back from Resolve (receipt.verified=false means it did not take). op.action (params; * = required):

• add_marker(frame*, color, name, note, duration, custom_data): Add a marker at a frame offset of a timeline.

• add_markers(markers*): Add several markers in one call; frames already occupied are skipped.

• add_track(type*, sub_type): Add a video, audio or subtitle track (audio accepts a sub type).

• append_clips(clips*): Append Media Pool clips to a timeline (end frames exclusive, record offsets relative).

• auto_align_clips(items*, sync_using, use_track): Align timeline items by timecode or waveform (Resolve 21.1+).

• clear_mark_in_out(type): Clear mark in/out.

• convert_to_stereo(): Convert the timeline to stereoscopic 3D.

• create_compound_clip(items*, name, start_timecode): Create a compound clip from timeline items.

• create_fusion_clip(items*): Create a Fusion clip from timeline items.

• create_timeline(name*): Create an empty timeline in the current Media Pool folder.

• create_timeline_from_clips(name*, clips*): Create a timeline from Media Pool clips (optional source in/out per clip).

• duplicate_timeline(name*): Duplicate a timeline under a new name; the current timeline is left unchanged.

• export_timeline(path*, format*, subtype): Export a timeline (EDL, XML, AAF, DRT, OTIO, ...) to a file.

• import_into_timeline(path*, insert_additional_tracks, insert_with_offset, source_clips_path, link_to_source_camera_files, use_sizing_info): Import items from an AAF file into an existing timeline.

• import_timeline(path*, timeline_name, import_source_clips, source_clips_path, interlace_processing): Create a timeline from an EDL/XML/AAF/DRT/OTIO file.

• insert_generated(kind*, name): Insert a generator, title, OFX or Fusion generator/title/comp at the playhead.

• rename_timeline(name*): Rename a timeline (the new name must be unique).

• rename_track(track*, name*): Rename a track.

• set_clips_linked(items*, linked*): Link or unlink timeline items.

• set_current_timecode(timecode*): Move the playhead to a timecode (from the Edit page when Resolve is on Media).

• set_current_timeline(): Make a timeline the current one.

• set_mark_in_out(mark_in*, mark_out*, type): Set mark in/out (frames relative to timeline start).

• set_output_blanking(top, bottom, left, right): Set the timeline output blanking in pixels (Resolve 21.1+).

• set_settings(settings*): Set timeline settings (verified key by key; some keys are silently refused).

• set_start_timecode(timecode*): Set the timeline start timecode.

• set_track_enabled(track*, enabled*): Enable or disable a track.

• set_track_locked(track*, locked*): Lock or unlock a track (a locked V1 makes Insert* calls fail).

• update_marker_custom_data(frame*, custom_data*): Replace the custom data of the marker at a frame offset. Shortcuts (prefer them for whole tasks):

• workflow_write.build_vertical_reel: Build a vertical timeline from clips, add subtitles and optionally render it. One call instead of create_timeline, create_timeline_from_clips, set_settings.

• workflow_write.conform_from_edl: Import media + EDL as a timeline, fix offline events via Start TC, report linkage. One call instead of import_timeline, set_start_timecode. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Remove ui objects. op.action (params; * = required):

• ripple_delete_selection(keyboard_preset): Ripple delete the selected timeline clips via the UI (selection not API-readable). First call returns a plan + confirm_token; repeat it with confirm_token to apply. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Read ui state, no side effects: use it to find ids and check results. op.action (params; * = required):

• list_menu_items(path): List the items of a Resolve menu (top-level menu bar when path is empty).

Change ui state; may overwrite current values. Every change is read back from Resolve (receipt.verified=false means it did not take). op.action (params; * = required):

• blade_at_playhead(keyboard_preset): Split the clips under the playhead on the Edit page (default Cmd+B).

• invoke_menu(path*, validate_path): Click a Resolve menu item by its path (brings Resolve to front).

• open_gallery_panel(keyboard_preset): Open the Color page and show the Gallery (needed for GalleryStillAlbum.ExportStills).

• send_shortcut(command*, keyboard_preset): Run a named Resolve command via its default shortcut or menu (default preset only). Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Read vision state, no side effects: use it to find ids and check results. op.action (params; * = required):

• contact_sheet(count, timecodes, from_markers, columns, thumb_width, labels): Tile frames sampled across the timeline (or at timecodes / markers) into one JPEG.

• export_frame(timecode, max_width): Capture the timeline frame at a timecode as a JPEG (playhead is restored).

• probe_media(path, clip): ffprobe summary of a file or Media Pool clip: codecs, fps, audio, color metadata.

• screenshot_resolve(max_width): Screenshot of the DaVinci Resolve window (macOS, needs Screen Recording permission).

• source_frames(path*, seconds*, max_width): Extract frames straight from a media file with ffmpeg (Resolve not needed).

Change workflow state; may overwrite current values. Every change is read back from Resolve (receipt.verified=false means it did not take). op.action (params; * = required):

• apply_look: Apply a LUT to every video item, group them in a color group and grab a still.

• build_vertical_reel: Build a vertical timeline from clips, add subtitles and optionally render it.

• conform_from_edl: Import media + EDL as a timeline, fix offline events via Start TC, report linkage.

• deliver: Render one or more outputs (preset/format/size) and report the real files produced.

• title_overlay: Add an animated Text+ title (and Merge over the clip) to a timeline item's Fusion comp. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Parameter schemas (compact) of one or several actions, with their flags.

With only tool, lists that tool's actions and their signatures.

Connection state, Resolve version/edition/channel, current project, timeline and page.

Call it first, and again after an error: it tells whether Resolve is reachable and what the other tools act on by default.

Search the Resolve scripting API (official 21.1 stub) by name or description.

Use it to check what Resolve itself can do; to call something, use the domain tools (describe_action gives their parameters).

State and progress of a long-running job (render, transcription...), right now.

Returns at once; use job_wait instead to block until it finishes.

Block until a job finishes, then return its final state and result.

If timeout_s elapses first, returns it still running: call again to keep waiting.

Stop a running job and return its state ("cancelled").

A job whose operation cannot be interrupted returns WRONG_STATE and keeps running; a finished job is returned unchanged. Check it first with job_status if unsure.

Every job this server started, running and finished, with its state.

Use it to recover a job_id; job_status gives one job's details.

Safety copies (timeline duplicates, .drp exports) this server took before changes.

Use it to find the copy to go back to after a bad edit; snapshot_write takes a new one on demand.

Run several domain-tool calls in ONE call, in order, server-side.

Prefer it whenever the next calls are known: e.g. set metadata and color on four clips, add markers, rename tracks. Each step is {tool, op} exactly as you would call that tool, and is validated, verified and audited the same way. A step's op may read an earlier step's output with a template: "{{ steps..receipt.result.id }}" (writes), "{{ steps..result... }}" (reads), [n] and [*] supported. Stops at the first failed or unverified step; every outcome is reported. With *_delete steps the first call returns a plan + confirm_token for the whole batch.

List the recipes recipe_run can execute: name, description, parameters.

Built-in and user recipes, plus any that failed to load. Call it before recipe_run; for an ad-hoc sequence use batch_run instead.

Run a recipe server-side: every step is validated, verified and audited.

Stops at the first failed or unverified step and reports each step's outcome. Destructive recipes first return a plan with a confirm_token.