DaVinci Resolve APIBeginnerProjects

How to Create a DaVinci Resolve Project with the Python API

CreateProject, current-project checks, and loading an existing project by name

Create a Resolve project through Project Manager without producing unnecessary duplicates, and fall back to loading an existing project when the requested name is already present.

API

Resolve Scripting API

Language

Python

Resolve

19–20+

Requires

Running Resolve

Syntax

project = project_manager.CreateProject(project_name)

Parameters

• The relevant arguments are shown in the complete working example below. Validate paths, object types, and required project state before calling the API method.

Returns

Always validate the returned object, list, identifier, or boolean before continuing to the next automation step.

Complete working Python exampleuse it as a starting point for your own script

import os
import sys
from pathlib import Path


def import_resolve_module():
    try:
        import DaVinciResolveScript as dvr
        return dvr
    except ImportError:
        search_paths = [
            os.environ.get("RESOLVE_SCRIPT_API", ""),
            os.environ.get("RESOLVE_MODULES", ""),
            r"C:\\ProgramData\\Blackmagic Design\\DaVinci Resolve\\Support\\Developer\\Scripting\\Modules",
            "/opt/resolve/Developer/Scripting/Modules",
            "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting/Modules",
            str(Path.home() / "Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting/Modules"),
        ]
        for path in search_paths:
            if path and os.path.isdir(path) and path not in sys.path:
                sys.path.append(path)
        import DaVinciResolveScript as dvr
        return dvr


dvr = import_resolve_module()

project_name = "API_Demo_Project"

resolve = dvr.scriptapp("Resolve")
if not resolve:
    raise RuntimeError("Resolve API is unavailable")

project_manager = resolve.GetProjectManager()
current_project = project_manager.GetCurrentProject()

if current_project and current_project.GetName() == project_name:
    project = current_project
    print("Project already current:", project.GetName())
else:
    project = project_manager.CreateProject(project_name)
    if project:
        print("Project created:", project.GetName())
    else:
        project = project_manager.LoadProject(project_name)
        if not project:
            raise RuntimeError(f"Could not create or load project: {project_name}")
        print("Project loaded:", project.GetName())

Guide

A safe project-creation order

The script first gets Project Manager and checks the currently open project. If that project already has the requested name, there is nothing to create. Otherwise it calls CreateProject(project_name). This makes repeated runs more predictable and avoids creating extra projects unnecessarily.

Why LoadProject is used

CreateProject can return None when a project with the same name already exists. In that case, trying LoadProject(project_name) makes the workflow idempotent: the same automation can be run again and continue with the existing project instead of failing immediately.

Where project creation fits

Project creation usually happens before Media Pool import, timeline creation, and render setup. The pattern is useful for training scripts, test projects, and simple production automation where the project name is known in advance.

What Project Manager actually manages

Project Manager works with Resolve Project Libraries, not arbitrary folders on disk. Choosing a specific Project Library or PostgreSQL database is an environment-level concern and sits outside this minimal example.

How the example works

Connect to Resolve

Establish a Resolve Scripting API connection and stop early if the application object is unavailable.

Validate the current context

Check the active project, Timeline, Media Pool, source paths, or Render Queue state required by this specific operation.

Run the core API operation

Execute the operation demonstrated in this guide: how to create a davinci resolve project with the python api.

Validate the result

Check the returned value before the workflow continues. Resolve methods often signal an unavailable object or failed operation with None, False, or an empty result.

Resolve API notes

The project name must be unique inside the active Project Library.
A None result from CreateProject does not always mean a fatal error; the project may already exist.
LoadProject loads a project by name from the active library.
After obtaining a project, the next common step is project.GetMediaPool().

Common errors

Resolve API is unavailable

Reason: Resolve is closed or Python cannot import/use DaVinciResolveScript.

Fix: Start Resolve and verify the Developer/Scripting/Modules path from the same Python interpreter used by the script.

The method returns None or False

Reason: A required project, Timeline, clip, preset, path, or application state is missing.

Fix: Validate each input and add explicit result checks after important Resolve API calls.

The script only works on one workstation

Reason: Paths or environment assumptions are hard-coded for a single operating system or machine.

Fix: Move paths into configuration and support the required Windows, Linux, and macOS locations explicitly.

Next step

Continue only after the current operation has returned the expected Resolve object or result.

Related API guides

Projects