DaVinci Resolve APIAdvancedRender

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.

API

Resolve Scripting API

Language

Python

Resolve

19–20+

Requires

Running Resolve

Syntax

ok = project.DeleteRenderJob(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
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 extract_render_job_id(job):
    if isinstance(job, dict):
        return (
            job.get("JobId")
            or job.get("jobId")
            or job.get("JobID")
            or job.get("Id")
            or job.get("id")
        )
    return job


def delete_render_job(project, raw_job):
    job_id = extract_render_job_id(raw_job)
    variants = []
    if job_id is not None:
        variants.extend([job_id, str(job_id)])
        try:
            variants.append(int(job_id))
        except Exception:
            pass
    variants.append(raw_job)

    seen = set()
    for value in variants:
        marker = repr(value)
        if marker in seen:
            continue
        seen.add(marker)
        if safe_call(project, "DeleteRenderJob", value):
            return True
    return False


resolve, project, timeline = get_project_and_timeline()
safe_call(project, "StopRendering")
jobs = safe_call(project, "GetRenderJobs") or safe_call(project, "GetRenderJobList") or []
for job in jobs:
    print("delete", extract_render_job_id(job), delete_render_job(project, job))

Guide

What the example does

The code reads the Render Queue, extracts an identifier from each task, and tries compatible representations of that same logical ID with DeleteRenderJob().

Why more than one representation is tested

Depending on the Resolve build, queue data can expose an ID as a string, a number, or fields such as JobId or Id inside a dictionary. DeleteRenderJob may not accept every form, so a defensive helper normalizes and tests only equivalent values for the same task.

How this differs from clearing the whole queue

This article focuses on deleting individual jobs. A full cleanup routine is simply the next layer: list the queue, pass each job through the deletion helper, then read the queue again to confirm what remains.

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 delete a render job 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

Stop an active render before trying to delete the job that is running.
Do not depend on only one field name such as JobId.
Read GetRenderJobs() again after deletion to confirm that the queue changed.
If deletion fails, start any new export explicitly by its own job ID.

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