← All DaVinci Resolve API guides
DaVinci Resolve APIIntermediateRender

How to Load a Render Preset with the DaVinci Resolve Python API

Select a suitable preset, call LoadRenderPreset, and validate the result before AddRenderJob

List available presets, choose an H.265/HEVC-oriented or otherwise suitable option, load it safely, and then apply project-specific Render Settings before creating a job.

API

Resolve Scripting API

Language

Python

Resolve

19–20+

Requires

Running Resolve

Syntax

ok = project.LoadRenderPreset(preset_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
import time
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",
            "/opt/BlackmagicDesign/DaVinciResolve/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


def safe_call(obj, name, *args, **kwargs):
    try:
        fn = getattr(obj, name, None)
        if callable(fn):
            return fn(*args, **kwargs)
    except Exception:
        return None
    return None


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

    project_manager = safe_call(resolve, "GetProjectManager")
    project = safe_call(project_manager, "GetCurrentProject") if project_manager else None
    if not project:
        raise RuntimeError("No DaVinci Resolve project is open")

    timeline = safe_call(project, "GetCurrentTimeline")
    if not timeline:
        raise RuntimeError("No active Timeline")

    return resolve, project, timeline



def list_presets(project):
    return safe_call(project, "GetRenderPresetList") or []


def load_hevc_friendly_preset(project):
    presets = list_presets(project)
    if not presets:
        return None

    prefer = ["H.265", "HEVC", "H265", "Web", "YouTube", "MP4", "Custom Export"]
    avoid = ("prores", "dnxhr", "intermediate")

    for wanted in prefer:
        for preset in presets:
            low = preset.lower()
            if wanted.lower() in low and not any(bad in low for bad in avoid):
                if safe_call(project, "LoadRenderPreset", preset):
                    return preset

    for preset in presets:
        if not any(bad in preset.lower() for bad in avoid):
            if safe_call(project, "LoadRenderPreset", preset):
                return preset

    for preset in presets:
        if safe_call(project, "LoadRenderPreset", preset):
            return preset

    return None


resolve, project, timeline = get_project_and_timeline()
selected_preset = load_hevc_friendly_preset(project)
print("Loaded preset:", selected_preset or "preset not loaded")

Guide

What the example does

The script reads the available Render Presets and tries to choose one suitable for a final H.265/HEVC export. If an obvious HEVC-oriented preset is unavailable, the selection logic can fall back to a more general preset instead of assuming one exact user-defined name exists.

Why one hard-coded preset name is fragile

Preset lists depend on Resolve version, user configuration, and workstation. One machine may expose YouTube 2160p, another a Custom Export preset, and another only team-specific presets. Matching by a small set of characteristics makes automation more portable.

What to do after loading the preset

LoadRenderPreset() establishes a base configuration but does not start an export. Apply TargetDir, CustomName, range, and any required codec overrides with SetRenderSettings() before calling AddRenderJob().

How the example works

1

Connect to Resolve

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

2

Validate the current context

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

3

Run the core API operation

Execute the operation demonstrated in this guide: how to load a render preset with the davinci resolve python api.

4

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

  • GetRenderPresetList() can return an empty list in some environments.
  • Check the boolean result from LoadRenderPreset() before assuming the preset was applied.
  • Individual settings can be overridden after the preset is loaded.
  • Do not create the Render Job until TargetDir and naming settings are correct.

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