Most “best GPU cloud” lists rank providers in a vacuum. Engineers don’t work that way. You’ve got a job to run: a LoRA fine-tune, an inference endpoint, a multi-node pretraining run or a nightly eval in CI, and the right provider depends on which one. This guide starts from the workload, maps each one to the best GPU cloud providers for AI, and ends with the commands to get a GPU up from your terminal.
Prices are on-demand rates per GPU-hour, checked between October 10 and 16, 2026, with the H200 as the main yardstick because it’s the card long-context and bigger fine-tuning jobs now reach for.
The short list
Top of the list is Lium, a GPU rental marketplace that launched as Celium in late 2024. Independent verifiers probe every GPU over SSH before it’s listed and keep re-checking it afterwards, so a low price doesn’t mean an unknown machine. If you only read one table, read this one:
| Rank | Provider | H200 (per GPU-hour) | Billing | Where it wins |
|---|---|---|---|---|
| 1 | Lium.io | From $3.40 | Per second, no minimum | Best price with verified hardware |
| 2 | Modal | About $4.54 | Per second | Python functions that scale to zero |
| 3 | Jarvis Labs | $4.59 | Per minute | Notebooks with pause and resume |
| 4 | RunPod | $5.29 | Per second | Serverless endpoints |
| 5 | Nebius | $5.40 | On-demand list rate | Managed cluster stack |
| 6 | CoreWeave | About $6.31 | 8-GPU nodes | Managed training clusters |
Lium takes the top spot because it’s the cheapest H200 we found, and the cheapest H100 too, and it doesn’t make you trade trust for price. The rest of the table matters too, because the right second choice depends on the job.
Match the provider to the job
Fine-tuning a 7B to 13B model
You need 80GB of VRAM, a few hours of compute and nothing fancy. LoRA or QLoRA on a single H100 handles most models in this range comfortably.
Pick Lium here. At $1.78 per H100-hour, a six-hour fine-tune costs under $11, and per-second billing means you stop paying the second the job exits. If you need more memory for longer context, an H200 with 141GB starts at $3.40 on the same platform.
Serving an LLM endpoint
Serving is a different problem. Traffic is spiky, latency matters, and an idle replica burns money all night.
For a steady, predictable load, a dedicated Lium pod running your own server is still the cheapest per hour. For spiky traffic, RunPod’s serverless endpoints or Modal’s scale-to-zero functions avoid paying for idle replicas, even though their hourly rates are higher. The inference engine matters as much as the provider, which is why we benchmarked TensorRT-LLM against vLLM on an RTX 5090. Pick the engine first, then size the GPU around its throughput.
Multi-node training
Once a model doesn’t fit on one machine, the interconnect decides whether more GPUs actually help. A slow link between nodes can leave expensive GPUs waiting on each other.
Lium’s multi-node clusters run over InfiniBand or RoCE, and the platform measures the link between candidate machines before it offers them as a pair. For very large, long-running clusters with managed orchestration and a support contract, CoreWeave is the benchmark, with 8-GPU HGX H100 nodes at $49.24 an hour and reserved capacity up to 60% cheaper.
Cheap experiments and image models
Not every job needs a data center card. Stable Diffusion, small model training and quick prototypes run fine on consumer GPUs.
On Lium, RTX 4090s start at $0.70 an hour and RTX 5090s at $0.79, against $0.89 and $1.19 on RunPod. For image models and quick prototypes, a 24GB or 32GB consumer card is usually all you need.
Long-context inference and big-batch evals
Long context windows eat memory fast, because the KV cache grows with context length. An 80GB card that’s fine for a 7B model at 8K context can run out of room at 128K.
This is where an H200 with 141GB earns its price.
On Lium it starts at $3.40 an hour, well under Modal’s roughly $4.54 or CoreWeave’s roughly $6.31 per H200, and it often lets you skip the complexity of tensor parallelism across two smaller cards.
Nightly evals and CI jobs
Short, scheduled jobs live or die on billing granularity. A 20-minute eval billed by the hour costs three times what it should.
Per-second billing with no minimum is the feature that matters here, and Lium, RunPod and Modal all have it, while Jarvis Labs bills by the minute. Whatever the platform, set an automatic shutdown or time-to-live where one exists, so a hung job can’t keep a GPU running until morning.
Cost per job, not per hour
Hourly rates hide how much a real job costs. These are a few common jobs, priced at each provider’s published on-demand rate:
| Job | Marketplace (Lium.io) | Specialist cloud | Managed or hyperscaler |
|---|---|---|---|
| LoRA fine-tune, 6 h on 1x H100 | $10.68 | $23.94 (RunPod Secure) | $41.28 (AWS) |
| Eval sweep, 2 h on 1x H200 | $6.80 | $8.94 (DigitalOcean) | $12.62 (CoreWeave) |
| SDXL batch, 3 h on 1x RTX 4090 | $2.10 | $2.67 (RunPod) | Not offered |
| Training run, 24 h on 8x H100 | $341.76 | $766.08 (Lambda) | $1,181.76 (CoreWeave) |
The last row is the one that changes budgets. A day of 8-GPU training ranges from about $342 to almost $1,182 depending on the provider, and that spread compounds over a month of iterations. Short jobs sit much closer together, which is why billing rules matter more than hourly rates for evals.
Spinning up a GPU from the shell
Web consoles are fine, but most of us would rather script it. Most GPU clouds now ship a command-line tool or an API, and the minimal flow looks much the same everywhere:
- Create an account, add credit, and upload your SSH public key.
- Install the provider’s command-line tool. Lium’s, for example, installs with pip install lium.io.
- Request a node by GPU type and count, such as one H100 or eight.
- Set an automatic shutdown or time-to-live if the platform supports one, so the machine goes away whatever happens.
- SSH in, pull your Docker image, and run the job.
- Copy checkpoints to a persistent volume or your own storage before the machine is deleted.
Scripting the flow also makes it portable. The same few steps can run from a CI job, a notebook or a cron entry, and switching provider means changing one command rather than rebuilding the workflow.
Reading a GPU listing like an engineer
On a marketplace, two H100 listings at the same price can be very different machines. The better platforms show enough detail per listing to choose well, and these are the fields I’d check before renting on any of them:
- Uptime, which tells you whether the node has been stable for days or months
- Reliability score, built from the node’s history
- Measured network speed, which matters for pulling large images and datasets
- CPU cores, RAM and disk, because a starved CPU can bottleneck data loading
- Location, for latency and data residency
- Tier, since spot nodes are cheaper but reclaimable
A Helsinki B200 node with more than three months of uptime and a 99% reliability score is a safer bet for a long run than a brand-new listing, even at the same price.
Engineering gotchas
A few things trip people up regardless of which provider they choose:
- Driver and CUDA mismatches. Pin a CUDA base image that matches the host driver.
- Run nvidia-smi before anything else, so you know the GPU count and memory are what you paid for.
- Local disk disappears with the pod. Checkpoints belong on a persistent volume.
- Storage bills separately on most platforms, so budget for volumes and data transfer as well as GPU hours.
- Spot or interruptible nodes are cheaper but can be reclaimed, so only use them for jobs that checkpoint often.
Prices also move faster than they used to. RunPod’s Secure Cloud H100 rose from $3.29 to $3.99 and Lambda’s 8-GPU rate climbed to $3.99 this autumn, according to an October 2026 H100 rental price comparison. Don’t hard-code a provider’s price into your capacity plan.
Where the others still make sense
Every other name in the short list wins a specific job. Modal and RunPod are the serverless specialists, with Modal’s scale-to-zero functions the neater fit for Python-heavy teams and RunPod’s endpoints the easier one for packaged inference APIs. Jarvis Labs suits researchers who live in notebooks and pause often. Nebius and CoreWeave are where you go when a cluster needs a contract, managed orchestration and a support engineer.
Lambda sits outside the H200 table because the card isn’t among its self-serve on-demand instances, but it remains a solid choice for teams that want one familiar vendor, with B200s at $6.69 to $6.99.
Availability is the other constraint across the market. Popular cards go quickly everywhere, and on October 15 even the cheapest platform in this guide had 1,582 of its 1,652 listed GPUs rented. If you need a specific card at a specific time, book early or keep a second provider set up.
Verdict
The best GPU cloud providers for AI are the ones that fit the job. On price, Lium came out ahead for fine-tuning, experiments, CI and cost-sensitive training. RunPod and Modal are the better fit for spiky inference, Jarvis Labs for notebook-driven research, and Nebius or CoreWeave for contracted clusters. Match the provider to the workload, not the other way round, and recheck prices often, because several moved this autumn.
