# DaVinci Resolve (pypi · davinci-mcp)

Typed, safe MCP server for DaVinci Resolve: every write verified, deletes confirmed, snapshots.

- Trust score: 70/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- pypi · `davinci-mcp`: 70/100 (this document), [markdown](https://verifymcp.io/servers/aedelon-davinci-mcp/davinci-mcp.md), [page](https://verifymcp.io/servers/aedelon-davinci-mcp/davinci-mcp)

## Channel facts

- Registry: `pypi`
- Package: `davinci-mcp`
- Version: `1.0.4`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs uv_build at install time, a recognised build step with no custom scripting around it.
  - 1 of 16 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (Apache-2.0).
  - Actively maintained (last published 3 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 71/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 13172 tokens (~248/item across 53 items; 52 tools + 1 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 99% of tool parameters carry a description.
  - Structured output schemas are declared (98% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 12 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 54 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the DaVinci Resolve MCP server?

DaVinci Resolve runs locally as a PyPI package, launched with uvx davinci-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add aedelon-davinci-mcp -- uvx davinci-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "aedelon-davinci-mcp": {
      "command": "uvx",
      "args": [
        "davinci-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "aedelon-davinci-mcp": {
      "command": "uvx",
      "args": [
        "davinci-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add aedelon-davinci-mcp -- uvx davinci-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "aedelon-davinci-mcp": {
      "type": "local",
      "command": [
        "uvx",
        "davinci-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add aedelon-davinci-mcp --command uvx --arg davinci-mcp
```

### Hermes

```yaml
mcp_servers:
  aedelon-davinci-mcp:
    command: "uvx"
    args: ["davinci-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "aedelon-davinci-mcp": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "davinci-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add aedelon-davinci-mcp -t stdio -c uvx -a davinci-mcp
```

### Other

```json
{
  "mcpServers": {
    "aedelon-davinci-mcp": {
      "command": "uvx",
      "args": [
        "davinci-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-01 (score 70)

First indexed and scored.

## MCP tools (52)

### `ai_delete` (~188 tokens)

Ai (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.

Input parameters:

- `confirm_token` (string|null): From the first call's plan; repeat that call with it to apply.
- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `ai_read` (~90 tokens)

Ai (read)

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.

Input parameters:

- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.

Output parameters:

- `action` (string)
- `channel` (string)
- `result` (object)

### `ai_write` (~454 tokens)

Ai (write)

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.

Input parameters:

- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `app_delete` (~197 tokens)

App (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.

Input parameters:

- `confirm_token` (string|null): From the first call's plan; repeat that call with it to apply.
- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `app_read` (~102 tokens)

App (read)

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.

Input parameters:

- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.

Output parameters:

- `action` (string)
- `channel` (string)
- `result` (object)

### `app_write` (~314 tokens)

App (write)

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.

Input parameters:

- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `audio_read` (~225 tokens)

Audio (read)

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.

Input parameters:

- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.

Output parameters:

- `action` (string)
- `channel` (string)
- `result` (object)

### `audio_write` (~310 tokens)

Audio (write)

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.

Input parameters:

- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `code_delete` (~186 tokens)

Code (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.

Input parameters:

- `confirm_token` (string|null): From the first call's plan; repeat that call with it to apply.
- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `color_delete` (~226 tokens)

Color (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.

Input parameters:

- `confirm_token` (string|null): From the first call's plan; repeat that call with it to apply.
- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `color_read` (~153 tokens)

Color (read)

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

Input parameters:

- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.

Output parameters:

- `action` (string)
- `channel` (string)
- `result` (object)

### `color_write` (~552 tokens)

Color (write)

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 se…

Input parameters:

- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `fusion_delete` (~239 tokens)

Fusion (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.

Input parameters:

- `confirm_token` (string|null): From the first call's plan; repeat that call with it to apply.
- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `fusion_read` (~200 tokens)

Fusion (read)

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

Input parameters:

- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.

Output parameters:

- `action` (string)
- `channel` (string)
- `result` (object)

### `fusion_write` (~665 tokens)

Fusion (write)

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, v…

Input parameters:

- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `gallery_delete` (~162 tokens)

Gallery (destructive)

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.

Input parameters:

- `confirm_token` (string|null): From the first call's plan; repeat that call with it to apply.
- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `gallery_read` (~99 tokens)

Gallery (read)

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.

Input parameters:

- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.

Output parameters:

- `action` (string)
- `channel` (string)
- `result` (object)

### `gallery_write` (~314 tokens)

Gallery (write)

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.

Input parameters:

- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `interchange_read` (~168 tokens)

Interchange (read)

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.

Input parameters:

- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.

Output parameters:

- `action` (string)
- `channel` (string)
- `result` (object)

### `interchange_write` (~337 tokens)

Interchange (write)

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.

Input parameters:

- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `item_delete` (~194 tokens)

Item (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.

Input parameters:

- `confirm_token` (string|null): From the first call's plan; repeat that call with it to apply.
- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `item_read` (~206 tokens)

Item (read)

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.

Input parameters:

- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.

Output parameters:

- `action` (string)
- `channel` (string)
- `result` (object)

### `item_write` (~571 tokens)

Item (write)

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*,…

Input parameters:

- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `media_delete` (~291 tokens)

Media (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.

Input parameters:

- `confirm_token` (string|null): From the first call's plan; repeat that call with it to apply.
- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `media_read` (~277 tokens)

Media (read)

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.

Input parameters:

- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.

Output parameters:

- `action` (string)
- `channel` (string)
- `result` (object)

### `media_write` (~875 tokens)

Media (write)

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.
\- re…

Input parameters:

- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `project_delete` (~192 tokens)

Project (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.

Input parameters:

- `confirm_token` (string|null): From the first call's plan; repeat that call with it to apply.
- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `project_read` (~143 tokens)

Project (read)

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

Input parameters:

- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.

Output parameters:

- `action` (string)
- `channel` (string)
- `result` (object)

### `project_write` (~531 tokens)

Project (write)

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…

Input parameters:

- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `render_delete` (~212 tokens)

Render (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.

Input parameters:

- `confirm_token` (string|null): From the first call's plan; repeat that call with it to apply.
- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `render_read` (~156 tokens)

Render (read)

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.

Input parameters:

- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.

Output parameters:

- `action` (string)
- `channel` (string)
- `result` (object)

### `render_write` (~506 tokens)

Render (write)

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.

Input parameters:

- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `snapshot_write` (~169 tokens)

Snapshot (write)

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.

Input parameters:

- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `timeline_delete` (~236 tokens)

Timeline (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.

Input parameters:

- `confirm_token` (string|null): From the first call's plan; repeat that call with it to apply.
- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `timeline_read` (~290 tokens)

Timeline (read)

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.

Input parameters:

- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.

Output parameters:

- `action` (string)
- `channel` (string)
- `result` (object)

### `timeline_write` (~859 tokens)

Timeline (write)

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_li…

Input parameters:

- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `ui_delete` (~169 tokens)

Ui (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.

Input parameters:

- `confirm_token` (string|null): From the first call's plan; repeat that call with it to apply.
- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `ui_read` (~84 tokens)

Ui (read)

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

Input parameters:

- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.

Output parameters:

- `action` (string)
- `channel` (string)
- `result` (object)

### `ui_write` (~230 tokens)

Ui (write)

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.

Input parameters:

- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.
- `snapshot` (boolean|null): true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `vision_read` (~200 tokens)

Vision (read)

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

Input parameters:

- `op` (object, required): {action, ...params}. Parameters per action: see the description or this server's describe_action tool.

Output parameters:

- `action` (string)
- `channel` (string)
- `result` (object)

### `workflow_write` (~223 tokens)

Workflow (write)

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.

Input parameters:

- `dry_run` (boolean): true: return the planned effect, change nothing.
- `op` (required): The action and its parameters.
- `snapshot`: true: back up the timeline/project first; omitted: server policy.

Output parameters:

- `job` (object|null)
- `plan` (object|null)
- `receipt` (object|null)
- `status` (string)

### `describe_action` (~119 tokens)

Describe Action

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

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

Input parameters:

- `action`: op.action, e.g. 'append_clips'.
- `actions`: Several at once, as 'tool.action' (e.g. ['color_write.set_cdl', 'gallery_write.grab_still']): one call instead of one per action.
- `tool`: Tool name, e.g. 'timeline_write'.
- `with_result` (boolean): Also return result schemas.

### `resolve_status` (~51 tokens)

Resolve Status

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.

Output parameters:

- `capabilities`
- `connected` (boolean)
- `error`
- `page`
- `project`
- `timeline`

### `search_api` (~75 tokens)

Search Api

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

Input parameters:

- `limit` (integer)
- `pattern` (string, required): Substring of a class, method or description.

Output parameters:

- `hits` (array)

### `job_status` (~60 tokens)

Job Status

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

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

Input parameters:

- `job_id` (string, required): Id from a write that returned status='started' (or job_list).

Output parameters:

- `error`
- `finished_at`
- `id` (string)
- `kind` (string)
- `label` (string)
- `progress`
- `result`
- `started_at` (string)
- `state` (string)

### `job_wait` (~73 tokens)

Job Wait

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.

Input parameters:

- `job_id` (string, required): Id from a write that returned status='started' (or job_list).
- `timeout_s` (number): Seconds to wait.

Output parameters:

- `error`
- `finished_at`
- `id` (string)
- `kind` (string)
- `label` (string)
- `progress`
- `result`
- `started_at` (string)
- `state` (string)

### `job_cancel` (~72 tokens)

Job Cancel

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.

Input parameters:

- `job_id` (string, required): Id from a write that returned status='started' (or job_list).

Output parameters:

- `error`
- `finished_at`
- `id` (string)
- `kind` (string)
- `label` (string)
- `progress`
- `result`
- `started_at` (string)
- `state` (string)

### `job_list` (~38 tokens)

Job List

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.

Output parameters:

- `jobs` (array)

### `snapshot_list` (~59 tokens)

Snapshot List

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.

Input parameters:

- `project`: Only this project's snapshots.

Output parameters:

- `snapshots` (array)

### `batch_run` (~211 tokens)

Batch Run

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.<id>.receipt.result.id }}"
(writes), "{{ steps.<id>.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.

Input parameters:

- `confirm_token`: When it contains *_delete steps: token from the plan.
- `dry_run` (boolean): Plan only.
- `steps` (array, required): Steps, in order.
- `verbose` (boolean): Full receipts for every step.

Output parameters:

- `duration_ms` (integer)
- `outputs` (object)
- `plan`
- `recipe` (string)
- `status` (string)
- `steps` (array)

### `recipe_list` (~52 tokens)

Recipe List

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.

Output parameters:

- `load_errors` (array)
- `recipes` (array)

### `recipe_run` (~107 tokens)

Recipe Run

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.

Input parameters:

- `confirm_token`: For destructive recipes: token from the planned call.
- `dry_run` (boolean): Plan only.
- `name` (string, required): Recipe name from recipe_list.
- `params`: Recipe parameters.
- `verbose` (boolean): Full receipts for every step.

Output parameters:

- `duration_ms` (integer)
- `outputs` (object)
- `plan`
- `recipe` (string)
- `status` (string)
- `steps` (array)

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/aedelon-davinci-mcp/davinci-mcp#diagnostics

## Score history

- 2026-11-05: 70
- 2026-11-04: 70
- 2026-11-03: 70
- 2026-11-02: 70
- 2026-11-01: 70

## Common questions

### What is the DaVinci Resolve MCP server?

DaVinci Resolve is an MCP server listed in the public MCP registry as io.github.Aedelon/davinci-mcp. Typed, safe MCP server for DaVinci Resolve: every write verified, deletes confirmed, snapshots. This page covers its PyPI package (davinci-mcp).

### Is the DaVinci Resolve MCP server safe to use?

DaVinci Resolve scores 70 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the DaVinci Resolve MCP server expose?

DaVinci Resolve exposes 52 tools: ai_delete, ai_read, ai_write, app_delete, app_read, and 47 more. Their descriptions and schemas cost roughly 12,712 tokens of context every time the server is loaded.

### Is the DaVinci Resolve MCP server still maintained?

DaVinci Resolve is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the DaVinci Resolve MCP server under?

DaVinci Resolve declares the Apache-2.0 licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- PyPI project: https://pypi.org/project/davinci-mcp/
- Socket report: https://socket.dev/pypi/package/davinci-mcp
- Repository: https://github.com/Aedelon/davinci-mcp
- Changelog RSS feed: https://verifymcp.io/servers/aedelon-davinci-mcp/davinci-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/aedelon-davinci-mcp/davinci-mcp.json
- HTML version of this page: https://verifymcp.io/servers/aedelon-davinci-mcp/davinci-mcp