DaVinci Resolve APIBeginnerGetting Started

How to Diagnose DaVinci Resolve Scripting API Access

Check the DaVinciResolveScript import, direct Resolve connection, and the Fusion fallback path

Use a read-only diagnostic script to identify where Resolve scripting access is failing: Python module lookup, the running application connection, scriptapp(), or the current Resolve environment.

API

Resolve Scripting API

Language

Python

Resolve

19–20+

Requires

Running Resolve

Syntax

fusion = dvr.scriptapp("Fusion")
resolve = fusion.GetResolve()

Parameters

• "Fusion" requests the Fusion application object, which can expose Resolve through GetResolve().

Returns

A Resolve object when either the direct connection or the Fusion fallback succeeds.

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

print("Python:", sys.executable)
print("Module:", getattr(dvr, "__file__", "unknown"))

resolve = dvr.scriptapp("Resolve")

if not resolve:
    fusion = dvr.scriptapp("Fusion")
    if fusion:
        resolve = fusion.GetResolve()

if not resolve:
    raise RuntimeError("Resolve API object is unavailable")

print("Product:", resolve.GetProductName())
print("Version:", resolve.GetVersionString())

Guide

What the diagnostic checks

The script prints the Python executable, the DaVinciResolveScript module location, and then attempts to obtain a Resolve object. This separates Python environment problems from application-connection problems. If the module imports but Resolve is still unavailable, your Python path is probably correct and the issue is further down the connection chain.

Why the Fusion fallback exists

Some setups can expose Resolve through a Fusion object: scriptapp("Fusion") followed by fusion.GetResolve(). It is useful as a fallback diagnostic path and can help confirm whether the application is reachable even when a direct Resolve object is not returned.

How to read the output

If the script prints the product name and version, the API connection is working. An import failure points to Developer/Scripting/Modules or environment configuration. A successful import with no Resolve object points to the running application, permissions, or scripting access.

When to run this file

Keep the diagnostic as a separate, non-destructive utility. It is useful when configuring a new workstation, changing Python environments, updating Resolve, or troubleshooting a machine before running production automation.

How the example works

Inspect the environment

Print sys.executable and the imported module path so you know exactly which Python interpreter and Resolve module are being used.

Try direct Resolve access

Use dvr.scriptapp("Resolve") first. This is the normal connection path for most external production scripts.

Try the Fusion fallback

If direct access fails, obtain a Fusion object and call GetResolve(). This is useful for narrowing down connection problems.

Confirm the object

Read GetProductName() and GetVersionString() to verify that the returned object is a live Resolve application object.

Resolve API notes

Run the diagnostic with the same Python interpreter that will run your production scripts.
Use the Fusion fallback only when direct scriptapp("Resolve") does not return an object.
GetProductName() and GetVersionString() are read-only checks.
A closed Resolve application normally means no usable Resolve object will be returned.

Common errors

The module imports, but Resolve is unavailable

Reason: The Python path is configured, but the application connection has not been established.

Fix: Start Resolve before running the diagnostic and verify the scripting environment and process permissions.

The Fusion fallback also fails

Reason: Resolve is closed or scripting access is unavailable in the current setup.

Fix: Restart Resolve and run the diagnostic from the exact Python environment you intend to use for automation.

One Python works and another does not

Reason: Different interpreters have different sys.path values and environment variables.

Fix: Standardize on one interpreter and configure the Resolve module path in that environment.

Next step

Once the diagnostic succeeds, move on to project creation, Media Pool import, or Timeline automation.

Related API guides

Getting Started