DaVinci Resolve APIIntermediateRender

How to Start a DaVinci Resolve Render with the Python API

Render Presets, SetRenderSettings, AddRenderJob, StartRendering, and completion monitoring

Drive the Render Queue from Python: load a preset, set the output directory and filename, add a render job, start the newly created job, and wait until Resolve finishes rendering.

API

Resolve Scripting API

Language

Python

Resolve

19–20+

Requires

Running Resolve

Syntax

job_id = project.AddRenderJob()
project.StartRendering(job_id)

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

import time

output_dir = r"D:\\Resolve\\renders"
render_name = "api_render_demo"
render_preset = "YouTube 1080p"

if not os.path.isdir(output_dir):
    os.makedirs(output_dir, exist_ok=True)

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

project = resolve.GetProjectManager().GetCurrentProject()
if not project:
    raise RuntimeError("No project is open")

if not project.GetCurrentTimeline():
    raise RuntimeError("No active Timeline")

presets = project.GetRenderPresetList() or []
if render_preset in presets:
    project.LoadRenderPreset(render_preset)
elif presets:
    project.LoadRenderPreset(presets[0])

project.SetRenderRange("Entire Timeline")

settings = {
    "TargetDir": output_dir,
    "CustomName": render_name,
    "RenderMode": "SingleClip",
    "ExportVideo": True,
    "ExportAudio": True,
}

project.SetRenderSettings(settings)
job_id = project.AddRenderJob()
if not job_id:
    raise RuntimeError("Could not create Render Job")

started = project.StartRendering([job_id]) or project.StartRendering(job_id)
if not started:
    started = project.StartRendering()

if not started:
    raise RuntimeError("Resolve refused to start rendering")

while project.IsRenderingInProgress():
    time.sleep(1)

print("Render finished:", job_id)

Guide

How the render workflow is structured

The script works with the current project and active Timeline. It loads a Render Preset, selects the Entire Timeline range, applies basic output settings, creates a Render Job, and starts rendering. It mirrors the normal Deliver-page workflow through the scripting API.

Why Render Presets are useful

Codec, container, bitrate, resolution, and other delivery details are easier to maintain as a Resolve preset. The Python script can then focus on variables that change per job: target directory, custom name, render range, and execution logic.

Why StartRendering is attempted in more than one form

Resolve versions and scripting builds have exposed slightly different StartRendering call patterns. The example first tries to launch the newly created job directly and only falls back to starting the queue more broadly if necessary.

Waiting for completion

IsRenderingInProgress() matters when the script has follow-up work: verify the output file, copy it, publish it, or hand it to another service. Without a wait loop, Python may exit before Resolve has finished the render.

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 start a davinci resolve render 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 named Render Preset must already exist in Resolve.
TargetDir must be writable by the Resolve process.
An active Timeline is required before creating the render job.
If StartRendering returns False, inspect the Deliver page, preset, output path, and Render Queue state.

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