Skip to main content
Glama

davinci-mcp is an MCP server for DaVinci Resolve. It gives AI agents such as Claude access to the whole Resolve scripting API: 299 typed actions across 17 domains. Every change is verified against Resolve itself before it is reported as done.

It is built for editors and colorists who want an assistant that does the clicking, and for developers who want a dependable bridge between an agent and Resolve.

See it work

A real Claude agent, given four plain messages, cut this 52-second action trailer from the open movie Tears of Steel. It imported the footage, laid out 33 shots on the beat, added the title cards, graded teal and orange, and rendered it. Nothing in the run was staged; the video below is sped up 4×.

Related MCP server: DaVinci MCP Professional

Why davinci-mcp

Verified, not hopeful

  • Every write is read back from Resolve, and its receipt says verified: true or false. An agent can't claim a change that didn't happen.

  • dry_run previews any write without applying it.

  • Deletes need consent: the first call returns a plan and a confirm_token, and nothing is removed until the same call comes back with the token.

  • Destructive edits take a safety snapshot of the timeline first.

  • Every call is written to a JSONL audit log.

Reliable

  • In the benchmark below, 20 of 20 jobs passed. The community MCP server passed 13 of 20, davinci-mcp-professional 10 of 20.

  • Near-miss parameters are repaired instead of refused (fade_out → FadeOut, a bare clip name → a selector), and every rewrite is reported.

  • Errors are actionable: they suggest the right field ("did you mean"), name the right tool, and say which render setting Resolve rejected.

Economical

  • batch_run chains a whole sequence server-side in one call, for example 18 steps from timeline to render.

  • Clients defer the tools, so the first turn costs about 32k tokens of context.

  • Replies and schemas are compact. Against the community server: 31 % cheaper and 60 % fewer calls.

Exhaustive and extensible

  • 17 domains: project, media, timeline, item, color, Fusion, gallery, audio, render, interchange, AI tools, UI, app and more.

  • One-call workflows: conform_from_edl, deliver, build_vertical_reel, apply_look, title_overlay.

  • Your own recipes: YAML templates, plus Python when you opt in.

Safe by default

  • File access is limited to the folders you allow.

  • The server's own state, its configuration and your Claude configuration files are always off-limits.

  • Symlinks are never followed when importing a folder.

Benchmarks

Headless Claude agents (Sonnet) ran four post-production jobs on a live Resolve Studio 21.1, five runs each. An agent that never saw the server's code wrote the jobs:

  • dailies: log and organise a day of footage;

  • promo: build a promo with a music bed;

  • look: grade with versions and a still;

  • spot QC: duplicate, export interchange files and render a range.

Each check reads Resolve directly, never through the server under test. Every agent ran under the same isolated harness. Full method and history →

Server

Jobs passed

Tool calls

Cost (4 jobs)

davinci-mcp

20 / 20

35

$0.62

Community MCP (samuelgursky/davinci-resolve-mcp)

13 / 20

90

$0.99

MCP Professional (hoyt-harness/davinci-mcp-professional)

10 / 20

156

$1.04

Resolve's built-in MCP

20 / 20

17

$0.35

About the built-in server. Resolve 21.1 ships its own MCP server, which is cheaper because it hands the agent one tool, run_script_unsafe, to run arbitrary Python inside Resolve. That makes for short runs, but nothing is validated, read back, audited, snapshotted or confirmed before a delete. In our scale test (160 clips, 4 timelines) it once put a marker at the wrong frame, then reported the job done. davinci-mcp trades a little cost for changes you can trust.

Talk to it like an editor

Import the clips in ~/Footage/day03, sort interviews and B-roll into bins, and colour the circled takes green.
Build a 9:16 reel from these three shots, add subtitles from the audio, and render it for Instagram.
Conform this EDL against the media in ~/Rushes and deliver a ProRes master and an H.264 proxy.
Apply the show LUT to every shot of the timeline except the end card, and grab a still of the first shot.
Add a red marker at the start of every shot named "broll_" in Edit_03.
Duplicate the approved cut as "QC", export it as FCPXML and OTIO, and render 01:00:02:00 to 01:00:07:24.

How it works

flowchart LR
    A["AI agent<br/>Claude, Cursor…"] -->|MCP call| V["Validate<br/>+ repair"]
    V --> C["Consent<br/>deletes only"]
    C --> N["Snapshot<br/>destructive only"]
    N --> X["Call Resolve<br/>one thread"]
    X <-->|scripting API| D[("DaVinci<br/>Resolve")]
    X --> R["Read back<br/>→ receipt"]
    R --> L["Audit log"]
    R -->|"verified: true / false"| A
  1. Validate. The agent calls a domain tool such as timeline_write with {"op": {"action": ..., ...}}, and the parameters are checked against a typed schema. Almost-right parameters are repaired, and each repair is reported.

  2. Consent and snapshot. Deletes stop at a plan until they are confirmed, and destructive edits take a snapshot first.

  3. Call Resolve. The call runs on a single executor thread, the only place Resolve is ever called from.

  4. Read back. The server reads the result back from Resolve and returns a receipt with verified. Long renders become jobs that the agent can wait on.

Tools

52 tools. Domain tools are named <domain>_read, <domain>_write and <domain>_delete, and take {"op": {"action": ..., ...}}; together they expose about 300 actions. Reads have no side effects, writes return a verified receipt, deletes ask for confirmation first.

  • resolve_status - Connection state, Resolve version and edition, current project, timeline and page.

  • describe_action - Compact parameter schemas of one or several actions.

  • search_api - Search the Resolve 21.1 scripting API by name or description.

  • batch_run - Run several tool calls in one call, server-side, with one confirmation for the batch.

  • workflow_write - One-call jobs: conform_from_edl, deliver, build_vertical_reel, apply_look, title_overlay.

  • recipe_list / recipe_run - List and run YAML or Python recipes; every step is validated, verified and audited.

  • project_read / project_write / project_delete - Projects, folders, databases, settings and settings presets; create, load, save, archive, import, export.

  • media_read / media_write / media_delete - Media pool and storage: import, bins, relink, proxies, metadata, markers, flags, multicam, mattes, audio sync.

  • timeline_read / timeline_write / timeline_delete - Timelines, tracks, markers, playhead, compound and Fusion clips, import and export.

  • item_read / item_write / item_delete - Timeline items: properties, speed, fades, takes, flags, colors, markers, transitions, stabilization.

  • color_read / color_write / color_delete - Node graphs, CDL, LUTs, versions, color groups, DRX grades, DCTL.

  • fusion_read / fusion_write / fusion_delete - Fusion comps and tools: add, connect, inputs, keyframes, expressions, Text+ titles, settings, fuses.

  • gallery_read / gallery_write / gallery_delete - Still albums: grab, import, export, label.

  • audio_read / audio_write - Loudness analysis, silence detection, normalization, voice isolation, Fairlight presets, audio mapping.

  • render_read / render_write / render_delete - Formats, codecs, presets and render jobs; render a timeline or a range, Quick Export.

  • interchange_read / interchange_write - EDL, FCPXML, OTIO, marker CSV and .cube LUT files, read and written without Resolve.

  • ai_read / ai_write / ai_delete - Transcription, subtitles from audio, scene-cut detection, Smart Reframe, audio classification, IntelliSearch.

  • vision_read - Export or screenshot frames and contact sheets so the agent can look at the picture.

  • ui_read / ui_write / ui_delete - Pages, menus and keyboard shortcuts, for the few things the API can't do.

  • app_read / app_write / app_delete - Resolve app info, layout presets, keyframe mode, quit.

  • snapshot_list / snapshot_write - Safety copies of the timeline or project, taken automatically before destructive edits.

  • job_status / job_wait / job_list / job_cancel - Long operations (renders, analyses) run as jobs.

  • code_delete - run_lua and run_python inside Resolve, an escape hatch that is off by default and always asks for confirmation.

Install

  • DaVinci Resolve Studio 21.1 or later. In Preferences → General → External scripting using, choose Local.

  • The free edition 21.1+ is not supported. Resolve 21.1 took Python scripting out of the free edition, and its Lua sandbox can't reach the Resolve API (tested on 21.1.2). On the free 21.0.x, the in-app bridge should still work: run davinci-mcp install --bridge, then start it from Workspace → Scripts.

  • Python 3.13+ and uv (or pipx / pip).

uv tool install davinci-mcp

pipx install davinci-mcp and pip install davinci-mcp work too.

davinci-mcp doctor

doctor checks that Resolve is reachable and reports its version, edition and channel.

davinci-mcp install --target claude-code

Or add it by hand:

claude mcp add davinci-mcp -- davinci-mcp serve
davinci-mcp install --target claude-desktop

This adds the server to claude_desktop_config.json. Restart Claude Desktop to load it. To do it by hand:

{
  "mcpServers": {
    "davinci-mcp": { "command": "davinci-mcp", "args": ["serve"] }
  }
}

If Claude Desktop can't find the command, use its absolute path (which davinci-mcp).

Without installing anything, any client can run it through uvx: { "command": "uvx", "args": ["davinci-mcp", "serve"] }. Don't run uvx davinci-mcp install: it would write a path from uv's temporary cache into the client config.

In ~/.cursor/mcp.json:

{
  "mcpServers": {
    "davinci-mcp": { "command": "davinci-mcp", "args": ["serve"] }
  }
}

In .vscode/mcp.json:

{
  "servers": {
    "davinci-mcp": { "type": "stdio", "command": "davinci-mcp", "args": ["serve"] }
  }
}

Run davinci-mcp serve over stdio. Use davinci-mcp serve --transport http for Streamable HTTP; it binds to loopback and needs a bearer token for any other host. The server also exposes a davinci://status resource.

Configure

The optional file ~/.config/davinci-mcp/config.toml holds the settings. Any key can be overridden with a DAVINCI_MCP_<SECTION>__<KEY> environment variable.

[safety]
allowed_roots = ["~/Movies", "~/Projects"]  # files outside these are refused (default: your home)
auto_snapshot = "destructive"               # "off" | "destructive" | "all"

[recipes]
allow_python = false                        # Python recipes run arbitrary code: opt in

The file does not exist until you create it; without it the defaults below apply. Unknown keys, or keys in the wrong section, stop the server with a validation error. In an environment variable a list is written [~/Movies,~/Footage].

Key

Default

Meaning

state_dir (top level)

~/.local/state/davinci-mcp

Audit log, jobs, confirm tokens, temporary frames.

connection.auto_launch

true

Start Resolve when it is not running.

connection.headless

false

Launch Resolve with -nogui.

connection.call_timeout_s

30

Maximum seconds for one Resolve API call.

connection.launch_timeout_s

90

Maximum seconds to wait for Resolve to start.

connection.script_api, connection.script_lib

auto-detected

Paths to Resolve's scripting modules, only if detection fails.

safety.allowed_roots

["~"]

Folders tools may read or write; anything else is refused.

safety.auto_snapshot

"destructive"

When snapshots are taken unasked: "destructive", "all" or "off". A call can force it with snapshot.

safety.snapshot_dir

<state_dir>/snapshots

Where project exports (.drp) are written.

safety.snapshot_retention

20

Snapshots kept per project; older ones are pruned. 0 keeps none.

safety.consent_ttl_s

300

Lifetime of a confirm_token, in seconds.

safety.enable_code_execution

false

Allow arbitrary Python/Lua (code_delete) and Fusion scripts. This code runs with your user rights, outside allowed_roots.

http.host, http.port

127.0.0.1, 8765

Address for serve --transport http. Any non-loopback host requires a token.

http.token_env

DAVINCI_MCP_TOKEN

Name of the environment variable holding the bearer token.

server.schema_mode

"compact"

"full" lists every action's complete schema in tools/list (much larger).

recipes.dirs

["~/.config/davinci-mcp/recipes"]

Folders of user recipes (see recipes).

recipes.allow_python

false

Load *.py recipes, which run arbitrary code.

FAQ

Check three things:

  • Resolve is running;

  • in Studio, External scripting using is set to Local;

  • no dialog is open in Resolve, such as an update prompt or a project manager.

Then run davinci-mcp doctor.

Not from 21.1 on. Resolve 21.1 removed both external scripting and in-app Python scripts from the free edition. In-app Lua scripts still run, but in a sandbox with no file access, no network and no access to the Resolve API (tested on free 21.1.2), so no bridge can work there. On the free 21.0.x, the in-app Python bridge (davinci-mcp install --bridge) should still work. Otherwise you need Resolve Studio.

Not without consent. Every delete returns a plan first and needs a matching confirm_token. Destructive edits snapshot the timeline, and every call is logged.

Only inside allowed_roots. The server's own state, its configuration and your Claude configuration files are always refused, whatever you allow.

It runs one unchecked Python script per job. davinci-mcp makes typed, verified calls, so it uses a few more steps. batch_run and the one-call workflows keep that overhead small.

Contributing

Issues and pull requests are welcome. docs/domain-guide.md shows how to add an action: a parameter model, a handler, a read-back check and a test. The rest is generated from there.

uv sync
uv run pytest
uv run ruff check . && uv run pyright

Credits

davinci-mcp is an independent project. It is not affiliated with, endorsed by or sponsored by Blackmagic Design. DaVinci Resolve is a trademark of Blackmagic Design Pty. Ltd.

Support

davinci-mcp is free and open source. If it saves you time in the edit, you can buy me a coffee:

Made by Delanoe Pirard (Aedelon) · Apache 2.0

Available Tools

52 tools
ai_deleteAi (destructive)A
Destructive

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.

Inputs: op (required), dry_run, snapshot, confirm_token. Returns: job, plan, status, receipt

ai_readAi (read)C
Read-onlyIdempotent

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.

Inputs: op (required). Returns: action, result, channel

ai_writeAi (write)A
Destructive

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.

Inputs: op (required), dry_run, snapshot. Returns: job, plan, status, receipt

app_deleteApp (destructive)A
Destructive

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.

Inputs: op (required), dry_run, snapshot, confirm_token. Returns: job, plan, status, receipt

app_readApp (read)A
Read-onlyIdempotent

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.

Inputs: op (required). Returns: action, result, channel

app_writeApp (write)A
Destructive

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.

Inputs: op (required), dry_run, snapshot. Returns: job, plan, status, receipt

audio_readAudio (read)A
Read-onlyIdempotent

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.

Inputs: op (required). Returns: action, result, channel

audio_writeAudio (write)A
Destructive

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.

Inputs: op (required), dry_run, snapshot. Returns: job, plan, status, receipt

batch_runBatch RunA
Destructive

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.

Inputs: steps (required), dry_run, verbose, confirm_token. Returns: plan, steps, recipe, status, +2 more

code_deleteCode (destructive)A
Destructive

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.

Inputs: op (required), dry_run, snapshot, confirm_token. Returns: job, plan, status, receipt

color_deleteColor (destructive)A
Destructive

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.

Inputs: op (required), dry_run, snapshot, confirm_token. Returns: job, plan, status, receipt

color_readColor (read)A
Read-onlyIdempotent

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).

Inputs: op (required). Returns: action, result, channel

color_writeColor (write)A
Destructive

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.

Inputs: op (required), dry_run, snapshot. Returns: job, plan, status, receipt

describe_actionDescribe ActionA
Read-onlyIdempotent

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

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

Inputs: tool, action, actions, with_result.

fusion_deleteFusion (destructive)A
Destructive

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.

Inputs: op (required), dry_run, snapshot, confirm_token. Returns: job, plan, status, receipt

fusion_readFusion (read)A
Read-onlyIdempotent

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).

Inputs: op (required). Returns: action, result, channel

fusion_writeFusion (write)A
Destructive

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.

Inputs: op (required), dry_run, snapshot. Returns: job, plan, status, receipt

interchange_readInterchange (read)A
Read-onlyIdempotent

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.

Inputs: op (required). Returns: action, result, channel

interchange_writeInterchange (write)A
Destructive

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.

Inputs: op (required), dry_run, snapshot. Returns: job, plan, status, receipt

item_deleteItem (destructive)A
Destructive

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.

Inputs: op (required), dry_run, snapshot, confirm_token. Returns: job, plan, status, receipt

item_readItem (read)A
Read-onlyIdempotent

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.

Inputs: op (required). Returns: action, result, channel

item_writeItem (write)A
Destructive

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.

Inputs: op (required), dry_run, snapshot. Returns: job, plan, status, receipt

job_cancelJob CancelA
Destructive

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.

Inputs: job_id (required). Returns: id, kind, error, label, +5 more

job_listJob ListA
Read-onlyIdempotent

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.

Inputs: no named parameters. Returns: jobs

job_statusJob StatusA
Read-onlyIdempotent

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

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

Inputs: job_id (required). Returns: id, kind, error, label, +5 more

job_waitJob WaitA
Read-onlyIdempotent

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.

Inputs: job_id (required), timeout_s. Returns: id, kind, error, label, +5 more

media_deleteMedia (destructive)A
Destructive

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.

Inputs: op (required), dry_run, snapshot, confirm_token. Returns: job, plan, status, receipt

media_readMedia (read)A
Read-onlyIdempotent

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.

Inputs: op (required). Returns: action, result, channel

media_writeMedia (write)A
Destructive

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.

Inputs: op (required), dry_run, snapshot. Returns: job, plan, status, receipt

project_deleteProject (destructive)A
Destructive

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.

Inputs: op (required), dry_run, snapshot, confirm_token. Returns: job, plan, status, receipt

project_readProject (read)A
Read-onlyIdempotent

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).

Inputs: op (required). Returns: action, result, channel

project_writeProject (write)A
Destructive

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.

Inputs: op (required), dry_run, snapshot. Returns: job, plan, status, receipt

recipe_listRecipe ListA
Read-onlyIdempotent

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.

Inputs: no named parameters. Returns: recipes, load_errors

recipe_runRecipe RunA
Destructive

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.

Inputs: name (required), params, dry_run, verbose, +1 more. Returns: plan, steps, recipe, status, +2 more

render_deleteRender (destructive)A
Destructive

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.

Inputs: op (required), dry_run, snapshot, confirm_token. Returns: job, plan, status, receipt

render_readRender (read)A
Read-onlyIdempotent

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.

Inputs: op (required). Returns: action, result, channel

render_writeRender (write)A
Destructive

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.

Inputs: op (required), dry_run, snapshot. Returns: job, plan, status, receipt

resolve_statusResolve StatusA
Read-onlyIdempotent

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.

Inputs: no named parameters. Returns: page, error, project, timeline, +2 more

search_apiSearch ApiA
Read-onlyIdempotent

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).

Inputs: pattern (required), limit. Returns: hits

snapshot_listSnapshot ListA
Read-onlyIdempotent

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.

Inputs: project. Returns: snapshots

snapshot_writeSnapshot (write)A
Destructive

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.

Inputs: op (required), dry_run, snapshot. Returns: job, plan, status, receipt

timeline_deleteTimeline (destructive)A
Destructive

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.

Inputs: op (required), dry_run, snapshot, confirm_token. Returns: job, plan, status, receipt

timeline_readTimeline (read)A
Read-onlyIdempotent

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.

Inputs: op (required). Returns: action, result, channel

timeline_writeTimeline (write)A
Destructive

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.

Inputs: op (required), dry_run, snapshot. Returns: job, plan, status, receipt

ui_deleteUi (destructive)A
Destructive

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.

Inputs: op (required), dry_run, snapshot, confirm_token. Returns: job, plan, status, receipt

ui_readUi (read)A
Read-onlyIdempotent

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).

Inputs: op (required). Returns: action, result, channel

ui_writeUi (write)A
Destructive

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.

Inputs: op (required), dry_run, snapshot. Returns: job, plan, status, receipt

vision_readVision (read)A
Read-onlyIdempotent

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).

Inputs: op (required). Returns: action, result, channel

workflow_writeWorkflow (write)A
Destructive

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.

Inputs: op (required), dry_run, snapshot. Returns: job, plan, status, receipt

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 52 tools

    Disambiguation4/5

    Most tools are clearly separated by domain and by read/write/delete intent, with descriptions clarifying item vs clip vs timeline scopes. There is some overlap between workflow shortcuts, batch_run, and recipe_run, and a few operations (markers, flags, audio mapping) appear across multiple scopes, but the boundaries are generally navigable.

    Naming Consistency4/5

    The dominant pattern is consistent noun_action with read/write/delete triplets per domain, all in snake_case. A few utility tools use different conventions (describe_action, batch_run, resolve_status, search_api) and code_delete contains execution actions, which is a notable naming oddity but not enough to break readability.

    Tool Count2/5

    At 52 top-level tools, the surface is very large and exceeds the comfortable range for agent tool selection, even for a comprehensive DaVinci Resolve server. The domain grouping makes each tool meaningful, but navigation and discovery overhead are still high.

    Completeness5/5

    The server covers an unusually complete DaVinci Resolve surface: media, timeline, item, project, render, color, fusion, audio, gallery, interchange, UI, AI, jobs, snapshots, workflows, and API discovery. There are no obvious dead ends for core lifecycle operations.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers