LLM Self-Hosting Break-Even Guide

Q: How do I calculate the self-hosting break-even point?

Divide your monthly self-hosting cost (GPU rental × ops overhead) by the blended API price per token. Example: a rented H100 at $2,109.70 a month against GPT-5.6 Terra's $5.00 per 1M blended gives 2,109.70 ÷ 5.00 ≈ 422M tokens a month at 1× ops overhead. Above that volume the rig is cheaper — provided it also has the capacity to serve it.

Q: What does ops overhead mean and why multiply by it?

The GPU price is not the total cost of self-hosting: you also pay in engineering hours, monitoring, upgrades and redundancy. The overhead multiplier folds that into the comparison — 1× for a hobby box someone maintains for fun, 2–3× for a production service, up to 5× when you need on-call cover and an SLA.

Q: How many tokens per month can one rented GPU serve?

Capacity = tokens per second × utilization × 2,592,000 seconds in a 30-day month. A single H100 running Llama 3.3 70B in FP8 at about 1,500 aggregate tokens per second and 60% utilization produces roughly 2.33 billion tokens a month. A consumer RTX 4090 running an 8B model at 100 tokens per second manages about 155 million.

Q: Should I buy a GPU instead of renting one?

Rent first. Buying an H100 costs roughly $25,000–$30,000 up front plus power and hosting, and it only beats renting if you keep it busy for years — while model and hardware generations keep moving underneath you. Renting turns the decision into a monthly number you can compare directly against the API bill, which is exactly what the break-even formula does.

By the TokenForge team · Last updated July 2026

At some monthly token volume, renting a GPU and running an open-weights model becomes cheaper than paying per token. This guide gives you the formula for finding that point, the six factors that move it, and three worked examples with July 2026 prices — including the case where self-hosting never wins.

The break-even formula

break-even tokens/month = monthly self-hosting cost ÷ blended API cost per token
in millions: break-even (M) = (GPU $/month × ops overhead) ÷ blended API $ per 1M
capacity check: capacity (M) = tokens/sec × utilization × 2,592,000 ÷ 1,000,000

Two conditions must hold before self-hosting wins. First, your volume must sit above the break-even point — below it, you're paying rent on idle silicon. Second, your volume must sit below the server's capacity — above it, you need more servers, and the math starts over with a bigger denominator. The zone where self-hosting makes sense is the band between those two lines.

The six factors that move the break-even

Factor	What it is	How it moves the break-even
Blended API price	(4 × input + output) ÷ 5 at your traffic mix	Pricier API → break-even drops, self-hosting wins sooner
GPU cost per month	Rental $/hr × 730, or a dedicated monthly box	Cheaper GPU → break-even drops
Throughput	Aggregate tokens/sec under real load (e.g. Llama 3.3 70B FP8 on one H100 ≈ 1,500 tok/s)	Sets the capacity ceiling, not the break-even itself
Utilization	Share of the month the GPU does useful work	You pay 24/7 — idle hours raise your true cost per token
Ops overhead	Engineering, monitoring, redundancy: 1× hobby → 5× SLA	Multiplies the self-hosting side; honesty here decides the answer
Quality gap	Open-weights model vs the hosted frontier model	Not in the formula — if quality fails your evals, the price is irrelevant

Worked example 1: a low-volume indie app — the API wins

An indie product doing 30M tokens a month on GPT-5.4 Mini (blended 4:1 price $1.50 per 1M) pays $45.00 a month in API fees. The cheapest sensible self-hosting option — a Vast.ai marketplace RTX 4090 at $0.35/hr — costs $255.50 a month before a single engineering hour, so the rig is 5.7× the API bill.

Worked example. Break-even = 255.50 ÷ 1.50 ≈ 170M tokens/month. But an RTX 4090 running an 8B-class model at ~100 tokens/sec and 60% utilization tops out at 100 × 0.6 × 2,592,000 ÷ 1M ≈ 155M tokens/month — below its own break-even. On this hardware self-hosting never becomes cheaper at any volume it can actually serve. That's the pattern for most low-volume apps: stay on the API.

Worked example 2: a high-volume batch pipeline — self-hosting wins

Now the opposite end: 2B tokens a month of Terra-class work (blended $5.00 per 1M) costs $10,000 a month on the API. A rented RunPod H100 at $2.89/hr runs $2,109.70 a month; call it $4,219.40 with an honest 2× ops overhead. Break-even at 2× is 4,219.40 ÷ 5.00 ≈ 844M tokens/month — well below the 2B workload — and capacity checks out: Llama 3.3 70B in FP8 at ~1,500 tok/s and 60% utilization produces ≈2.33B tokens/month. Self-hosting saves about $5,780 a month, if the open model passes your quality bar.

One honest caveat: hosted open-weights endpoints compete hard here. Together AI serves the same Llama 3.3 70B at a flat $0.88 per 1M — $1,760 a month for those 2B tokens, which beats even the 1×-overhead rig. The real competition for self-hosting is often not the frontier API but hosted open weights; self-hosting pulls ahead again when utilization is high, data cannot leave your infrastructure, or you fine-tune.

Worked example 3: replacing a premium model — the break-even collapses

Break-even scales inversely with the API price. Against Claude Fable 5 — blended (4 × $10.00 + $50.00) ÷ 5 = $18.00, ×1.3 tokenizer correction = $23.40 per 1M — the same $2,109.70 H100 breaks even at just 2,109.70 ÷ 23.40 ≈ 90M tokens a month (180M at 2× ops). That's 4.7× lower than against Terra. The catch is the quality gap at its widest: workloads that justify Fable 5 pricing are usually exactly the ones an open 70B model handles worst. Run your evals before you believe this row of the table.

API model you'd replace	Blended $/1M (4:1)	Break-even vs H100 (1× ops)	Break-even (2× ops)
Claude Fable 5	$23.40	≈90M tokens/mo	≈180M tokens/mo
GPT-5.6 Sol	$10.00	≈211M tokens/mo	≈422M tokens/mo
GPT-5.6 Terra	$5.00	≈422M tokens/mo	≈844M tokens/mo
Claude Sonnet 5	$4.68	≈451M tokens/mo	≈902M tokens/mo
GPT-5.4 Mini	$1.50	≈1.41B tokens/mo	≈2.81B tokens/mo

The last row is the sobering one: against a budget model, break-even (1.41B) eats most of a single H100's ≈2.33B capacity at 1× ops — and exceeds it at 2×. Self-hosting competes with premium and mid-tier pricing, not with the budget tier.

What the formula leaves out

Quality first: hosted frontier models still beat open weights on hard reasoning, and no cost model survives a failed eval. Then latency — a rented single GPU has cold starts and queueing that a hyperscaler API doesn't. On the other side of the ledger, self-hosting buys things the formula can't price: data that never leaves your infrastructure, immunity to provider price changes and deprecations, and the freedom to fine-tune. Weigh those qualitatively; use the numbers for the rest.

To run this math on your own workload interactively, the OpenAI vs self-hosting calculator compares GPT tiers against a rented H100 live, and the LLM Token Cost Calculator lets you pick any model and any GPU from the same daily-refreshed price feed this guide is pinned to.

Frequently asked questions

How do I calculate the self-hosting break-even point?

What does ops overhead mean and why multiply by it?

How many tokens per month can one rented GPU serve?

Should I buy a GPU instead of renting one?

Related tools and guides

OpenAI vs self-hosting cost — this guide's math as an interactive calculator
LLM Token Cost Calculator — any model against any GPU, with live prices
LLM Pricing Comparison — the blended API prices used in these examples
How to estimate your monthly LLM token usage — get your volume number right before comparing

Find your own break-even point

Pick your model, your GPU and your utilization — the calculator does this guide's math live.

Open the LLM Token Cost Calculator