GPU Cloud Comparison 2026: RunPod, Lambda, CoreWeave, AWS
A practitioner's guide to picking a GPU cloud for training and inference, where hourly rates for the same H100 can differ by 3x.
Key takeaways
- Start on RunPod, where an H100 lists at $2.89 to $3.99 per hour on Secure Cloud as of October 2026.
- Use Vast.ai interruptible for the lowest price on fault-tolerant jobs, Lambda or CoreWeave for multi-node InfiniBand training, and AWS only when compliance or existing data forces it, since a p5 Capacity Block H100 costs about $5.97 per hour.
On this page
Start on RunPod: as of October 2026 its Secure Cloud lists an H100 at $2.89 to $3.99 per hour, and it covers pods and serverless in one account. Use Vast.ai for the cheapest interruptible work, Lambda or CoreWeave for multi-node InfiniBand training, and AWS when compliance or data gravity forces it.
Verified against
RunPod, Lambda, CoreWeave and AWS EC2 Capacity Block list prices, runpodctl v2, against each vendor's public pricing page and the RunPod and vLLM docs. Checked October 2026.
The same H100 lists at about $2 an hour on RunPod's Community Cloud and about $6 on CoreWeave or an AWS Capacity Block. Multiply that across a week-long training run and GPU cloud choice shows up directly on the invoice. Rates move constantly, so every number below is a dated list price, not a quote.
Why the price spread is so large
A GPU-hour is not a commodity. The headline rate bundles the silicon, the interconnect around it, the storage attached, the network out of it, and how much hand-holding the provider does. A hyperscaler charges for compliance, global regions and a support contract. A marketplace like Vast.ai is cheap because you rent someone's idle rig with no SLA. Everything between trades price against reliability.
Compared on what you actually decide on
H100 list prices per GPU-hour, on-demand unless noted, as of October 2026:
| Provider | H100 per GPU-hour | Other GPUs listed | Multi-node interconnect | Serverless option | Best for |
|---|---|---|---|---|---|
| RunPod | $2.89 PCIe, $3.99 SXM (Secure Cloud) | L4 $0.59, L40S $1.09, A100 80GB $1.79, H200 $5.29 | Not compared here | Yes, H100 at $5.39/hr equivalent | Default for indie and startup work |
| Lambda | $3.29 PCIe, $3.99 to $4.29 SXM | A100 SXM 80GB $2.79, GH200 $2.29, B200 $6.69+ | Yes, 1-Click Clusters (16 to 256+ GPUs) | Not a focus | Clean on-demand boxes, reserved clusters |
| CoreWeave | $6.16 (8x HGX instance $49.24) | L40S $2.25, A100 $2.70, H200 $6.31, B200 $8.60 | Yes, Kubernetes-native clusters | Not a focus | Large reserved training |
| Vast.ai | Live marketplace, varies by host | 68+ GPU types | Varies by host | Not a focus | Cheapest interruptible batch |
| AWS (p5) | $5.97 (Capacity Block, us-east-1) | H200 p5en $7.90, B200 $14.21 per accelerator-hour (blocks) | Yes, EFA up to 3,200 Gbps on p5.48xlarge | Via SageMaker | Compliance, regions, existing AWS data |
Two notes on reading it. CoreWeave sells whole 8-GPU instances, so the per-GPU figure is the instance price divided by eight; its spot H100 instance lists at $19.71, about $2.46 per GPU. AWS Capacity Block prices are reservation fees charged up front and are scheduled to change next in January 2027; we covered the two 2026 increases in AWS GPU price increases in 2026.
The players, briefly
RunPod: Developer-friendly and fast to start, with pods (rent a container) and serverless GPU endpoints. Community Cloud runs on vetted third-party hosts and is cheaper than Secure Cloud. The widest range from hobby to production.
Lambda: Built for ML teams. Clear per-GPU on-demand pricing that drops slightly with more GPUs per instance (H100 SXM from $4.29 on 1x to $3.99 on 8x), plus 1-Click Clusters for two-week to one-year terms.
CoreWeave: Built for scale. Kubernetes-native, InfiniBand-connected clusters, where you go for hundreds of tightly wired GPUs. Contract-heavy and priced like it on-demand.
Vast.ai: A marketplace where you rent other people's hardware. Its pricing page says interruptible instances are "50%+ cheaper" and "may be reclaimed". Great for fault-tolerant work, poor for anything that must stay up.
Together AI: Leans toward serverless inference and fine-tuning APIs rather than raw boxes. Convenient when you don't want to manage GPUs at all.
AWS, GCP, Azure: The most expensive per GPU-hour, but unmatched for regions, compliance, IAM and VPC integration. On AWS, p5.4xlarge gives a single H100 and p5.48xlarge eight with 900 GB/s NVSwitch.
What to compare beyond the hourly rate
GPU type: H200 and H100 for large training and high-throughput inference; A100 for mid-size work; L40S and L4 for cost-efficient inference. Match GPU memory to the model footprint first, then throughput.
Pricing model: On-demand for flexibility, reserved for steady load, spot or interruptible for anything that checkpoints. Most teams mix all three.
Availability: The cheapest H100 you cannot provision is worth zero. Marketplaces show capacity live; hyperscalers make you request quota.
Egress and storage: Hyperscalers bill data leaving the network. Neither RunPod's nor Lambda's pricing page lists egress fees, but storage bills even when the GPU is off: RunPod charges $0.10 per GB-month for a running pod's volume and $0.20 when idle.
Interconnect: Past one node, InfiniBand or EFA versus plain Ethernet decides whether a distributed job scales or stalls on gradient sync.
Cold start: For serverless, the time from request to first token after scaling to zero. Fine for batch, painful for chat.
Training and inference want opposite things
Training wants big, tightly networked, long-lived clusters that you reserve and keep saturated; interruptions are tolerable with checkpoints. Inference wants elasticity: scale to zero, spike on traffic, low latency. That is where serverless GPU wins for bursty or low-volume traffic, and where a dedicated box wins once load is steady. If you are picking a serving engine, Ollama vs vLLM covers the throughput side.
Launching a pod and serving a model
RunPod's CLI is runpodctl (not the runpod Python SDK). From the RunPod docs:
$ bash <(curl -sL cli.runpod.io)
$ runpodctl config --apiKey "$RUNPOD_API_KEY"
$ runpodctl pod create --template-id runpod-torch-v21 --gpu-id "NVIDIA RTX 4090"
$ runpodctl pod list
Swap --gpu-id for the GPU you want and check runpodctl pod create --help for volume and port flags. Stop pods you're not using: storage keeps billing, and an idle pod keeps billing GPU time.
Most providers just take a Docker image for serving. The vLLM docs' command for its OpenAI-compatible server:
$ export HF_TOKEN=hf_xxx
$ docker run --runtime nvidia --gpus all \
-v ~/.cache/huggingface:/root/.cache/huggingface \
--env "HF_TOKEN=$HF_TOKEN" \
-p 8000:8000 \
--ipc=host \
vllm/vllm-openai:latest \
--model Qwen/Qwen3-0.6B
$ curl -s localhost:8000/v1/models
Because the endpoint speaks the OpenAI API, moving between a rented GPU and a hosted API becomes a base-URL change rather than a rewrite.
Failure modes that cost real money
CUDA out of memoryon a cheaper GPU: the model doesn't fit. Use a larger-memory card or quantize; don't just shrink the batch until throughput collapses.- No capacity for the GPU you picked: top-tier capacity is regional and spiky. Keep a second region or provider configured.
- Interrupted spot or marketplace job with no checkpoint: you pay for every hour up to the interruption and keep nothing. Checkpoint to persistent storage on a timer.
- Re-downloading weights on every cold start: mount a persistent or network volume for the Hugging Face cache.
- Forgotten idle pods: the most common surprise bill. Put a TTL or an auto-stop on dev pods.
Where this breaks
List prices are only a starting point. Committed contracts from CoreWeave, Lambda and the hyperscalers are negotiated, and a large commitment can undercut every number in the table. Marketplace prices change hourly. And if your data already sits in S3 under strict compliance controls, egress and audit costs can outweigh a cheaper GPU-hour elsewhere.
Questions people ask
What is the cheapest GPU cloud for an H100 in 2026?
Among fixed list prices checked in October 2026, RunPod Secure Cloud is lowest at $2.89 per hour for an H100 PCIe, with Lambda at $3.29. Vast.ai's marketplace and interruptible instances can go lower, with no reliability guarantee. CoreWeave on-demand ($6.16) and AWS Capacity Blocks ($5.97) sit at the top of the range.
Is RunPod or Lambda better for training?
For a single node, either works and RunPod is usually cheaper per hour. For multi-node training, Lambda is the stronger pick because its 1-Click Clusters give you 16 to 256+ interconnected H100 or B200 GPUs on fixed terms, priced per GPU-hour. RunPod is better suited to single-node work, experiments and serverless inference.
Is serverless GPU cheaper than renting a GPU by the hour?
For bursty or low-volume inference, yes, because you pay only while requests run instead of for a box idling at low utilization. For steady high load, no: RunPod lists serverless H100 at about $5.39 per hour equivalent versus $2.89 to $3.99 for a pod. By those list prices, the break-even sits at roughly 55% to 75% sustained utilization.
The call we'd make
Start on RunPod: it covers the widest range of needs, the pricing is public, and you can go from one hobby pod to serverless inference without changing vendors. Reach for Vast.ai interruptible when you want the absolute floor and can tolerate reclaimed hosts. Move to Lambda clusters or CoreWeave only for multi-node training that needs the interconnect. Save the hyperscalers for compliance, region or data gravity. For the wider stack this fits into, see the best LLM APIs and AI infrastructure.
Sources
Cite this article
Kiril Urbonas (2026). GPU Cloud Comparison 2026: RunPod, Lambda, CoreWeave, AWS. DevOpsNess. Updated 2026-10-31. https://www.devopsness.com/blog/gpu-cloud-comparison
[GPU Cloud Comparison 2026: RunPod, Lambda, CoreWeave, AWS](https://www.devopsness.com/blog/gpu-cloud-comparison) (Kiril Urbonas, DevOpsNess, updated 2026-10-31)
More from AI
Explore more articles in this category
vLLM vs SGLang vs TGI vs TensorRT-LLM: Which LLM Server in 2026
Hugging Face TGI is archived and read-only, so the real 2026 choice is vLLM, SGLang or TensorRT-LLM. A feature table, a launch command for each, and the one we default to.
Monitoring ML Models in Production: Data, Concept and Prediction Drift, With Code
Three kinds of drift, two tests that catch most of it, one Prometheus exporter, and the alert rules that do not page you every Monday morning.
MLOps Tools in 2026: 7 Platforms Compared, and the Stack We'd Pick
MLflow, Kubeflow, Weights & Biases, SageMaker, Vertex AI, ZenML and Metaflow compared on tracking, registry, pipelines, serving, self-hosting and pricing, with a default stack for each team size.
You might have missed
Evergreen posts worth revisiting.