ComfyUI Cloud 2026: Run Stable Diffusion on RTX 5090 or H100

You want to run ComfyUI in the cloud to generate SDXL or Flux.1 images at scale, faster than your local GPU and without burning your own hardware 24/7. There are two ways to do it: pay for Comfy Cloud, the hosted service from the ComfyUI team, or run ComfyUI yourself on a rented GPU. On Spheron, you can provision an RTX 5090 at $0.84/hr or an H100 at $2.64/hr on demand, run your generation jobs, and shut everything down when you're done.

TL;DR: ComfyUI Cloud on a Rented RTX 5090 or H100

• Two options: Comfy Cloud (hosted, from $20/month, about $4.54 per active GPU-hour on an RTX PRO 6000 as of 20 Oct 2026) or your own ComfyUI on a rented GPU.
• Price: Spheron RTX 5090 runs $0.84/hr on-demand; the cheapest H100 is $2.64/hr, as of 17 Sep 2026.
• Cost per image: at 13 Mar 2026 rates, SDXL cost about $0.033 per 100 images on RTX 5090 versus $0.080 on H100 PCIe.
• VRAM ceiling: Wan 2.1 14B and HunyuanVideo at 720p need 40GB+ even in FP8, past the RTX 5090's 32GB.
• Verdict: RTX 5090 for SDXL and Flux.1 Dev FP8, H100 for video, Comfy Cloud for light use. An RTX 4090 GPU rental is close on cost per image.

Why RTX 5090 vs H100 Is the Comparison That Matters

The interesting comparison in 2026 isn't H100 vs A100. It's RTX 5090 vs H100 PCIe. These two GPUs have surprisingly similar memory bandwidth: GDDR7 at 1,792 GB/s vs HBM2e at 2,000 GB/s, an 11% gap. But the hourly rate gap is much wider (2.6x at the 13 Mar 2026 rates). For diffusion model inference, which is largely memory-bandwidth-bound, that math matters a great deal.

Here's a benchmark of both GPUs in ComfyUI, a complete Docker setup guide, and a framework for deciding which GPU fits your workflow. For a broader GPU decision guide covering every tier from RTX 4090 to H200 with VRAM requirements for SD 1.5, SDXL, Flux.1, and Flux.2, see best GPU for AI image generation in 2026. If you're serving language models rather than diffusion, best GPU for AI inference in 2026 applies the same cost-per-output framework to LLMs.

Why Cloud GPU for ComfyUI?

Consumer GPUs top out at 24GB VRAM (without the RTX 5090 or RTX PRO 6000 GPU rental). That's enough for SDXL and Flux.1 in FP8, but tight when you add ControlNets, run batch generations, or experiment with Flux.1 Dev in BF16. Most video generation models need 60-80GB and are completely out of reach on local hardware.

Speed is the second reason. A cloud H100 or RTX 5090 generates images significantly faster than a consumer RTX 3090 or 4080. If you're doing a batch run of 1,000 images for a project or testing 50 workflow variations, that throughput difference turns hours into minutes.

The third reason is flexibility. Your local machine is for other work. A cloud GPU instance runs your generation job overnight, you download the output in the morning, and you pay only for the time it was actually running. No idle hardware cost, no thermal throttling from a machine running hot for 8 hours, no interrupting your primary workstation.

Always-on workloads that used to require owning dedicated hardware (running a custom image generation API, generating training datasets, processing client projects) now cost exactly what you use and nothing more.

ComfyUI's entire node graph runs on PyTorch under the hood, which is one reason custom nodes and new model architectures land in the ecosystem so fast. If you're wondering why diffusion tooling gravitated toward PyTorch instead of TensorFlow, the PyTorch vs TensorFlow comparison covers the ecosystem and research-adoption reasons behind that split.

Comfy Cloud vs Running ComfyUI on a Rented GPU

Search "ComfyUI cloud" and the first results are Comfy Cloud, the official hosted version from Comfy Org. It is a fair product and worth comparing honestly, because the right answer depends on how many hours a month you actually generate.

Comfy Cloud runs every plan on an RTX PRO 6000 with 96GB of VRAM and only charges credits while a workflow is executing, so building a graph costs nothing. The published Comfy Cloud plans as of 20 Oct 2026:

Comfy does not print a per-minute credit rate for subscription plans, but its API deployments list the same RTX PRO 6000 at $4.54/hr, or 957.94 credits per hour. If subscription credits burn at that rate, Standard buys about 4.4 GPU-hours a month, Creator about 7.7 and Pro about 22. All three work out to roughly $4.54 per active GPU-hour.

The split is simple. If you generate a few hours a month and use mainstream nodes, Comfy Cloud is less work and the idle-time-is-free billing helps. If you run long batches, need a niche custom node, or want to serve a workflow as an API around the clock, a rented GPU costs a fraction per hour and has no job-length cap. The rest of this guide covers the second path.

GPU Comparison for ComfyUI: RTX 5090 vs H100 vs RTX 4090

For image generation workloads, memory bandwidth is the primary bottleneck. Diffusion models at inference time repeatedly load large weight tensors and activations from memory; the GPU's compute units often sit waiting for data rather than computing. This is why the RTX 5090's GDDR7 bandwidth matters for ComfyUI.

Spheron prices below are live from the marketplace as of 17 Sep 2026. Pricing fluctuates over time based on market supply and demand, check current GPU pricing for live rates before planning production workloads.

The H100 rate shown is the lowest on-demand H100 currently listed, which is usually the PCIe variant; SXM usually costs more. Spot tiers come and go per GPU, so check the pricing page for which are live today.

The RTX 5090 vs H100 PCIe nuance: The bandwidth gap is only ~11%. That translates to roughly 10-15% fewer images per minute on the RTX 5090 compared to H100 PCIe for SDXL and Flux.1. But the cheapest on-demand H100 costs $2.64/hr against $0.84/hr for the RTX 5090.

Result: at the 13 Mar 2026 rates ($0.76/hr vs $2.01/hr), the RTX 5090 delivered typical SDXL and Flux.1 images at roughly 40% of the H100 PCIe's cost per image. Unless you need the H100's 80GB VRAM for video models or very large ControlNet stacks, the RTX 5090 wins on cost efficiency.

The H100 SXM is the speed champion with 3,350 GB/s HBM3 bandwidth, nearly double the RTX 5090's. H100 spot capacity (from $2.21/hr for the cheapest variant listed) suits throughput-intensive workloads where you can tolerate preemption; spot capacity can be reclaimed without notice. At the on-demand rate, the math shifts back toward the RTX 5090 for most image generation use cases. For a deeper look at NVL, SXM5, and PCIe tradeoffs across both LLM and diffusion workloads, see our H100 form factor guide.

For detailed RTX 5090 specs and LLM inference benchmarks, see our complete RTX 5090 rental guide.

VRAM Requirements by Model

The 32GB VRAM on the RTX 5090 covers most ComfyUI workflows. Here's what actually fits:

For FLUX.2 (the 32B DiT successor with true-text rendering), see Deploy FLUX.2 on GPU Cloud for updated VRAM requirements and quantization options.

The main limitation of the RTX 5090 for ComfyUI is video generation: Wan 2.1 requires approximately 60-70GB VRAM (BF16, with model offloading) and HunyuanVideo requires at least 60GB (80GB recommended); neither will run on 32GB. For those models, H100 PCIe (80GB) is the minimum viable option.

For broader VRAM requirements across diffusion and LLM models, see our GPU requirements cheat sheet for 2026.

Benchmark Results: Images Per Minute

These benchmarks reflect ComfyUI community data for standard workflows. Test configuration: ComfyUI with xFormers enabled, batch size 1, Ubuntu 22.04, CUDA 12.4. Throughput numbers are approximate; results vary with driver version, CUDA version, and system configuration. Cost columns in both tables are a worked example at the Spheron rates recorded on 13 Mar 2026: RTX 5090 $0.76/hr, H100 PCIe $2.01/hr, H100 SXM $2.50/hr on-demand and $0.80/hr spot, RTX 4090 $0.58/hr. Live rates are in the GPU table above.

SDXL 1024×1024, 20 steps:

Flux.1 Dev 1024×1024, FP8, 20 steps:

For SDXL, the RTX 5090 ($0.033/100 images) and RTX 4090 ($0.035/100 images) are close in cost efficiency because the speed improvement is roughly proportional to the price difference. The RTX 5090's advantage for SDXL is throughput speed (38 vs 28 img/min), better for time-sensitive workflows, and the ability to run larger, more complex setups thanks to its 32GB VRAM.

For Flux.1 Dev FP8, the RTX 5090 becomes more compelling: $0.055 per 100 images vs $0.064 for the RTX 4090 (faster and cheaper) and $0.124 for H100 PCIe (2.25x cheaper). The H100 SXM on Spot at ~$0.035 offers the best price-for-speed when availability permits.

Key takeaway: for cost-conscious image generation teams running SDXL and Flux.1, the RTX 5090 offers strong value at on-demand pricing. H100 PCIe is the premium option when your workflow exceeds 32GB VRAM, not before.

Step-by-Step Setup: ComfyUI on Spheron

Step 1: Launch a GPU instance

On Spheron, go to the GPU catalog and select RTX 5090 or H100 PCIe. Choose Ubuntu 22.04 as your OS. Do not open port 8188 in the network settings. ComfyUI has no built-in authentication, so exposing it publicly would let anyone on the internet access your instance. You will access it securely via an SSH tunnel instead (Step 4).

Step 2: Pull and run the ComfyUI Docker image

SSH into your instance, then run:

# Using latest-cuda pulls the most recent CUDA-enabled build of the ai-dock/comfyui image.
# This tag is a floating tag; the image author can push updates to it at any time.
# For a stronger supply-chain guarantee, pin by digest instead of tag:
#   docker pull ghcr.io/ai-dock/comfyui:latest-cuda
#   docker inspect --format='{{index .RepoDigests 0}}' ghcr.io/ai-dock/comfyui:latest-cuda
# Then replace the IMAGE value below with the returned sha256 digest reference.
# Check https://github.com/ai-dock/comfyui/pkgs/container/comfyui for available tags.
IMAGE=ghcr.io/ai-dock/comfyui:latest-cuda

docker pull $IMAGE

docker run -d \
  --gpus all \
  --ipc=host \
  -p 127.0.0.1:8188:8188 \
  -v ~/comfyui-models:/opt/ComfyUI/models \
  -v ~/comfyui-output:/opt/ComfyUI/output \
  $IMAGE

The -v flags persist your model files and outputs across container restarts. --ipc=host is required for the shared memory that PyTorch uses internally.

Step 3: Download models

# Create model directories
mkdir -p ~/comfyui-models/checkpoints ~/comfyui-models/vae

# Download SDXL base checkpoint (~6.5GB)
wget -O ~/comfyui-models/checkpoints/sd_xl_base_1.0.safetensors \
  https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors

# Download Flux.1 Dev FP8 (~11GB) from community repo (no auth required)
# The official black-forest-labs/FLUX.1-dev repo contains only the BF16 weights.
# FP8-quantized checkpoints are provided by the community via Kijai/flux-fp8.
pip install huggingface_hub
huggingface-cli download Kijai/flux-fp8 \
  --include "flux1-dev-fp8-e4m3fn.safetensors" \
  --local-dir ~/comfyui-models/checkpoints

For the BF16 variant (flux1-dev.safetensors), you need a HuggingFace account and must accept the model license at huggingface.co/black-forest-labs/FLUX.1-dev before downloading from the official repo.

Step 4: Access ComfyUI via SSH tunnel

Because ComfyUI has no built-in authentication, you access it through an SSH tunnel rather than opening the port directly to the internet. Run this on your local machine:

ssh -L 8188:localhost:8188 user@your-server-ip

Replace user with your instance username and your-server-ip with the public IP shown in the Spheron dashboard. While the tunnel is open, navigate to http://localhost:8188 in your browser. The ComfyUI node graph interface will load. Traffic is encrypted in transit and the port is never exposed publicly.

Step 5: Load a workflow and generate

ComfyUI uses workflow JSON files. Load one by dragging a .json file onto the canvas, or use the Load button in the top menu. Community workflow sources include comfyworkflows.com and OpenArt.ai. The ai-dock container includes a default SDXL txt2img workflow to get you started immediately.

Optimizing ComfyUI Speed on Cloud GPU

Enable FP8 for Flux.1

Use the FP8 checkpoint loader node instead of the standard CheckpointLoaderSimple for Flux.1. FP8 native Tensor Core support is available on NVIDIA's 4th-generation Tensor Cores, present in both Hopper (H100) and Ada Lovelace (RTX 4090, L40S) architectures, and continues with Blackwell's 5th-generation (RTX 5090). All three GPUs in this comparison accelerate FP8 inference in hardware. This reduces VRAM usage by ~40% and speeds up generation compared to BF16. The RTX 5090 additionally supports FP4 (Blackwell-only), but current ComfyUI and Flux.1 tooling does not use FP4 yet. Load your flux1-dev-fp8-e4m3fn.safetensors file directly; no conversion needed.

Use TAESD for live previews

Tiny AutoEncoder for SD (TAESD) generates preview images in ComfyUI's node graph during generation without decoding the full VAE at each step. This significantly speeds up preview refresh and reduces VRAM pressure during long generations. Add a TAESDDecode node and connect it to the latent output of your sampler.

Set high VRAM mode

In ComfyUI settings (gear icon → top right), enable "Force High VRAM" mode. This keeps model weights loaded in VRAM between generation runs rather than unloading them. On RTX 5090 and H100 with dedicated VRAM, this eliminates per-run model loading overhead and meaningfully speeds up sequential generation.

Tile large images

For outputs above 1024×1024, use tiled VAE decode to avoid VRAM spikes during the final decode step. The VAEDecodeTiled node splits the latent into tiles, decodes them separately, and stitches the result. This enables 2048×2048 and larger outputs on 32GB VRAM without running out of memory.

Batch generation

Use the KSampler node's batch size parameter to generate multiple images per run. Batching is significantly more GPU-efficient than sequential single-image runs because it amortizes model loading and CUDA kernel launch overhead. On an RTX 5090, a batch of 4 images takes roughly 2.5x the time of a single image (not 4x), so throughput per hour increases substantially.

Video Generation on Cloud GPU

Most video generation models in ComfyUI need 60GB+ VRAM at standard quality settings, well beyond the RTX 5090's 32GB. For video workflows, H100 PCIe or H100 SXM is the minimum practical option.

AnimateDiff and CogVideoX-5B are workable on the RTX 5090 for short clips. For Wan 2.1 or HunyuanVideo (the models generating the most visually impressive results for video in 2026), you need H100 PCIe's 80GB, which makes the H100 the default pick for video generation workloads.

For a dedicated ComfyUI + WanVideoWrapper setup guide with cost per clip breakdowns, see Deploy Wan 2.1/2.2 for AI Video Generation.

For production image editing setups using diffusers and FastAPI rather than ComfyUI, see deploying open-source image editing models on GPU cloud, which covers Qwen-Image-Edit, OmniGen 2, and FLUX.1 Kontext with benchmark data.

Cost Comparison: Running ComfyUI on Spheron vs Runpod vs Local

Spheron rows are a worked example at rates recorded on 13 Mar 2026; third-party rates are as published on that date. GPU pricing fluctuates over time based on supply and availability; verify current rates on the pricing page before planning production workloads.

The local machine cost assumes $0.12/kWh electricity with a 450W load and excludes hardware amortization. Factor in GPU purchase cost and it changes the math significantly for infrequent workloads.

For occasional large batch jobs (1,000-10,000 images for a project), cloud GPU is generally cheaper than owning hardware when you account for idle time. If you're generating images 8+ hours per day continuously, local hardware starts to compete on total cost.

Spheron's RTX 5090 runs $0.84/hr, against Runpod's RTX 4090 at ~$0.69/hr (Secure Cloud; Community Cloud starts at $0.34/hr), and delivers 36% faster generation and 8GB more VRAM. For teams currently on Runpod's RTX 4090 for image generation, Spheron's RTX 5090 gives you meaningfully better throughput.

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

For a full comparison between Spheron and Runpod across GPU options and features, see our Spheron vs Runpod comparison.

Run ComfyUI on Spheron's RTX 5090 or H100: deploy in minutes, no monthly subscriptions, shut down when your generation job is done.

Get an RTX 5090 for ComfyUI →