DaVinci Resolve API
Automate DaVinci Resolve with the Python API
A practical hub for the Resolve Scripting API: connect to the application, work with projects and Media Pool, build timelines and automate render operations with Python.
Python automation pipeline
Python Script
GetResolve()Project Manager
Create / Open projectMedia Pool
ImportMedia(files)Timeline
CreateTimeline()Render Queue
StartRender()Practical API guides
DaVinci Resolve API for real production tasks
All 50 practical Resolve API guides are now available in English: connection and projects, Media Pool, Timeline and timecode, audio placement, Render Queue, delivery, diagnostics, and reusable production helpers.
How to Connect to DaVinci Resolve with the Python API
A reliable Resolve Scripting API entry point: import the module, call scriptapp("Resolve"), and verify the active project
Build a dependable starter template for external Python scripts: locate DaVinciResolveScript, obtain the Resolve application object, inspect the installed version, access Project Manager, and verify that a project is open.
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.
How to Get the Current DaVinci Resolve Project in Python
Project Manager, the active Project object, and a safe current-Timeline check
Get the project currently open in Resolve and verify the active Timeline before importing media, reading settings, exporting audio, or starting render automation.
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.
How to Import Media into the DaVinci Resolve Media Pool with Python
ImportMedia, path validation, and MediaPoolItem objects from the current project
Import files into the active project Media Pool, validate source paths before calling Resolve, and inspect the MediaPoolItem objects returned by ImportMedia().
How to Import a Folder and Append Clips to a Timeline
Folder scanning, ImportMedia, CreateEmptyTimeline, and AppendToTimeline in a predictable order
Scan a folder for video files, sort them by filename, import them into the Media Pool, create a Timeline when needed, and append the imported clips as a rough assembly.
How to Create a Timeline in DaVinci Resolve with Python
CreateEmptyTimeline, CreateTimelineFromClips, and validation of the newly created sequence
Use either an empty Timeline or a Timeline created directly from imported Media Pool clips, depending on how much control your automation needs over the assembly process.
How to Get Timeline FPS with the DaVinci Resolve Python API
Read timelineFrameRate from the Timeline, with Project settings as a fallback
Read the active Timeline frame rate, convert string settings safely to float, and use project settings as a fallback when the Timeline does not expose a value.
How to Iterate Timeline Clips with the DaVinci Resolve Python API
Use GetTrackCount and GetItemListInTrack across video and audio tracks
Walk every video and audio track on the active Timeline, inspect TimelineItem objects, and print the name, start frame, and end frame for each clip.
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.
How to Convert Frames to Timecode for DaVinci Resolve in Python
A practical frames_to_tc helper for SetCurrentTimecode, In/Out ranges, and frame-accurate Timeline operations
Convert a Timeline frame number into HH:MM:SS:FF timecode before moving the playhead, setting In/Out points, or calling Resolve methods that expect timecode instead of seconds.
How to Convert DaVinci Resolve Timecode to Frames in Python
Convert HH:MM:SS:FF back to a frame index for precise Timeline calculations
Use a small parse_tc_to_frames() helper to convert Resolve timecode into a frame number so ranges, durations, offsets, and external Timeline data can be compared in one coordinate system.
How to Move the Playhead in DaVinci Resolve with the Python API
SetCurrentTimecode, SetCurrentFrame, and a defensive helper for jumping to an exact Timeline frame
Move the Resolve playhead to a known frame by trying SetCurrentTimecode first and falling back to SetCurrentFrame when that method is available in the current scripting build.
How to Unlock Timeline Tracks with the DaVinci Resolve Python API
Use GetTrackCount, SetTrackLock, and SetTrackEnable across all video and audio tracks
Prepare a Timeline for later automation by iterating every existing video and audio track, removing track locks, and enabling tracks without hard-coding V1, V2, A1, or A2.
How to List Render Presets with the DaVinci Resolve Python API
Use GetRenderPresetList and LoadRenderPreset to prepare a render from Python
Read the Render Presets available to the current Resolve project, select a suitable preset, and load it safely before creating a Render Job.
How to Clear the Render Queue with the DaVinci Resolve Python API
Use GetRenderJobs, GetRenderJobList, DeleteRenderJob, and StopRendering before a fresh export
Build a defensive Render Queue cleanup routine: enumerate existing jobs, extract their job IDs, stop an active render if necessary, and remove stale jobs before creating a new one.
How to Set a Render Range from V1 Clips with the DaVinci Resolve API
Use GetItemListInTrack, SetInOutPoints, and SetRenderRange to render only the active V1 edit
Find the combined frame range occupied by clips on video track V1, convert that range to timecode, set Timeline In/Out points, and switch the Deliver page to In/Out Range.
How to Detect Source Resolution on V1 with the DaVinci Resolve API
Read MediaPoolItem clip properties and find the largest source resolution on the primary video track
Walk the clips on V1, resolve each TimelineItem back to its MediaPoolItem, read source properties, and determine a representative maximum resolution for project or render setup.
How to Export Timeline Audio to WAV with the DaVinci Resolve Python API
Deliver page, SetCurrentRenderFormatAndCodec, SetRenderSettings, and an audio-only Render Job
Export the active Timeline to WAV from Python: switch to Deliver, clear stale jobs, configure LinearPCM audio, create a Render Job, start it, and wait for Resolve to finish.
How to Delete Timeline Clips with the DaVinci Resolve Python API
Find a TimelineItem by frame range, validate it, and pass the selected item to DeleteClips
Locate an item on the active Timeline by its start and end frame positions, verify that DeleteClips is available, and delete only the TimelineItem that matches the requested range.
How to Append Clips to a DaVinci Resolve Timeline with AppendToTimeline
Import media into the Media Pool and append clips to the active Timeline in a controlled order
Import a list of files with ImportMedia, map the resulting MediaPoolItem objects back to their source paths, and append them to the active Timeline in the intended order.
How to Get the Timeline Start Frame with the DaVinci Resolve API
Use GetStartFrame and GetStart defensively to determine the Timeline base frame
Read the Timeline base frame with GetStartFrame when available, fall back to GetStart on compatible builds, and avoid assuming that every Timeline begins at frame zero.
How to Read the Timeline Start Timecode with the DaVinci Resolve Python API
Read timelineStartTimecode, fall back to GetStartTimecode, and convert the result to frames
Read the active Timeline start timecode from settings, use GetStartTimecode as a fallback, and convert HH:MM:SS:FF into a frame-based value for external synchronization.
How to Split a Clip at an Exact Frame in DaVinci Resolve with Python
Find the clip under a frame, move the playhead, and trigger Resolve's native Split Clip command
Use the Scripting API to verify that a clip crosses the requested frame and move the playhead there, then trigger Resolve's native split command as a practical fallback when a direct SplitClip API method is unavailable.
How to Build a Timeline Clip Map with the DaVinci Resolve API
Combine GetTrackCount, GetItemListInTrack, GetStart, GetEnd, and MediaPoolItem source data
Build a technical map of the active Timeline containing media type, track number, clip name, start, end, duration, and source file path when a linked MediaPoolItem is available.
How to Trim a TimelineItem with the DaVinci Resolve Python API
Test SetStart, SetEnd, SetLeftOffset, and SetRightOffset defensively when changing clip boundaries
Find a video TimelineItem, read its current boundaries, and attempt a controlled trim using whichever TimelineItem boundary methods are exposed by the installed Resolve scripting version.
How to Render the Entire Timeline with the DaVinci Resolve Python API
Set Entire Timeline, configure output settings, add one Render Job, and start only that job
Build a complete active-Timeline render skeleton: clean the queue, clear old In/Out points, select Entire Timeline, configure the output path, create a Render Job, launch it, and wait for completion.
How to Configure MOV H.265 Render Settings with the DaVinci Resolve API
Set TargetDir, CustomName, container, HEVC video, AAC audio, and bitrate from Python
Configure a practical MOV + H.265/HEVC export from Python, including output directory, base file name, video and audio settings, bitrate, and codec-name fallbacks for different Resolve environments.
How to Apply V1 Source Resolution to Project and Render Settings
Use GetMediaPoolItem, GetClipProperty, SetSetting, and ResolutionWidth/ResolutionHeight
Detect the largest source resolution represented by clips on V1 and apply that width and height to project and render settings as part of an automated export-preparation step.
How to Read Source Properties with MediaPoolItem.GetClipProperty
Connect TimelineItem to MediaPoolItem and read file path, resolution, FPS, and codec metadata
Use TimelineItem.GetMediaPoolItem() and MediaPoolItem.GetClipProperty() to inspect the source media behind clips on the Timeline.
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.
How to Configure Render Settings with the DaVinci Resolve Python API
Set TargetDir, CustomName, container, codec, audio, and other delivery parameters before AddRenderJob
Use SetRenderSettings() to configure a practical final export: output directory, file name, MOV container, H.265/HEVC video, AAC audio, and bitrate-related options.
How to Create a Render Job with the DaVinci Resolve Python API
Configure the preset, range, and output settings first, then call AddRenderJob
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.
How to Start One Render Job with the DaVinci Resolve Python API
Use StartRendering with a specific job ID without launching stale tasks in the queue
Start only the Render Job you just created, trying compatible job-ID representations where necessary, instead of triggering every task that may remain in the Render Queue.
How to Read Render Job Status with the DaVinci Resolve Python API
Use GetRenderJobStatus, JobStatus, and progress data to verify an export result
Read a Render Job by ID during and after rendering, normalize the status response, and distinguish completed, failed, or unavailable states without checking the Deliver page manually.
How to Wait for a Render to Finish with the DaVinci Resolve Python API
Use IsRenderingInProgress, a polling interval, and a final Render Job status check
Keep a Python automation process alive until Resolve finishes rendering, poll at a reasonable interval, then read the final job status and verify the output file.
How to Stop Rendering with the DaVinci Resolve Python API
Use StopRendering before queue cleanup or an emergency cancellation path
Stop an active Resolve export safely, confirm that IsRenderingInProgress becomes false, and only then modify the Render Queue or rebuild a Render Job.
How to Delete a Render Job with the DaVinci Resolve Python API
Handle different job-ID shapes with DeleteRenderJob and remove one queue entry safely
Delete a specific Render Queue task while accounting for job IDs that Resolve may expose as strings, numbers, or dictionaries in different scripting versions.
How to Set an In/Out Render Range with the DaVinci Resolve Python API
Convert frames to timecode, call SetInOutPoints, and switch the Deliver page to In/Out Range
Turn a frame-based interval into Timeline timecodes, set In and Out points, and configure Resolve to render only that selected range.
A Complete DaVinci Resolve Render Pipeline with the Python API
Project, Timeline, queue cleanup, MOV H.265 settings, AddRenderJob, StartRendering, status, and output verification
Combine the core Resolve render calls into one end-to-end workflow: prepare the active project, configure delivery, create one Render Job, launch it safely, wait for completion, and return the finished file path.
How to Get the Audio Track Count from a DaVinci Resolve Timeline
Use GetTrackCount("audio") before inserting music, SFX, or running audio-oriented automation
Read the number of audio tracks in the active Timeline and use that value to validate track targets before adding audio clips or preparing an audio workflow.
How to Create Missing Audio Tracks with the DaVinci Resolve API
Check GetTrackCount and add tracks with AddTrack("audio") until the requested track index exists
Build a helper that guarantees A1, A2, A3, or another requested audio track exists before a later AppendToTimeline operation targets it.
How to Append an Audio File to a DaVinci Resolve Timeline with Python
ImportMedia plus AppendToTimeline with mediaType 2, recordFrame, and trackIndex
Import an audio file into the Media Pool and place it on a specific Timeline audio track at an exact frame position using a clip-info dictionary.
How to Import Media and Map MediaPoolItem Objects by File Path
ImportMedia, GetClipProperty, and a reusable path-to-MediaPoolItem lookup
Import multiple source files and build a normalized dictionary that lets later automation find the corresponding MediaPoolItem for each original path.
How to Convert Seconds to Timeline Frames for the DaVinci Resolve API
Timeline FPS, base frame, and recordFrame calculation for time-based placement
Convert a time value in seconds into an absolute Timeline frame suitable for recordFrame and other frame-based Resolve API operations.
How to Get a TimelineItem Track Type and Track Index with Python
Use GetMediaType and GetTrackIndex to identify where video, audio, titles, and other Timeline items live
Inspect TimelineItem media type and track index so clips can be grouped, reported, filtered, or processed according to their actual Timeline location.
How to Get the Source Media Path from a DaVinci Resolve Timeline Clip
Use GetMediaPoolItem and GetClipProperty to connect a TimelineItem with its source file
Get the MediaPoolItem behind a TimelineItem and read its File Path property to locate the source media on disk.
How to Create Missing Video Tracks with the DaVinci Resolve API
Use GetTrackCount("video") and AddTrack("video") before targeting V2, V3, or higher tracks
Prepare a Timeline safely by checking how many video tracks exist and creating missing tracks before later placement operations target them.
How to Export a DaVinci Resolve Timeline Clip Map to JSON
GetTrackCount, GetItemListInTrack, GetStart, GetEnd, and JSON serialization of Timeline structure
Build a technical JSON map of the current Timeline containing media type, track number, clip name, start, end, duration, and source path when available.
How to Calculate Visible V1 Segments When V2 Clips Overlap
GetItemListInTrack, clip intervals, and Timeline geometry across stacked video tracks
Calculate which portions of V1 remain visible when clips on V2 cover parts of the primary video track, without modifying the Timeline.