Black Friday 25% off render credits

Settings

Your pipeline, our render farm API

Submit, monitor and control Blender, Cinema 4D and Houdini renders from your own scripts and tools. Included with Drop & Render Link.

dar login
dar job prepare render.json
dar job submit render.json
{
  "ok": true,
  "phase": "accepted",
  "jobs": [{"job_id": "...", "qid": "..."}]
}

Windows, macOS and Linux

Add cloud rendering to your pipeline

The farm becomes part of your own workflow. A few things artists and studios can build with it:

monitoring

Your own render monitor

Every active job, its render progress and download state on a screen in the studio, a page on your phone or a widget on your desktop. You decide what it shows.

notifications_active

A message when your shot is done

Post to Discord, Slack or Teams when frames are delivered, or when a slice needs attention. No more refreshing the dashboard.

dark_mode

Overnight batches

Queue every shot of the episode before you leave. Have your pipeline follow delivery into your project folders.

movie

Automatic previews

When the frames arrive, your script builds a review video, runs a comp or copies the shot to the client folder. Rendering is one step in the chain.

layers

Product variations at scale

Forty colorways, ten camera angles, every language version of a packshot. Generate the requests in a loop and send them in one go.

touch_app

One-click submit from your tools

Add a Render on the farm button to your asset browser, your production tracker or an internal web page for the team.

payments

Cost-aware rendering

Let the farm sample the first, middle and last frame, then pick a cost-efficient frame grouping for the rest of the sequence automatically.

replay

Self-healing renders

Watch the slices of a job and retry one that failed, once, before anyone gets a notification.

terminal

A render assistant in your terminal

Describe the render in plain words. A coding assistant writes the request, validates it, submits it and tells you when the frames are delivered.

How the render farm API works

Describe your scene in JSON and submit it through Link. The farm renders the job and returns finished frames to your output folder.

  1. 1

    1. Describe the render

    Create a render.json file with your application, version, render engine, scene, frame range and output folder. Include the scene’s dependencies in assets, as they are not discovered automatically, and write relative paths from the JSON file’s directory.

  2. 2

    2. Submit it

    Run dar job submit render.json. Upload and rendering continue in the background. Keep source files unchanged until upload finishes.

  3. 3

    3. Get your frames

    Keep Link running to receive frames in your output folder. Check delivery with dar job status before processing them.

Get started in five minutes

Install Link and connect your account, then submit a short test render from your terminal.

  1. 1

    1. Create your free account

    Register at dropandrender.com/register. You get €25 in render credits to test with.

  2. 2

    2. Download and install Link

    Use the Start rendering page. Link connects your computer to the farm, installs your 3D application plugins and includes the dar command.

  3. 3

    3. Open a terminal and sign in

    Run dar login. This opens your browser to connect the account. On an unattended machine, pass studio, username and password from your secret store instead.

  4. 4

    4. Check that everything is ready

    Run dar status. It prints your sign-in and service readiness as JSON.

  5. 5

    5. Send your first render

    Use one of the examples below. Start with a short frame range to check the output and cost for your scene.

dar login
dar status

# For unattended machines, use credentials from your secret store:
dar login "$DAR_STUDIO" "$DAR_USER" "$DAR_PASS"

Simple examples

These are deliberately short. The complete reference is built into dar itself.

1. Render a Blender shot

Put render.json next to your .blend file:

{
  "application": "blender",
  "version": "4.5",
  "renderer": "cycles",
  "assets": ["textures"],
  "jobs": [{
    "name": "shot010",
    "scene": "shot010.blend",
    "frames": {"start": 1, "end": 120},
    "output": {"directory": "renders/shot010", "format": "png"}
  }]
}
dar job submit render.json

Frames download to renders/shot010. Keep output folders outside the inputs listed in assets. For Cinema 4D, omit output.format and save the format in your scene. Houdini HIP jobs need an absolute render_node, such as /out/karma1; standalone USD uses Karma without a render node.

2. Check a render

dar job status <job_id>

Read state for the job’s lifecycle. Rendering finished is delivery_pending; wait for delivered before processing the output. The percentages farm_progress, render_progress, download_progress and upload_progress can be null when unknown; farm progress depends on the current stage.

If a shot becomes urgent, use its returned QID to check the available priority tiers before changing it:

dar job priority <qid>
dar job priority <qid> emerald

Choose from allowed_tiers and confirm the cost change. Priority changes wait up to 30 seconds for confirmation; use --detach to return sooner. If you receive accepted, check the job before trying again.

3. Send a Discord message when frames arrive

Check a job once and notify Discord if its frames have arrived. Set DISCORD_WEBHOOK_URL from your secret store. In your monitor, send only once per job. Adapt this example to other platforms as needed.

import json
import os
import subprocess
import urllib.request

out = subprocess.run(
    ["dar", "job", "status", "<job_id>"],
    capture_output=True,
    text=True,
    check=True,
).stdout
result = json.loads(out)

if result["state"] == "delivered":
    body = json.dumps({"content": "shot010 is delivered"}).encode()
    request = urllib.request.Request(
        os.environ["DISCORD_WEBHOOK_URL"],
        data=body,
        headers={"Content-Type": "application/json"},
    )
    with urllib.request.urlopen(request) as response:
        response.read()

4. Send every shot before you go home

for request in shots/*/render.json; do
  dar job submit "$request"
done

Each submission returns its job IDs as JSON, ready for your own monitor.

Give the batch a project label in each request’s top-level labels object, then add a shot label in jobs[].labels. Your monitor can find the relevant shots without keeping a separate list of IDs:

dar job list --label project=atlas --label shot=sh010

You’ll get jobs matching every label exactly, with filtering applied before pagination. Within a request, you can override the default labels for each job or remove an inherited key with null. Any take children keep the labels set at submission, even if you edit the parent’s labels later.

dar job label <qid> project atlas
dar job label <qid> project
dar job label <qid> --clear project

Set, read or remove a label on an existing job. Use --clear to remove the key; passing an empty string keeps it with an empty value. Use dar job get <qid> to read every label.

5. A tiny render monitor

import json
import subprocess
import time


def dar(*args):
    out = subprocess.run(
        ["dar", *args],
        capture_output=True,
        text=True,
        check=True,
    )
    return json.loads(out.stdout)


job_id = "<job_id>"
while True:
    job = dar("job", "status", job_id)
    print(job["state"], job["farm_progress"], job["download_progress"])
    if job["state"] in ("delivered", "error", "cancelled"):
        break
    time.sleep(60)

This minimal monitor polls until delivery, error or cancellation. Unknown progress prints as None. In production, also set a timeout.

6. Ask the farm which versions it has

dar versions blender
dar versions redshift --houdini 21.0.700

Choose a supported build from the returned JSON list before writing it into your render request.

The full reference is in dar itself

Every command documents itself, and the help always matches the version you have installed:

dar --help                 # all commands with examples
dar job prepare --help     # every render.json field, per application
dar job submit --help      # options such as --with-estimate

Ready for scripts, pipelines and agentic workflows

Use dar from your Python and shell scripts, or with terminal-based coding assistants such as Claude Code, Codex, Cursor or Amp.

  • Built-in reference: use --help to look up commands and request fields.
  • Structured results: read JSON from stdout and follow progress separately on stderr.
  • Suggested next actions: dar job list includes ready-to-run arguments in next. Job status, get and events return data without added guidance.
  • Validate before spending: run dar job prepare to check your request without creating a job.
  • Interactive confirmation: when you cancel, suspend, resume or requeue work in a terminal, you’ll be asked to confirm, with No selected by default.
Render frames 1 to 24 of shots/shot010/shot010.blend with Cycles on Drop & Render.
Validate the request with dar job prepare first, submit it, then poll
dar job status until the frames are delivered to renders/shot010.

Keep control of automated jobs

  • Require approval: scripts do not prompt before submit, cancel or requeue. Rendering spends credits.
  • Start small: validate with dar job prepare and render a short frame range first.
  • Pin the account: pass --account using the account reported by dar status.

What the API covers

Use these commands to prepare submissions, follow renders and manage jobs. Each command includes its own help and returns structured results.

Task Command
Validate without creating a job dar job prepare render.json
Submit and return after acceptance dar job submit render.json
Estimate credits and choose frame grouping dar job submit render.json --with-estimate
Render state, progress and download progress dar job status <id>
List jobs, filter by name, state or user dar job list --search shot010
Full job record, slices, events and resources dar job get, slices, events, resources
Control a job dar job suspend, resume, cancel
Retry one slice dar job requeue <qid> --slice 4
Set a job label dar job label <qid> project atlas
Filter jobs by labels dar job list --label project=atlas --label shot=sh010
Read priority and allowed tiers dar job priority <qid>
Change a job’s priority dar job priority <qid> emerald
Farm application or renderer versions dar versions blender, dar versions redshift --houdini 21.0.700
Browse archived jobs and files dar archive list, dar archive files <archive_id>
Download an archived file dar archive download <archive_id> --file <name> --output <new-path>
Check files already on the farm dar sync check --list files.txt
Sign-in, readiness and diagnostics dar status, dar diagnose

Jobs submitted from the plugins are farm jobs too: list, follow and control them with the same commands.

Use --page to read further pages of jobs or slices. To follow events in your script, poll the event history rather than waiting for webhook notifications.

Use --with-estimate to estimate credits from paid test frames and choose a cost-efficient slice size. Wait for the samples to render and download; remaining frames run in the background without rendering the samples again. When sample charges are available, a planning estimate prints on stderr, not a fixed quote. For example:

Job 1 should cost about 200.00 credits total, with 194.00 credits remaining.

Test frames are charged at normal rates. Use consecutive frames without exclusions or dependencies. Submit caches, single-machine jobs and standalone USD without estimation.

Supported applications and render engines

Submit Blender, Cinema 4D and Houdini projects with the render engines below. Check the available builds before preparing your request.

Application Render engines Also supported
Blender Cycles, Eevee, Redshift, Octane, LuxCore Goo Engine and E-Cycles builds
Cinema 4D Standard, Physical, Redshift, Octane, Arnold, Corona, V-Ray, Cycles 4D, Thea Saved output format; optional pass remapping for Redshift, Octane and Cycles 4D
Houdini Karma, Mantra, Redshift, Octane, V-Ray File Cache, standalone USD with Karma CPU and XPU, SideFX Labs, MOPs and qLib

Run on Windows, macOS or Linux. Query dar versions blender, dar versions cinema4d or dar versions houdini for available farm builds. Without a name, dar versions reports Link and service versions.

Already using a render manager?

Keep it. The API sits next to the tools your studio already uses, and our own integrations are built on it.

monitoring

Deadline 10

Follow and control your Drop & Render cloud jobs in Deadline Monitor, next to your local renders.

hub

Flamenco 3

Send Blender jobs to the cloud with the Drop & Render job type. Frames come back to your output folder.

assistant

MCP extension

Connect your AI assistant to prepare, submit and follow renders through Drop & Render Link.

Same farm, same pricing

No API fee. Jobs submitted with dar use the same account, render credits and priority tiers as plugin jobs.

Related FAQs

Have questions about the render farm API? Find answers about setup, supported applications and automatic delivery here.

Does Drop & Render have a render farm API?

keyboard_arrow_down

Do I need an API key?

keyboard_arrow_down

How do I get started with the API?

keyboard_arrow_down

Can I build my own render monitor or dashboard?

keyboard_arrow_down

Can AI coding assistants use the Drop & Render API?

keyboard_arrow_down

Does the API download the rendered frames automatically?

keyboard_arrow_down

Which applications and render engines does the API support?

keyboard_arrow_down

Does it work on Windows, macOS and Linux?

keyboard_arrow_down

Can I control jobs I submitted from the plugins?

keyboard_arrow_down

Is rendering through the API more expensive?

keyboard_arrow_down

Can I use the API together with Deadline or Flamenco?

keyboard_arrow_down

Start with one shot

Create an account, install Link, write a render.json for one shot and run it. You keep control of your scenes and your next production step. We render and bring the frames back.