DaVinci Resolve APIBeginnerTimeline

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.

API

Resolve Scripting API

Language

Python

Resolve

19–20+

Requires

Running Resolve

Syntax

fps = float(timeline.GetSetting("timelineFrameRate"))

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


def get_timeline_fps(project, timeline):
    try:
        value = timeline.GetSetting("timelineFrameRate")
        if value:
            return float(value)
    except Exception:
        pass

    try:
        value = project.GetSetting("timelineFrameRate")
        if value:
            return float(value)
    except Exception:
        pass

    return 25.0


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

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

fps = get_timeline_fps(project, timeline)
print("Timeline FPS:", fps)

Guide

Why FPS should come from Resolve

Resolve projects can use 23.976, 24, 25, 30, 50, 60 fps, and other rates. Hard-coding the value causes frame, duration, and timecode calculations to drift. Read the active Timeline settings whenever possible.

Why the result is converted to float

GetSetting("timelineFrameRate") often returns a string. Convert it to float before calculations, especially for fractional frame rates such as 23.976 where converting directly to int would lose important precision.

When the Timeline does not return FPS

Depending on project state and Resolve version, the Timeline setting may be empty. The example therefore tries timeline.GetSetting() first and then project.GetSetting(). A final 25.0 fallback is kept only as a last-resort guard for simple educational scripts.

Where FPS is used

Frame rate is a foundational value for seconds-to-frames conversion, clip-duration calculations, playhead positioning, timecode handling, and render-range logic.

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 get timeline fps 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

GetSetting() values are often returned as strings.
Use float for fractional frame rates such as 23.976.
Treat the 25.0 fallback as a last-resort safety value, not as primary logic.
Verify that an active Timeline exists before reading Timeline-specific settings.

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

Timeline