Blender Cloud Rendering: Rent a GPU vs a Render Farm (2026)

Blender cloud rendering comes in two flavors: upload your scene to a render farm that splits it across its own nodes, or rent a GPU for rendering and run Blender yourself. The second option costs less per GPU-hour and runs exactly the Blender version and add-ons you use locally. This guide shows how to render Cycles headless on a rented RTX 5090 GPU, which GPU to pick for your scene size, and what each frame actually costs.

TL;DR: Blender Cloud Rendering on a Rented GPU

Rent an RTX 5090 for most Cycles work; it renders about 35% faster than an RTX 4090 per the Blender 4.5 OptiX benchmark.

Scores are Blender Open Data medians (Oct 2026); Spheron rates as of 20 Oct 2026. Compare all GPU rental pricing.

Render Farm or Rented GPU?

A render farm and a rented GPU both put your frames on someone else's hardware. They differ in who runs Blender.

Published farm pricing as of 20 Oct 2026: Render.st lists Blender Cycles at $4.49 per server-hour on L40S hardware. GarageFarm lists GPU nodes from $3.16 to $18.99 per hour for a single L40S and $3.22 to $25.76 for an RTX PRO 6000, depending on priority tier. A rented RTX 5090 on Spheron costs $0.78/hr.

The farm premium buys convenience and massive parallelism. If you need 500 frames back in 10 minutes and never want to touch a terminal, a farm is the right call. If you can wait an hour and are comfortable with SSH, renting the GPU directly costs a fraction as much. Many studios use both: a rented GPU for look-dev and test renders, a farm for the final crunch.

Which GPU to Rent for Blender Cycles

Cycles uses NVIDIA's RT cores through OptiX, so ray-tracing hardware matters more than raw compute or memory bandwidth. That is why consumer and workstation RTX cards beat datacenter AI GPUs at rendering.

RTX 5090 (32GB): the default. It scores 14,966 on Blender Open Data's OptiX benchmark across 1,555 submitted runs, about 35% ahead of the RTX 4090. 32GB holds most product shots, archviz interiors and character animation. Our RTX 5090 vs RTX 4090 comparison covers the generational jump in detail.

RTX 4090 (24GB): the budget pick. Still fast at 11,061, and enough VRAM for most scenes under heavy texture loads. The RTX 4090 rental is worth it when the 5090 is sold out or the scene is light.

L40S (48GB): big scenes on a budget. It renders about 30% slower than an RTX 4090 (7,848 for the bare-metal L40S in Blender Open Data, from a small sample) but has twice the memory. Choose it when a scene with dense geometry, volumes or 8K textures does not fit in 32GB. See our L40S deep dive for the full spec sheet.

RTX PRO 6000 Blackwell (96GB): the biggest scenes. The Server Edition used in data centers scores 15,519, only about 4% ahead of the RTX 5090 (the 600W Workstation Edition reaches 16,737), and holds almost anything. It costs more per hour, so reserve it for scenes that are too big for 48GB. The RTX 5090 vs RTX PRO 6000 comparison explains what the extra money buys.

Skip H100 and A100. They have no RT cores and cost more per hour. In Blender Open Data an H100 scores about 5,900 and an A100 about 3,700 with OptiX (from only a handful of submissions), roughly half and a third of an RTX 4090. They are built for AI training, not ray tracing.

A note on VRAM: Cycles on NVIDIA can spill some data into system RAM when a scene overflows the GPU, but render times climb sharply when it does. Size the GPU to the scene. Open the scene locally, render one frame, and read the peak memory in Blender's status bar before you rent.

Step-by-Step: Render Blender Headless on a Cloud GPU

1. Rent a GPU and install Blender

Launch a GPU server with Ubuntu 22.04 or 24.04 on Spheron, SSH in, and install the libraries Blender's Linux build links against. Cycles does not need a display.

sudo apt-get update
sudo apt-get install -y libxi6 libxxf86vm1 libxfixes3 libxrender1 libgl1 \
  libxkbcommon0 libsm6 libice6 xz-utils
VER=4.5.14   # newest 4.5 LTS patch on 20 Oct 2026; check download.blender.org/release/Blender4.5/
wget https://download.blender.org/release/Blender4.5/blender-$VER-linux-x64.tar.xz
tar xf blender-$VER-linux-x64.tar.xz
mv blender-$VER-linux-x64 ~/blender
~/blender/blender --version
nvidia-smi

Match the Blender version you use locally. A file saved in a newer Blender can render differently, or not at all, in an older one.

2. Pack and upload the scene

On your workstation, use File > External Data > Pack Resources so every texture and HDRI travels inside the .blend. Linked libraries and caches (simulation bakes, Alembic, VDB) need to go up separately with their folder structure intact.

rsync -avP scene.blend user@your-gpu-server:~/project/

Before uploading, set Output > Overwrite off and Placeholders on in the render properties. Blender then skips frames that already exist, so a restarted render picks up where it stopped. That matters if you use spot capacity, which can be reclaimed.

3. Render with OptiX

Arguments run in order, so put the output path and format before -a:

cd ~/project
~/blender/blender -b scene.blend -E CYCLES \
  -o //renders/frame_#### -F PNG -s 1 -e 250 -a \
  -- --cycles-device OPTIX

For a single still, swap -s 1 -e 250 -a for -f 1. While the first frame renders, run nvidia-smi in a second session: the GPU should sit near full utilization. If it idles, Blender fell back to CPU, and the driver or device flag is wrong.

4. Use every GPU on a multi-GPU server

Cycles can split one frame across GPUs, but for animations it is faster to give each GPU its own frames. The -j flag makes each process skip ahead by the GPU count:

N=$(nvidia-smi -L | wc -l)
for i in $(seq 0 $((N-1))); do
  CUDA_VISIBLE_DEVICES=$i ~/blender/blender -b scene.blend -E CYCLES \
    -o //renders/frame_#### -F PNG -s $((1+i)) -e 250 -j $N -a \
    -- --cycles-device OPTIX > render_gpu$i.log 2>&1 &
done
wait

On a 4-GPU server, GPU 0 renders frames 1, 5, 9 and so on. Total GPU-hours stay the same as a single card; wall-clock time drops by roughly the GPU count.

5. Download and shut down

rsync -avP user@your-gpu-server:~/project/renders/ ./renders/

Terminate the instance when the frames are safe. Billing on Spheron is per minute, so a forgotten idle server is the only real way to waste money here.

Cost per Frame: Worked Example

Rendering cost is GPU-hours times the hourly rate. To estimate GPU-hours, time one representative frame locally, then scale it by the benchmark ratio between your card and the cloud GPU.

The example below assumes a 1080p frame that takes 2 minutes on an RTX 4090, typical of a lit archviz interior at a few hundred samples with denoising. Other GPUs are scaled by their Blender 4.5 OptiX scores. Hourly rates are frozen so the comparison stays internally consistent: they are the last recorded Spheron on-demand rates on 17 Sep 2026, and the farm rate is GarageFarm's lowest published L40S node price on 20 Oct 2026.

These are not current prices. For today's rates, see the TL;DR table above. The ratios are the useful part. At these frozen rates the RTX 5090 came out cheapest per frame with the RTX 4090 close behind; the two can swap order as marketplace rates move, so redo the division with live rates before a big job. The bigger gap is the farm: the same L40S cost about three times as much per frame at the farm's lowest listed rate as rented directly.

Wall-clock time is a separate question. 6.2 GPU-hours on one RTX 5090 is an afternoon. Spread across 8 rented GPUs, the same shot finishes in under an hour for the same total cost, because you pay for GPU-hours, not for waiting.

Pricing fluctuates based on GPU availability. Spheron rates above are live as of 20 Oct 2026; other providers reflect their most recent published rates and may have changed. Check current GPU pricing → for live rates.

Tips to Cut Cloud Rendering Cost

• Test locally, render remotely. Dial in lighting at low samples on your own machine. Only send final-quality frames to the cloud.
• Use adaptive sampling and the OptiX or OpenImageDenoise denoiser. A noise threshold plus a denoiser lets you cut max samples sharply, often with no visible difference.
• Use spot capacity for animations. Frames are independent, so with Overwrite off and Placeholders on, a reclaimed instance loses one frame at most. Spot capacity can be reclaimed without notice; our spot instance guide covers the pattern.
• Keep the scene on a persistent volume if you render the same project repeatedly, so you do not re-upload gigabytes each session.
• Watch the first frame. Check nvidia-smi for full GPU use. A job that silently fell back to CPU can take many times longer.

The same rented GPUs that render Blender also run real-time 3D work like Gaussian splatting reconstructions and AI tooling for game studios such as self-hosted AI NPCs, so one account covers a whole 3D pipeline.

Rendering a Blender project this week? Spin up an RTX 5090 or a 96GB RTX PRO 6000, render headless with OptiX, and pay per minute.

RTX 5090 on Spheron → | RTX PRO 6000 availability → | L40S GPU pricing →

Get started on Spheron →