Overview

This MCP (Model Context Protocol) server provides a programmable bridge between DaVinci Resolve and external tooling to accelerate editing, color grading, media management, and project coordination. By exposing Resolve operations over a simple HTTP API, teams and automation scripts can orchestrate common tasks—import media, adjust timelines, apply grades, and trigger renders—from CI pipelines, AI models, or remote control panels.

The server is designed for developers who want to integrate Resolve into larger systems: ingest tools, collaborative platforms, or model-driven workflows. Running a local or networked MCP server centralizes project control, reduces repetitive manual work, and makes it easier to apply deterministic edits and grading operations at scale.

Features

HTTP API for interacting with DaVinci Resolve projects and assets
Remote project control: open, lock, and save projects programmatically
Media management: import, relink, and organize clips and bins
Timeline operations: create sequences, trim clips, move cuts, and adjust markers
Color operations: apply LUTs, copy node trees, adjust key color parameters
Render queue control: add jobs, start/stop renders, and query status
Batch processing for repetitive tasks across multiple timelines or projects
Lightweight configuration with environment variables and a config file
Example client snippets and quick-start scripts for common tasks

Installation / Configuration

Prerequisites: a running installation of DaVinci Resolve (desktop) accessible from the same machine as the MCP server, and the Resolve scripting API enabled.

Clone the repository and install dependencies:

# clone the MCP repo
git clone https://github.com/samuelgursky/davinci-resolve-mcp.git
cd davinci-resolve-mcp

# install dependencies (example using Python)
pip install -r requirements.txt

Create or edit a configuration file (config.json or .env). Minimal config example:

{
  "host": "0.0.0.0",
  "port": 8080,
  "resolve_socket": "/path/to/resolve/ipc.sock",
  "project_path": "/projects",
  "auth_token": "CHANGE_ME"
}

Start the server:

# start the MCP server (example)
python -m mcp_server.main --config config.json

Environment variables can be used instead of a config file:

export MCP_HOST=0.0.0.0
export MCP_PORT=8080
export MCP_AUTH_TOKEN=CHANGE_ME
python -m mcp_server.main

Quick health check (replace host/port/token as configured):

curl -H "Authorization: Bearer CHANGE_ME" http://localhost:8080/health
# expected: {"status":"ok","version":"<server-version>"}

Note: the exact commands and filenames may vary depending on the packaged release. Check the repository for the latest startup instructions and configuration keys.

Available Resources

The MCP server groups functionality into resource endpoints that map to common Resolve concepts. Typical resources you’ll find:

Resource	Common Actions
/projects	list, open, create, save, lock/unlock
/media	import, relink, locate, list clips and bins
/timeline	create, cut/trim, move clips, insert gaps, add markers
/color	apply LUT, copy node graphs, set grade parameters
/render	add to render queue, start/stop, query job status
/logs	server logs, recent actions, diagnostics

Example endpoints (conceptual):

GET /projects — list available projects
POST /projects/{id}/open — open a particular project
POST /timeline/{id}/trim — trim a clip on a timeline
POST /color/{clip}/apply-lut — apply a LUT to a clip
POST /render/queue — enqueue a render job

Check the repository’s API documentation or the OpenAPI/Swagger file (if included) for exact request/response shapes and query parameters.

Use Cases

Batch LUT application: A post facility needs to apply a set of approved LUTs to all camera A-roll across multiple timelines. Use the MCP server to iterate over clips and apply the selected LUT, then enqueue renders automatically for QC.
Remote editorial automation: A newsroom runs ingest and rough-cut workflows automatically. After ingest, a script calls the MCP API to create timelines, place clips according to metadata, add markers, and save a new project for an editor to refine.
AI-assisted grading: Integrate a color recommendation model that suggests primary adjustments. The model sends suggested parameters to the MCP server, which applies them to a selected timeline, allowing a colorist to review and tweak interactively.
Centralized asset relinking: When media paths change (e.g., new storage mount), a centralized tool can call the MCP server to relink offline clips across many projects in a reproducible way.
Collaborative sessions: Teams using DAW-style remote control can lock projects, apply synchronized changes, and push updated project files to a shared storage location through the MCP endpoints.

Getting Help and Next Steps

Clone the GitHub repo: https://github.com/samuelgursky/davinci-resolve-mcp
Read the project README and API docs for endpoint details and sample clients
Use the server’s health/log endpoints for diagnostics
For scripting specifics, consult DaVinci Resolve’s official scripting API documentation to understand how the server translates HTTP calls to Resolve actions

This MCP server is intended as a starting point for automating Resolve workflows; examine the code and examples to adapt it to your studio’s pipeline and security requirements.

DaVinci Resolve MCP Server for Editing and Grading