Guide

Best GPUs to rent for Stable Diffusion, SDXL and Flux.

VRAM needs for SD 1.5, SDXL and Flux at FP16, FP8 and NF4, why consumer cards win on value, and how to work out your real cost per 1,000 images.

By Vi Nguyen · Published October 27, 2026 · Prices on this page are live · Editorial policy

Image generation is the one popular AI workload where the expensive datacenter GPUs rarely make sense. Stable Diffusion 1.5 and SDXL fit comfortably in consumer VRAM, Flux fits once you pick the right precision, and none of them need the multi-GPU interconnect that justifies H100 pricing for LLM training. That leaves you with a simpler question: which consumer or workstation card gives you the most images per dollar for the model you actually use? This guide walks through the VRAM each model needs, how to turn an hourly rental price into a cost per 1,000 images, and when the answer changes because you are generating interactively rather than in batches.

How much VRAM each model needs

A diffusion pipeline is several networks, not one. There is a text encoder (or two) that turns your prompt into embeddings, the denoising network (a UNet in Stable Diffusion, a transformer in Flux) that runs once per sampling step, and a VAE that decodes the final latent into pixels. The denoiser dominates compute. Memory is the sum of whichever parts are resident at the same time, plus activations that grow with resolution and batch size.

Using the same rule of thumb as for language models, weights take parameters × bytes per parameter: 2 bytes at FP16 or BF16, 1 byte at FP8, and roughly half a byte at 4-bit formats such as NF4.

• Stable Diffusion 1.5: the UNet is under a billion parameters, and the whole pipeline is only a few gigabytes at FP16. It runs on almost anything with 8 GB, and at its native 512×512 resolution even older cards are fine. It is the cheapest model to run, and its large ecosystem of fine-tunes and LoRAs keeps it relevant.
• SDXL: a UNet of roughly 2.6 billion parameters plus two text encoders brings the pipeline to around 3.5 billion parameters, or about 7 GB of weights at FP16. At its native 1024×1024 resolution, plan for 12 GB to be comfortable, with 16 GB or more if you add a refiner, ControlNets or larger batches.
• Flux.1 dev: the Flux.1 dev transformer alone has 12 billion parameters. At BF16 that is about 24 GB of weights before anything else. Its T5-XXL text encoder adds roughly another 9 GB at FP16. Running everything resident at full precision means a 48 GB card, or a 24 GB card that swaps the text encoder in and out (ComfyUI does this automatically, at some cost in speed).
• Flux at FP8: the transformer drops to about 12 GB, and an FP8 T5 to about 5 GB. This is the configuration most people run on 24 GB cards, and the quality loss is generally small.
• Flux at NF4 or other 4-bit formats: the transformer falls to around 6–7 GB, which brings Flux within reach of 12 GB and 16 GB cards, with a more visible quality trade-off and some speed overhead from dequantization.

One subtlety worth knowing: storing weights in FP8 saves memory on any GPU, but only cards with FP8 tensor cores get a compute speedup from it. The RTX 40-series (Ada) and 50-series (Blackwell) have them; the RTX 3090 (Ampere) does not, so FP8 weights are upcast before the math runs. On a 3090, FP8 is a memory trick, not a speed trick.

GPU	VRAM	Cheapest now	Where	Median across providers	Providers
Nvidia GeForce RTX 3090	24GB	$0.15/hr	Akash Network	$0.21/hr	7
Nvidia GeForce RTX 4090	24GB	$0.30/hr	io.net	$0.47/hr	11
Nvidia GeForce RTX 5090	32GB	$0.45/hr	Nosana	$0.75/hr	6
Nvidia RTX 4070 Ti SUPER	16GB	$0.29/hr	Clore.ai	$0.31/hr	2
Nvidia L40S	48GB	$0.38/hr	Lium	$0.97/hr	13

Live data: median hourly price per GPU, collected in the last 24 hours. How we collect prices.

Why consumer cards are the value pick

Datacenter GPUs charge a premium for three things: large memory capacity, fast interconnect between GPUs, and enterprise features such as ECC, virtualization and managed support. Image generation mostly doesn't use any of them.

• Memory: every model above fits on 24 GB with the right precision. An 80 GB card doesn't make a single SDXL image faster; the extra memory sits idle unless you run very large batches.
• Interconnect: a diffusion job runs on one GPU. If you want more throughput, you run more independent copies on more cards, which needs no NVLink at all. This is the workload where the RTX 4090's lack of NVLink matters least.
• Compute per dollar: diffusion is compute-bound, since the denoiser processes the whole latent at every step. Consumer cards deliver strong tensor throughput for their rental price. The RTX 4090 and RTX 5090 are among the fastest single cards you can rent for this job.

The workstation and datacenter options still have a place. The 48 GB L40S lets you keep full-precision Flux plus its text encoder resident with room for ControlNets and LoRAs, and it is usually available from managed clouds with better reliability guarantees than a marketplace host. If you are running a production image service with an uptime commitment, that can be worth paying for. For experimentation, personal projects and batch jobs, a 24 GB or 32 GB consumer card is the right starting point. The 16 GB RTX 4070 Ti Super handles SD 1.5 and SDXL well and runs quantized Flux, which makes it a sensible budget option if you find it listed cheaply.

Cost per 1,000 images: the formula

Hourly price alone doesn't tell you which card is cheaper. A card that costs twice as much per hour but generates images three times as fast is the better deal. The metric that matters is cost per image, and it's easy to calculate:

cost per 1,000 images = hourly price ÷ (images per minute × 60) × 1,000

The images-per-minute figure depends on the model, resolution, sampler, step count and software stack, so you need to measure it for your own workflow. Run 20 images with your real settings and time them. To show how the formula works, here is an example with hypothetical throughput numbers, not measurements:

1. Suppose card A generates 2 SDXL images per minute at your settings, and card B generates 5.
2. Card A produces 2 × 60 = 120 images per hour; card B produces 300.
3. At a hypothetical $0.40/hr, card A costs $0.40 ÷ 120 × 1,000 = $3.33 per 1,000 images.
4. At a hypothetical $0.80/hr, card B costs $0.80 ÷ 300 × 1,000 = $2.67 per 1,000 images.

Card B costs twice as much per hour and is still 20% cheaper per image. That is the pattern to look for: the faster card wins whenever its speed advantage is larger than its price premium.

With a live price: the cheapest RTX 4090 right now is $0.30/hr on io.net. If your measured rate on that card were the same hypothetical 5 images per minute, 1,000 images would cost about $1.00. Put your own measured rate in place of the 5 to get your real figure.

A back-of-envelope speed estimate for Flux

If you want a rough speed estimate before you rent, you can derive one from the specs. Flux.1 dev at 1024×1024 works on a 128×128 latent, which it cuts into 2×2 patches, giving 4,096 image tokens. Add up to 512 text tokens for about 4,600 tokens per step. A transformer costs roughly 2 × parameters FLOPs per token, so one step is about 2 × 12 × 10⁹ × 4,600 ≈ 110 TFLOP, before attention overhead. Flux dev is guidance-distilled, so it needs one pass per step rather than the two that classifier-free guidance requires in SDXL.

The RTX 4090's spec-sheet dense BF16 tensor rate with FP32 accumulation is about 165 TFLOPS. At a hypothetical 40% utilization, that's roughly 66 TFLOPS usable, or about 1.7 seconds per step. At 28 steps, that works out to roughly 45–50 seconds per image. That is an estimate, not a benchmark: FP8 kernels on cards that support them, attention optimizations and lower step counts can all bring it down, and it ignores text encoding and VAE decode. Its main use is comparing cards. Because this workload is compute-bound, relative speed between cards roughly follows their relative tensor throughput, which lets you estimate whether a pricier card pays for itself before you rent it.

Batch generation vs interactive use

The cost-per-1,000 formula assumes the GPU is generating the whole time you pay for it. That's true for batch jobs and far from true for interactive work.

Batch generation means a queue of prompts, a dataset of product shots, or a grid of variations that runs unattended. The GPU stays busy, so the formula holds. For batch work, optimize for throughput: pick the card with the lowest cost per image, raise the batch size until you run out of VRAM or stop seeing gains, and consider running several instances in parallel on cheap marketplace hosts. Interruptions matter less here, because a batch job can write each finished image to storage and resume where it stopped.

Interactive use means sitting in ComfyUI or a web UI, tweaking prompts and reviewing results. Here the GPU is idle most of the time while you think. If the card generates for only 10 minutes of each hour you rent, your effective cost per image is six times the batch figure. Two consequences follow:

• For interactive work, latency per image matters more than cost per image, because waiting is what you notice. A faster card makes the session feel better, but you pay its full hourly premium even while it sits idle, so the question is whether the waiting it saves you is worth that premium, not whether it wins on cost per image.
• Shut the instance down when you step away. Per-second or per-minute billing on many platforms makes short sessions cheap, but a forgotten instance running overnight costs more than a week of careful use. Our article on the hidden costs of renting GPUs covers idle time and storage charges.

ComfyUI, templates and setup time

Setup time is a real cost at rental prices, and image generation has more moving parts than most workloads: the UI, custom nodes, checkpoints, LoRAs, VAEs and text encoders, each downloaded separately. A few practical points:

• Use a template. RunPod offers ready-made templates for ComfyUI and other Stable Diffusion interfaces, and marketplace platforms such as Vast.ai also provide image templates. Starting from a known-good image avoids spending your first paid hour on CUDA and Python dependency problems.
• Keep models on persistent storage. Flux dev plus its text encoders is tens of gigabytes. Downloading it at the start of every session wastes paid GPU time. A persistent volume costs a little per month but pays for itself quickly if you come back often. Check how your provider bills for storage while the GPU is stopped.
• Check the license. Flux.1 dev weights are released under a non-commercial license, while Flux.1 schnell uses Apache 2.0. If you plan to use the model in a commercial product, read the terms before building a pipeline around it.
• Mind host variability on marketplaces. Host-supplied platforms like Vast.ai and Clore.ai are often the cheapest place to rent consumer cards, but download speed, disk speed and reliability vary from host to host. A slow disk can make model loading take longer than generation. Check host details before you rent, and see GPU marketplaces vs managed clouds for the broader trade-off.

Which card to rent: a decision framework

• SD 1.5 or SDXL, personal or experimental use: rent a 16 GB or 24 GB consumer card. An RTX 3090 is often the cheapest 24 GB option; an RTX 4070 Ti Super is enough for SDXL at standard settings. Pick whichever is cheapest on the day from a host with good reliability.
• Flux at FP8, or SDXL with ControlNets, LoRAs and upscaling: rent a 24 GB card with FP8 support, which means the RTX 4090. The 3090 fits the model, but without FP8 tensor cores it is slower on the same workflow.
• Heavy Flux workflows or large batches: the 32 GB RTX 5090 gives you more headroom and higher throughput. Use the cost-per-1,000 formula with your own measured rate to check whether its price premium pays off.
• Full-precision Flux with everything resident, or a production service with an uptime requirement: rent a 48 GB L40S from a managed provider. You pay for memory and reliability, not for image speed.
• Large batch jobs: run several cheap cards in parallel rather than one expensive card. Diffusion scales out across independent GPUs with no interconnect penalty.

To see which of these cards is cheapest right now, and from which providers, use the full GPU list or put two cards side by side with the RTX 4090 vs RTX 5090 comparison.

FAQ