GPU VPS for LLMs: Rent, Buy, or Don't Bother?

Almost every guide to GPU hosting for LLMs answers the wrong question. They compare cards, list providers, and tell you an A100 has 80GB of VRAM — all true, all beside the point.

The variable that decides your bill isn’t the card. It’s how many hours a day the GPU is actually doing work. Rent an RTX 4090 for an hour a day and you’ll spend about $10 a month. Leave the same instance running around the clock and it’s $245. Same card, same provider, 24× the invoice — and the difference is entirely down to whether you remember to shut it down.

This article is about that decision: rent by the hour, commit to a month, go serverless, or buy hardware. If you need the sizing arithmetic instead — how much VRAM a given model and context length requires — that’s covered properly in our vLLM GPU hosting guide. And if you haven’t yet established that you need a GPU at all, start with our Ollama VPS comparison, because a surprising number of people don’t.

What GPUs actually cost per hour

Checked August 2026. The 4090 range spans marketplace spot pricing at the low end to vetted-datacenter pricing at the high end; across the whole market, 4090 rates have been observed from $0.12 to $1.61/hour depending on provider and interruption risk.

Note how wide those ranges are. An A100 costs between $1.39 and $3.43 an hour depending purely on where you rent it — a 2.5× spread for identical silicon. That’s not a quality difference, it’s a difference in whether the instance can be reclaimed out from under you.

The hyperscalers are a different market entirely

The table above samples marketplace and boutique GPU clouds. Priced against the hyperscalers, the H100 spread is far wider than 2.5×:

That’s an 8× spread on identical silicon, and it dwarfs the marketplace variation the rest of this article is about.

The practical trap is the node size, not the rate. You generally cannot rent a single H100 from a hyperscaler — the unit of sale is an eight-GPU node. So the smallest H100 purchase on AWS P5 is $55.04 an hour, whatever your workload needs. If you want one H100 for an evening, the hyperscalers are not selling that product, and the per-GPU-hour column above is a normalisation rather than a price you can pay.

Where hyperscaler pricing is the right answer is when you need eight GPUs with fast interconnect for distributed training, or the surrounding platform and committed-use discounts matter more than the sticker rate. For single-GPU inference, it isn’t close.

The only table that matters

Here’s the same RTX 4090 at RunPod’s two tiers, priced by how much you actually use it:

Two conclusions fall straight out of this.

First, intermittent GPU use is remarkably cheap. If you’re fine-tuning occasionally, batch-processing documents overnight, or experimenting for a couple of hours in the evening, you’re looking at $10–40 a month for a card that costs well over a thousand dollars to buy. This is the case where renting is obviously correct.

Second, always-on is where the money goes, and it’s the mode most people accidentally end up in. A forgotten instance bills identically to a busy one. Per-second billing — which RunPod and several others now use — helps only if you actually stop the pod. If the GPU genuinely is going to run around the clock, a dedicated monthly server usually beats any hourly marketplace: RunPod vs Hetzner for Ollama compares the same 96GB RTX PRO 6000 on both and finds the dedicated box 35% cheaper per month.

And be aware that on most providers stopping isn’t enough: a stopped instance keeps billing for reserved compute, storage and IP allocations until it’s destroyed. Our hourly billing guide quotes the policies and lists what keeps charging while a server is switched off.

Before you pick a provider, work out honestly which row you’re in. Most people estimate high: they imagine constant use and buy for that, then use the thing four hours a week.

Rent or buy? The break-even in hours

The buy-your-own-card argument is seductive and occasionally correct. Here’s how to check it without guessing at hardware prices, which move constantly.

Divide the purchase price of the card by the hourly rental rate. That gives you the number of rental hours the purchase is worth:

• At $0.34/hour, a $1,000 card equals about 2,940 rental hours
• At $0.69/hour, a $1,000 card equals about 1,450 rental hours

Now convert to your usage:

And that’s before the costs that don’t appear on the sticker. A 4090 under sustained load draws roughly 350–450W; at 24/7 that’s around 290 kWh a month, which at typical residential rates adds tens of dollars monthly. You also inherit the failure risk, the noise, the heat, and a machine that has to be online for your service to be.

The rule of thumb: buying starts to make sense somewhere above eight to twelve hours a day of genuine utilization, and only if you’re keeping the card for years. Below that, renting wins comfortably. Above 24/7 production load, look at monthly-committed dedicated hosting rather than hourly rates, which is where providers like Liquid Web are priced to compete.

Spot, on-demand, or serverless

Three billing models, three different risk profiles.

Spot / interruptible / community instances are 30–60% cheaper and can be reclaimed when demand spikes. For batch work that can checkpoint and resume — fine-tuning, bulk document processing, experimentation — this is free money. For anything a user is waiting on, an instance that vanishes mid-request is unacceptable.

On-demand / secure costs roughly double and stays up. This is what you want behind anything user-facing.

Serverless bills per request rather than per hour, scaling to zero between calls. For genuinely bursty traffic — a handful of requests an hour — this can beat both, because you pay nothing while idle. The trade is cold starts: loading a multi-gigabyte model into VRAM takes time, and your first request after a quiet period pays for it.

The decision rule is simple arithmetic: if your GPU would sit idle more than about half the time, serverless or spot is likely cheaper. If it’s busy most of the time, a dedicated instance is cheaper and more predictable.

The seven providers worth using

1. RunPod — the default for hourly GPU work

RTX 4090 at $0.34/hour on Community Cloud, $0.74/hour on Secure Cloud. A100 PCIe $1.39/hour, H100 PCIe $2.89/hour. Billed per second.

RunPod is the provider we’d point most people at, for a specific reason: the two-tier structure lets you match spend to risk without changing platforms. Develop and experiment on Community Cloud at half the price, then move the production endpoint to Secure Cloud in vetted datacentres when it matters.

Per-second billing is the other thing that makes it suit this use case. A job that takes eleven minutes costs eleven minutes, not an hour. Combined with templates for the common inference stacks, it’s the lowest-friction way to get a GPU for an afternoon.

The caveat is the one that applies to all marketplace-style capacity: Community Cloud instances live on third-party hardware with variable host quality and no guarantee your preferred GPU is available in your preferred region right now.

Check RunPod pricing → · Read our RunPod review

2. Vast.ai — cheapest, if you’ll do the work

Vast.ai is a true marketplace: individuals and datacentres list spare GPUs and you bid. RTX 4090 capacity commonly sits around $0.35–0.50/hour on interruptible instances, and the floor across the market goes lower still.

You get the lowest prices available anywhere. You also get to evaluate hosts yourself — reliability scores, bandwidth, storage speed and the operator’s track record all vary enormously, and a cheap host with poor network throughput will cost you more in wasted time than you saved. There’s no support organisation to escalate to.

Right for experimentation and cost-sensitive batch work by someone willing to manage it. Wrong for production.

“Prices set by supply and demand” is the whole model — rates move, and the cheap ones are interruptible.

We don’t have an affiliate relationship with Vast.ai; it’s here because it genuinely holds the price floor.

3. Liquid Web — dedicated GPU, not virtualized

NVIDIA L4 Ada 24GB at around $1.07/hour, L40S Ada 48GB at around $1.92/hour, plus H100 NVL 94GB. Discounts of roughly 25% appear on committed terms.

Liquid Web’s GPU line is the alternative for the always-on case, and the pitch is that the hardware is genuinely dedicated rather than a virtualized slice — dual EPYC processors, DDR5, NVMe RAID-1, unlimited inbound and 10TB outbound bandwidth. No noisy neighbours competing for PCIe bandwidth or host memory.

The hourly rate looks poor against RunPod Community. That comparison is misleading if you’re running 24/7: at that duty cycle you’re buying predictable dedicated performance and a support contract, and committed pricing narrows the gap considerably. The L40S at 48GB is a genuinely useful capacity point — it clears 30B-class quantized models that a 24GB card can’t hold.

“Single-tenant” is the distinction being sold here — no sharing the host with another tenant’s job.

Check Liquid Web GPU hosting → · Read our Liquid Web review

4. DigitalOcean — GPU Droplets with the usual platform

DigitalOcean added GPU Droplets to the platform many teams already run on, which is the main argument for using them: the same API, the same networking, the same billing, the same Spaces buckets and managed databases your application already talks to.

You’ll pay more per GPU-hour than a marketplace charges. If the GPU is one component of an application you already run on DigitalOcean, the integration is often worth more than the difference. If the GPU is the whole workload, it isn’t.

Check DigitalOcean pricing → · Read our DigitalOcean review

5. Lambda — built for people who train

Lambda specialises in AI compute and is generally priced competitively on A100 and H100 capacity, with multi-GPU nodes and fast interconnect for distributed work. If you’re training or fine-tuning rather than just serving, the hardware topology matters and Lambda is built around it.

For single-GPU inference it’s more machine than most people need. Availability on popular configurations can also be tight.

No affiliate relationship here.

6. Jarvislabs — A100 with per-minute billing

Jarvislabs offers on-demand A100 80GB at around $1.49/hour with per-minute billing, no commitment and no minimum rental period — notable because $1.49 sits near the bottom of the A100 range while remaining on-demand rather than interruptible.

If your workload specifically needs 80GB of VRAM in bursts — a 70B quantized model you query occasionally — this billing model fits unusually well. Smaller operation, thinner ecosystem.

No affiliate relationship here either.

7. Serverless platforms — Modal and Replicate

Both remove the instance from the equation: you deploy a function or a model and they bill per request, scaling to zero when idle.

For low, spiky volume this is frequently the cheapest option available, because idle time costs nothing. It’s also the least operational work by a wide margin. The costs are cold starts on the first request after a quiet spell, less control over the runtime, and per-request pricing that becomes expensive at sustained volume — the crossover point where a dedicated instance wins is usually lower than people expect.

When you shouldn’t rent a GPU at all

Worth stating plainly, because it applies to more readers than the rest of this article: for most people, a commercial API is cheaper than self-hosting on a rented GPU.

The reason is utilization. A hosted API bills per token — you pay for exactly the work you do. A rented GPU bills per hour whether you use it or not, and it takes a substantial, steady query volume before amortising a $245/month always-on 4090 across your tokens beats simply paying per token to a provider running their cards at near-100% utilization across thousands of customers.

Self-hosting on a GPU wins when you have one of these, and mostly not otherwise:

• Data that can’t leave your infrastructure — regulatory, contractual or otherwise. This is the strongest reason and it doesn’t depend on economics at all.
• Genuinely high, steady volume that keeps the card busy.
• A fine-tuned or unusual model no API serves.
• Predictable flat costs as a business requirement.

If your reason is “it’ll be cheaper,” check that against the table above before you commit. Our vLLM guide works through the break-even against hosted API pricing in more detail.

How we picked

We prioritised providers that publish hourly rates, bill at fine granularity, and are realistically accessible to an individual or small team rather than requiring an enterprise contract. Prices were checked in August 2026 from provider pricing pages and published comparisons.

On the hyperscaler table specifically, treat the figures as indicative rather than quoted. The node rates — AWS p5.48xlarge at $55.04/hour, Azure ND96isr H100 v5 at about $98.32 and GCP a3-highgpu-8g at about $87.84 — come from third-party pricing aggregators and published comparisons rather than from AWS, Azure and Google’s own calculators, which we did not query directly. The per-GPU-hour and monthly columns are our arithmetic on those node rates. The GCP figure is the least reliable: sources we consulted disagreed substantially, with one putting A3-series capacity as low as $3.35 per GPU-hour, which likely reflects a different A3 variant or committed-use pricing. Hyperscaler GPU pricing also varies by region and is frequently discounted under commitments, so a list rate is close to a worst case. The direction of the finding — that hyperscaler on-demand H100 capacity costs several times marketplace capacity, and is sold in eight-GPU units — is robust; the specific decimals are not.

We have not benchmarked throughput on these providers ourselves, and we’d be cautious about anyone claiming they have across this many platforms — GPU performance varies with host hardware, driver versions and neighbours, particularly on marketplace capacity. The hourly rates are verifiable; tokens-per-second claims are much less so.

GPU hosting is a market where we have few affiliate relationships — four of the seven providers here earn us nothing, and RunPod, Liquid Web and DigitalOcean are the exceptions. We’ve ordered on merit for the use case.

FAQ

What’s the cheapest GPU that runs a useful LLM?

An RTX 4090 with 24GB of VRAM, at roughly $0.34–0.69/hour. That holds 7B–13B class models comfortably at 4-bit quantization with room for context, which covers the large majority of self-hosted inference. Below 24GB you’re constrained to small models or short contexts.

How much does it cost to run an LLM on a GPU 24/7?

At the low end, about $245/month for an RTX 4090 on interruptible capacity. On vetted on-demand infrastructure, closer to $500. An A100 80GB running continuously is roughly $1,000–2,500/month depending on provider and interruption tolerance.

Is it cheaper to buy a GPU than rent one?

Only above roughly eight to twelve hours per day of sustained use, and only if you keep the card for years. At two hours a day, a $1,000 card takes about four years to pay back against $0.34/hour rental — before electricity, which adds meaningfully at high duty cycles. Renting also means you can move to a bigger card next month.

What’s the difference between spot and on-demand GPU instances?

Spot (also called interruptible or community) capacity is 30–60% cheaper and can be reclaimed when demand rises. On-demand costs more and stays up. Use spot for anything that can checkpoint and resume, and on-demand for anything a user is waiting on.

Can I run a 70B model on a single GPU?

At 4-bit quantization, yes — a 70B model needs roughly 40GB for weights, so an 80GB A100 or H100 holds it with room for KV cache. At full FP16 precision it needs around 140GB, which means multiple cards. Our vLLM sizing guide covers the arithmetic including context length.

Do I need a GPU to run Ollama?

No, and many people shouldn’t. Small quantized models run acceptably on a normal CPU VPS if you can tolerate a few tokens per second — fine for background and batch work, frustrating for interactive chat. Our Ollama VPS guide draws the line between the two cases.