unofficial-davinci-mcp
The unofficial-davinci-mcp server lets AI agents automate professional video editing in DaVinci Resolve — either driving the Studio version live via its scripting API, or generating interchange files (FCPXML/EDL) for the free version.
System & Discovery
resolve_capabilities— Check active tier (live Studio vs. free interchange), Resolve version, and dependency status. Call this first.resolve_project_summary— Read current project name, timelines, FPS, and marker count (live only).get_editing_knowledge— Access editorial best practices with concrete numbers for color, beat-cutting, dialogue, music, and mixing.
Media Inspection
probe_media— Extract duration, FPS, resolution, codecs, audio channels/rate, and timecode.scan_media_folder— Recursively scan and probe every media file in a directory.
Audio & Music
beat_grid— Estimate BPM, beat times, downbeat, and onset strengths.cut_music— Trim a song to a target length on a musical boundary with a tail fade or button sting.measure_loudness— Report EBU R128 integrated LUFS, loudness range, and true peak.mix_plan— Normalize dialogue, set music bed level, apply ducking windows, and render a premix WAV.tighten_dialogue— Detect dead air and return a keep-range cut plan with optional preview render.
Color Grading
color_match— Match clips to a reference image (Reinhard or Lab-histogram) and bake a 33-point.cubeLUT with before/after preview strips.resolve_apply_lut— Apply a.cubeLUT to timeline clips (live only).resolve_set_grade— Set ASC CDL slope/offset/power/saturation on timeline clips (live only).
Timeline Assembly & Export
assemble_edit— Validate an edit plan against probed media and snap cuts to a beat grid.generate_fcpxml— Output an FCPXML 1.9 timeline importable into Resolve.generate_edl— Output a CM3600 EDL cut list.generate_marker_csv— Output a marker manifest CSV.
Live Resolve Studio Controls
resolve_import_media— Import media into the project media pool.resolve_create_timeline— Create a timeline from a clip plan, music, and markers.resolve_append_to_timeline— Append clips with source/record ranges to the active timeline.resolve_add_markers— Add markers to the active timeline.resolve_render/resolve_render_status— Start and monitor render jobs.
Safety: Every mutating tool defaults to dry_run=true, returning a preview plan before any changes are applied. Set dry_run=false and confirm=true to execute.
Provides tools for controlling DaVinci Resolve (Studio and free) programmatically, including timeline editing, color grading, audio mixing, and media management.
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., "@unofficial-davinci-mcp Color match these clips to the reference image."
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.
Wasserman's Unofficial DaVinci MCP
Let any AI agent run DaVinci Resolve for you — Claude Code, Codex, Cursor, Hermes, or any MCP client. Cut clips to the beat, match a reference look, tighten dialogue, hit a loudness spec, and build timelines — either by driving Resolve Studio live, or by generating clean import files for the free edition.

A flat log-ish grade (BEFORE) matched to a warm reference frame (REFERENCE) → the MATCHED result, baked to a 33-point .cube LUT. Real output from the color_match engine on a single desert-dance frame.
You describe the edit in plain language; your agent calls the tools. The server does the deterministic, numeric work an LLM shouldn't guess at — beat grids, LUT math, EBU R128 loudness, FCPXML — and hands back files and plans you can trust. No cloud rendering, no black boxes: every engine is stdlib + numpy + ffmpeg, and every mutating tool previews before it touches anything.
Two tiers, auto-detected
The server detects at startup whether it can drive a running DaVinci Resolve Studio (verified on Studio 21) or should fall back to interchange files. resolve_capabilities tells you which tier you're in and why.
Capability | Resolve Studio — live | Free Resolve / not running — interchange |
How it works | Drives the running app via the scripting API | Writes files you import in one action |
Build & edit timelines | Directly in the app | FCPXML 1.9 / EDL → |
Markers | Inserted live | Marker CSV, or embedded in the FCPXML |
Color grades & LUTs | Applied per clip via the API | Bake a |
Renders | Queue and start jobs | Use Resolve's own export |
Probe, beat grid, music cut, dialogue tighten, loudness, mix | ✅ engines run either way | ✅ engines run either way |
External scripting | ✅ Studio only | ❌ not available in free Resolve |
Being honest about it: external scripting is a DaVinci Resolve Studio feature. On the free edition the live tools can't reach the app — but every creative engine still runs, and the interchange writers give you a timeline, LUTs, markers, and a premix you import in a single step. Nothing about the free path is a stub.
Related MCP server: io.github.Airta-Admin/davinc-resolve-local-bridge-mcp
Quick start
Install straight from GitHub:
pip install "git+https://github.com/wassermanproductions/unofficial-davinci-mcp.git"Optional extras — beat-tracking (librosa) and the push-to-talk voice bridge:
pip install "unofficial-davinci-mcp[beats] @ git+https://github.com/wassermanproductions/unofficial-davinci-mcp.git"
pip install "unofficial-davinci-mcp[voice] @ git+https://github.com/wassermanproductions/unofficial-davinci-mcp.git"Or clone and install editable:
git clone https://github.com/wassermanproductions/unofficial-davinci-mcp.git
cd unofficial-davinci-mcp
pip install -e .You also need ffmpeg on your PATH (brew install ffmpeg, or your distro's package). That's the only non-Python dependency.
Wire it into your agent
Claude Code — one line:
claude mcp add davinci -- unofficial-davinci-mcpAny MCP client (generic mcpServers JSON):
{
"mcpServers": {
"davinci": {
"command": "unofficial-davinci-mcp"
}
}
}Hermes — ~/.hermes/config.yaml:
mcpServers:
davinci:
command: unofficial-davinci-mcpIf the console script isn't on your PATH, use python -m davinci_mcp as the command instead. Then ask your agent to call resolve_capabilities first — it reports your tier, Resolve version, ffmpeg, and optional dependencies.
What it can do
Reference color matching
Point color_match at a reference still (or a graded frame) and the shots you want to match. It samples both in CIE Lab, computes a per-shot transform (Reinhard mean/std, or a firmer Lab-histogram match), and bakes a Resolve-loadable 33-point .cube LUT — plus a before/after preview strip and the numeric ΔE convergence. The hero strip above is a real run: a flat grade pulled to a warm reference, ΔE 43.9 → 3.2. On Studio it can apply the LUT for you; on free Resolve you get the file to drop on a node.
A worked example, end to end
"Cut these clips to the music, give it a warm look, and set dialogue at −16 LUFS."

One request, seven tool calls: read the tier, probe the media, find the tempo, assemble a beat-snapped edit, write an FCPXML, bake a warm LUT, and plan the mix — every number above is real output from the running server.
Beat-aware music cutting
beat_grid finds the tempo, beats, downbeat, and onset strengths (librosa when installed, an energy-envelope fallback when not). cut_music uses that grid to trim a track to a target length on a musical boundary, then rings the tail out under an exponential fade — or lands on a hit with a "button" ending. No cuts mid-phrase.

Dialogue, loudness, and the mix
tighten_dialoguedetects dead air in a talking clip and returns a keep-range cut plan (with head/tail handles) — apply it live, or export the tightened edit as FCPXML.measure_loudnessreports EBU R128 integrated LUFS, loudness range, and true-peak per file.mix_plannormalizes dialogue to your delivery spec, sets the music bed under it, derives ducking windows from speech, and renders a re-measured premix so you can trust the number.
Build the timeline
assemble_edit validates an edit plan against your probed media and snaps cuts to a beat grid. Then generate_fcpxml writes an FCPXML 1.9 timeline that imports cleanly into Resolve 19/20, generate_edl writes a CM3600 cut list, and generate_marker_csv writes a marker manifest. On Studio, resolve_create_timeline / resolve_append_to_timeline build it in the app directly.
The 37 tools
Every mutating tool defaults to dry_run=true and returns a plan; re-run with dry_run=false and confirm=true to apply it. Tier both = works in free or Studio; live = requires DaVinci Resolve Studio.
Tool | Tier | What it does |
| both | Report the active tier, Resolve version, ffmpeg, and optional deps. Call first. |
| both | Serve editorial knowledge (color, beat, dialogue, music, mixing) with concrete numbers. |
| both | ffprobe files: duration, fps, resolution, codecs, audio channels/rate, timecode. |
| both | Scan a folder and probe every media file, in stable sorted order. |
| both | Estimate tempo (BPM), beat times, a downbeat guess, and onset strengths. |
| both | Cut a song to length on a musical boundary with a smooth sting-out. |
| both | Match clips/stills to a reference; bake a 33-point |
| both | Measure EBU R128 integrated LUFS, loudness range, and true-peak per file. |
| both | Plan dialogue-normalize + music bed + ducking; render a re-measured premix. |
| both | Detect dead air in a talking clip; return a keep-range cut plan. |
| both | Validate an edit plan against probed media; snap cuts to a beat grid. |
| both | Write an FCPXML 1.9 timeline that imports cleanly into Resolve. |
| both | Write a CM3600 EDL cut list for round-tripping. |
| both | Write a marker manifest CSV (frame, timecode, name, color, note). |
| live | Read the current project, timelines, active-timeline fps and markers. |
| live | Check render progress and the render queue. |
| live | Import media into the project media pool. |
| live | Create a timeline seeded from a clip plan, music, and markers. |
| live | Append clips (with source/record ranges) to the active timeline. |
| live | Add markers to the active timeline. |
| live | Apply a |
| live | Set ASC CDL slope/offset/power/saturation on clips. |
| live | Configure and start a render job for the current timeline. |
It knows editing, not just buttons
Operating the app is half the job; knowing what a good edit is is the other half. get_editing_knowledge serves the same editorial playbook the tools were built around — written like a seasoned editor briefing an assistant, with numbers your agent can act on:
Loudness by destination. Dialogue sits at −16 LUFS for web / −23 LUFS for broadcast; the music bed rides 4–8 dB under it; ducking is −6 to −8 dB with a 0.3 s attack / 0.5 s release; the master limiter caps at −1 dBTP.
mix_plantakes these as parameters.Cut to the energy, not the metronome. At 120 BPM a beat is 12 frames — so cut a moving shot 1–2 frames early and the motion lands on the beat perceptually; hold 8–16 shots per 8 bars in the chorus and only 1–3 in the intro.
assemble_edit's beat-snap tolerance tightens to ±2 frames for the drop.Match, don't invent. For teal-and-orange, reference a warm-skin/cool-shadow frame with
method="lab_histogram"at strength 0.5–0.65, and always re-check skin last. Never bake exposure or white balance into a look LUT.
Topics: color-looks, beat-cutting, dialogue-editing, music-editing, mixing.
One-command workflows
Four headline tools chain the engines above into a single call. Each one plans first (dry_run=true) and returns a plan you can inspect before it writes anything.
Auto-edit to music
Scan a footage folder, beat-grid the song, cut it to length, and lay a beat-synced edit whose cut density tracks the song's energy — long holds in the intro, 1–2 beat cuts in the chorus — with a no-adjacent-same-source variety rule. Every cut carries a rationale, and the plan exports as FCPXML or feeds resolve_create_timeline live.
auto_edit(music="track.wav", media_dir="./footage", target_seconds=30, style="music_video")Search footage by what's said
Transcribe every clip once (cached), then search the spoken words by phrase, all-words, or regex. Hits come back with timestamps and context; build_selects=true cuts them into a selects timeline with 0.5 s handles.
find_in_footage(query="let's go", media="./interviews", mode="phrase", build_selects=true)Captions and chapters
Turn a transcript into broadcast-sane SRT/VTT captions (line-length, duration, and orphan-word rules, speech-snapped timing, optional karaoke), and derive YouTube chapters from the speech's own topic shifts.
generate_captions(media="talk.mp4", format="srt") # youtube_chapters(media="talk.mp4")Grade a timeline to a reference
Match every clip to a reference frame with one auto-tuned LUT each: the loop reads the quality report and lowers strength (down to a 0.5 floor) until the grade passes its gates, flagging any clip it can't as needs_human. Returns per-clip LUTs plus a live/interchange apply manifest.
grade_timeline(reference_image="look.png", clips=[{"path": "a.mov", "in": 0, "out": 4}])Talk to your editor
An optional macOS push-to-talk voice bridge lets you hold a key, speak, and drop the transcript straight into your agent terminal — hands on the footage, not the keyboard.

It runs entirely on your Mac: faster-whisper transcribes locally, nothing is sent to the cloud, and editing jargon (LUFS, J-cut, sting, FCPXML) is biased into the model so it transcribes cleanly. Setup, permissions, and configuration are in voice/README.md.
pip install "unofficial-davinci-mcp[voice] @ git+https://github.com/wassermanproductions/unofficial-davinci-mcp.git"
python -m voiceRequirements & troubleshooting
Python ≥ 3.10, numpy, and ffmpeg on your PATH (checked in
/opt/homebrew/bin,/usr/local/bin,/usr/binas fallbacks). Install ffmpeg withbrew install ffmpegon macOS or your distro's package manager on Linux.librosais an optional extra ([beats]) for tempo-tracked beat grids; without it,beat_griduses an energy-envelope fallback that still works.Studio vs free. Live tools need DaVinci Resolve Studio, running, with external scripting enabled (Preferences ▸ System ▸ General ▸ External scripting using: Local). If you're on the free edition or Resolve isn't running, the server drops to interchange automatically —
resolve_capabilitiesexplains why."Studio required" / handshake failed. The scripting module loaded but couldn't reach the app: confirm Resolve is open, you're on Studio, and scripting is enabled. Everything in the interchange tier still works regardless.
The voice bridge needs Microphone + Accessibility permissions — see voice/README.md for the walkthrough.
Disclaimer
Unofficial. This project is not affiliated with, authorized by, or endorsed by Blackmagic Design. "DaVinci Resolve" is a trademark of Blackmagic Design Pty Ltd. This is an independent, community tool that talks to Resolve through its public scripting API and standard interchange formats.
Support
A few people asked if they could send tips to support my work developing open source tools. So I set up an optional way in case anyone wants to.
No pressure at all. Using the apps, sharing them, starring the repositories, and contributing code all help too. Thank you.
License & credits
Apache License 2.0 — see LICENSE. Free to use, modify, fork, and build on, commercially or otherwise.
Attribution required: per the NOTICE file (Apache 2.0 §4(d)), any use, fork, or redistribution must retain the NOTICE file and credit Sam Wasserman (wassermanproductions.com) in its documentation and about/credits surface.
Created by Sam Wasserman — wassermanproductions.com · wasserman.ai.
Available Tools
23 toolsassemble_editA
Validate an edit plan against probed media and optionally snap cut points to a beat grid; returns a normalised plan for interchange/live.
Inputs: plan (required).
beat_gridA
Estimate tempo (BPM), beat times, a downbeat guess, and onset strengths. Uses librosa when available, else an approximate energy-envelope fallback.
Inputs: audio (required).
color_matchB
Match target clips/stills to a reference image; bake 33-point .cube LUTs (Reinhard or Lab-histogram) with before/after preview strips.
Inputs: targets (required), reference_image (required), method, confirm, +4 more.
cut_musicC
Cut a song to a target length ending on a musical boundary with a smooth sting-out (tail ring-out or button hit).
Inputs: song (required), target_seconds (required), sting, confirm, +4 more.
generate_edlA
Generate a CM3600 EDL for the video clips in the plan. Simpler than FCPXML (cuts only, no audio/effects); use for round-tripping a cut list. dry_run returns the plan; dry_run=false writes the file.
Inputs: name (required), clips (required), dry_run, frame_rate, +2 more.
generate_fcpxmlA
Generate an FCPXML 1.9 timeline (video + audio clips, in/out ranges, markers) that imports cleanly into DaVinci Resolve via File > Import > Timeline. The primary way to deliver an edit in interchange (free Resolve) mode. dry_run returns the plan; dry_run=false writes the file.
Inputs: name (required), clips (required), width, height, +5 more.
generate_marker_csvA
Write a deterministic marker manifest CSV (frame, timecode, seconds, name, color, note, duration). Use in interchange mode where live marker insertion is unavailable. dry_run returns the plan; dry_run=false writes the file.
Inputs: markers (required), name, dry_run, frame_rate, +1 more.
get_editing_knowledgeA
Read editorial knowledge for editing well (not just operating the app): color looks, beat-cutting, dialogue editing, music editing, and mixing — with concrete numbers and mappings to this server's tool parameters. Omit topic to list what's available.
Inputs: topic.
measure_loudnessC
Measure EBU R128 integrated LUFS, loudness range, and true peak per file.
Inputs: paths (required).
mix_planC
Plan a dialogue/music/sfx mix: dialogue normalisation gain, music bed level, and ducking windows; render a re-measured premix WAV on confirm.
Inputs: dialogue (required), sfx, ramp, music, +8 more.
probe_mediaA
Probe media files with ffprobe: duration, fps, resolution, codecs, audio channels/rate, timecode, and video/audio/image/other kind.
Inputs: paths (required).
resolve_add_markersA
Add one or more markers to the active timeline. dry_run first, then confirm. Live tier only; for free Resolve use generate_marker_csv.
Inputs: markers (required), confirm, dry_run.
resolve_append_to_timelineA
Append clips (with ranges) to the active timeline, importing them first if needed. dry_run first, then confirm. Live tier only.
Inputs: clips (required), confirm, dry_run.
resolve_apply_lutA
Apply a .cube LUT to clips on a timeline video track. dry_run first, then confirm. Live tier only. To produce the LUT file itself, use the color_match engine (both tiers).
Inputs: lut_path (required), confirm, dry_run, node_index, +2 more.
resolve_capabilitiesA
Call FIRST. Reports the active tier (live vs interchange), why, the DaVinci Resolve version if reachable, ffmpeg availability, and optional dependency status. Live tools need tier=live; interchange tools work in either tier. Every mutating tool defaults to dry_run=true - run it once to preview the plan, then again with dry_run=false and confirm=true.
Inputs: no named parameters.
resolve_create_timelineA
Create a timeline, optionally seeded from a clip plan (with source/record ranges), music, and markers. dry_run first, then confirm. Live tier only; for free Resolve use generate_fcpxml instead.
Inputs: name (required), clips, confirm, dry_run, +3 more.
resolve_import_mediaA
Import media into the project media pool. Workflow: dry_run first, then confirm. Run before resolve_create_timeline / resolve_append_to_timeline when the media is not already in the pool. Live tier only.
Inputs: paths (required), confirm, dry_run, bin_name.
resolve_project_summaryA
Read the current project name, its timelines, and the active timeline's frame rate and marker count. Use to orient before editing. Live tier only.
Inputs: no named parameters.
resolve_renderA
Configure a render job for the current timeline and optionally start it. dry_run first, then confirm. Poll with resolve_render_status. Live tier only.
Inputs: target_dir (required), custom_name (required), confirm, dry_run, +5 more.
resolve_render_statusA
Check render progress and the render queue. Live tier only.
Inputs: job_id.
resolve_set_gradeA
Set ASC CDL slope/offset/power/saturation on timeline clips. dry_run first, then confirm. Live tier only.
Inputs: power, slope, offset, confirm, +5 more.
scan_media_folderA
Scan a folder for media and probe each file. Stable sorted order.
Inputs: folder_path (required), probe, max_files, recursive, +1 more.
tighten_dialogueB
Detect and tighten dead air in a talking clip; returns a keep-range cut plan (for the NLE) plus an optional rendered preview.
Inputs: media (required), head, tail, confirm, +6 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 23 tools
Each tool targets a specific function (e.g., color matching, beat detection, EDL generation) with minimal overlap. The clear separation between live and interchange tiers further resolves any ambiguity.
Most tools follow a verb_noun pattern (e.g., assemble_edit, beat_grid) or a resolve_verb_noun pattern for live operations. The dual pattern is still predictable and readable, with minor inconsistency in prefix usage.
With 23 tools, the server covers a broad range of DaVinci Resolve workflows without being excessive. Each tool has a clear purpose, though some might be combined (e.g., generate_edl and generate_fcpxml).
The toolset is comprehensive for the intended interchange/live workflow but lacks basic editing operations like trimming, transitions, or effects, which are notable gaps for a full video editing assistant.
Maintenance
Related MCP Connectors
AI video editor for agents and humans: timeline, captions, color, audio and generation as MCP tools.
The agentic video editor for ChatGPT and Claude. Ask in your chat and it cuts, captions, adds music, titles and motion graphics on a real timeline you can open and adjust.
Open-source AI video editor: cut, caption, clip and animate real Revline projects from your agent.
AI video editor your agent can drive: plan scenes, edit a multi-track timeline, and render MP4s.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to control DaVinci Resolve (Free and Studio) through natural language, providing 162 tools for timeline editing, color grading, rendering, and more. Includes local AI replacements for Studio-only features like voice isolation, background removal, and transcription.1MIT
- AlicenseAqualityBmaintenanceEnables AI assistants to control DaVinci Resolve (Free and Studio) through 215 MCP tools covering the full Resolve scripting API, including projects, timelines, media, Fusion, color, and rendering.139 PyPI1MIT
- AlicenseBqualityCmaintenanceEnables AI-driven video editing and color grading in DaVinci Resolve, including beat-synced cuts, algorithmic 3D LUT generation, media transcoding, and hands-free playback control through natural language.212MIT
- 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.10,157 npmMIT