davinci-mcp
davinci-mcp is an MCP server that lets AI agents read, edit, grade, render, and automate DaVinci Resolve Studio through typed, verified actions with safety controls.
Inspect and discover: check connection/version/project/timeline/page (
resolve_status), search Resolve's scripting API, and get compact action schemas.Projects: list/load/save/create/import/export/archive projects; manage folders, databases, settings, and presets.
Media: browse storage and Media Pool; import/move/relink/replace clips; manage bins, metadata, markers, flags, proxies, mattes, multicam, stereo clips, audio sync, and cloning.
Timelines: create/duplicate/import/export timelines; manage tracks, markers, playhead, mark in/out, settings, compound/Fusion clips, and linking.
Timeline items: inspect and edit item properties, speed, fades, takes, flags/colors, markers, transitions, stabilization, blanking, and multicam.
Color: inspect/edit node graphs, CDL, LUTs, versions, color groups, DRX grades, node cache, and DCTL validation/encryption.
Fusion: manage comps/tools, connections, inputs, keyframes, expressions, Text+ titles, tool settings, and fuses.
Gallery: list/manage still and PowerGrade albums, grab/import/export stills, and label stills.
Audio: analyze loudness/silence, normalize audio, set voice isolation, apply Fairlight presets, and manage audio mapping/properties.
Render: inspect formats/codecs/resolutions/presets/jobs; queue/start/stop renders; render timelines or ranges; Quick Export.
Interchange: read/write EDL, FCPXML, OTIO, marker CSV, and .cube LUT files.
AI tools: transcribe audio, create subtitles, detect scene cuts, Smart Reframe, classify audio, IntelliSearch, generate speech, and run Slate ID analysis.
UI/app/vision: switch pages, invoke menus/shortcuts, manage app presets and keyframe mode; export frames, contact sheets, screenshots, and probe media.
One-call workflows:
conform_from_edl,deliver,build_vertical_reel,apply_look, andtitle_overlay.Automation and safety: run
batch_runsequences, execute YAML/Python recipes, manage long-running jobs/snapshots, usedry_run, confirm deletes with tokens, enforce allowed roots, and get verified receipts/audit logs.
Provides AI agents with access to the DaVinci Resolve scripting API, enabling editing, media management, timeline operations, color grading, Fusion, audio, rendering, delivery, and other post-production workflows, with changes verified against Resolve.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@davinci-mcp grade the timeline teal and orange, then render an H.264"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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: trueorfalse. An agent can't claim a change that didn't happen.dry_runpreviews 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_runchains 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"| AValidate. The agent calls a domain tool such as
timeline_writewith{"op": {"action": ..., ...}}, and the parameters are checked against a typed schema. Almost-right parameters are repaired, and each repair is reported.Consent and snapshot. Deletes stop at a plan until they are confirmed, and destructive edits take a snapshot first.
Call Resolve. The call runs on a single executor thread, the only place Resolve is ever called from.
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_luaandrun_pythoninside 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-mcppipx install davinci-mcp and pip install davinci-mcp work too.
davinci-mcp doctordoctor checks that Resolve is reachable and reports its version, edition and channel.
davinci-mcp install --target claude-codeOr add it by hand:
claude mcp add davinci-mcp -- davinci-mcp servedavinci-mcp install --target claude-desktopThis 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 inThe 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 |
|
| Audit log, jobs, confirm tokens, temporary frames. |
|
| Start Resolve when it is not running. |
|
| Launch Resolve with |
|
| Maximum seconds for one Resolve API call. |
|
| Maximum seconds to wait for Resolve to start. |
| auto-detected | Paths to Resolve's scripting modules, only if detection fails. |
|
| Folders tools may read or write; anything else is refused. |
|
| When snapshots are taken unasked: |
|
| Where project exports ( |
|
| Snapshots kept per project; older ones are pruned. |
|
| Lifetime of a |
|
| Allow arbitrary Python/Lua ( |
|
| Address for |
|
| Name of the environment variable holding the bearer token. |
|
|
|
|
| Folders of user recipes (see recipes). |
|
| Load |
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 pyrightCredits
Demo footage: Tears of Steel, © Blender Foundation | mango.blender.org, CC-BY 3.0.
Demo music: Five Armies by Kevin MacLeod (incompetech.com), CC-BY 4.0.
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 toolsai_deleteAi (destructive)ADestructive
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)CRead-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)ADestructive
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)ADestructive
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)ARead-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)ADestructive
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)ARead-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)ADestructive
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 RunADestructive
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)ADestructive
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)ADestructive
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)ARead-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)ADestructive
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 ActionARead-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)ADestructive
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)ARead-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)ADestructive
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
gallery_deleteGallery (destructive)ADestructive
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.
Inputs: op (required), dry_run, snapshot, confirm_token. Returns: job, plan, status, receipt
gallery_readGallery (read)ARead-onlyIdempotent
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.
Inputs: op (required). Returns: action, result, channel
gallery_writeGallery (write)ADestructive
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.
Inputs: op (required), dry_run, snapshot. Returns: job, plan, status, receipt
interchange_readInterchange (read)ARead-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)ADestructive
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)ADestructive
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)ARead-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)ADestructive
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 CancelADestructive
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 ListARead-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 StatusARead-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 WaitARead-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)ADestructive
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)ARead-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)ADestructive
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)ADestructive
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)ARead-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)ADestructive
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 ListARead-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 RunADestructive
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)ADestructive
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)ARead-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)ADestructive
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 StatusARead-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 ApiARead-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 ListARead-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)ADestructive
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)ADestructive
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)ARead-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)ADestructive
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)ADestructive
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)ARead-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)ADestructive
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)ARead-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)ADestructive
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
Scored across 52 tools
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.
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.
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.
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
Related MCP Connectors
AI video editor for agents and humans: timeline, captions, color, audio and generation as MCP tools.
AI video editor your agent can drive: plan scenes, edit a multi-track timeline, and render MP4s.
Video review and collaboration for teams and agents: a full review interface for agentic video and motion graphics, feedback by voice, screen and drawing on the frame, agents that iterate version by version, and every version's notes and source files saved for the team.
QC, conform and AI video, image and sound generation for film. Priced before every run.
Related MCP Servers
- AlicenseNot gradedqualityAmaintenanceA server that enables LLM applications to interact directly with DaVinci Resolve video editing software, allowing AI-assisted capabilities like accessing timeline information and automating editing workflows.9,499 npm4,221MIT
- AlicenseAqualityBmaintenanceA professional implementation of a Model Context Protocol server that enables integration between DaVinci Resolve video editing software and AI assistants like Claude Desktop or Cursor.626GPL 3.0
- AlicenseBqualityDmaintenanceEnables AI-driven DaVinci Resolve 21 automation with 88 tools for project management, timeline editing, color grading, AI analysis, rendering, and dailies creation.884MIT
- AlicenseNot gradedqualityBmaintenanceEnables AI assistants to control DaVinci Resolve Studio through the official Scripting API, covering editing, media pool management, rendering, grading, Fusion, Fairlight, and project lifecycle tasks.MIT