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.
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
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 load a render preset with the davinci resolve 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
- 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
Render
How to List Render Presets with the DaVinci Resolve Python API
Read the Render Presets available to the current Resolve project, select a suitable preset, and load it safely before creating a Render Job.
Render
How to Configure Render Settings with the DaVinci Resolve Python API
Use SetRenderSettings() to configure a practical final export: output directory, file name, MOV container, H.265/HEVC video, AAC audio, and bitrate-related options.
Render
How to Create a Render Job with the DaVinci Resolve Python API
Follow the correct Render Queue order: choose or load a preset, apply the final Render Settings and range, create the job, and retain the returned job ID for safe targeted execution.

