Self-Hosted LLM vs API: The Real Break-Even Math for 2026

Some links in this article are affiliate links. Automated Wealth Lab may earn a commission at no extra cost to you. See our Affiliate Disclosure.

Disclosure: This article contains affiliate links to DigitalOcean and n8n, mentioned where they genuinely fit the setups described. If you buy through those links, Automated Wealth Lab may earn a commission at no extra cost to you. Every price below was checked against a published source in October 2026; anything unverifiable is labeled a planning assumption with its inputs printed.

Self-hosting an LLM sounds like the obvious money move. No per-token bills, no rate limits, no landlord. Download Llama, rent or buy a GPU, and your automations run on hardware you control. The pitch writes itself — and falls apart the moment you do the arithmetic honestly.

The uncomfortable truth is that “self-hosted” does not mean “free per token.” It means you swapped a variable cost for a fixed cost. A GPU charges you the same whether it serves ten million tokens or ten. An API charges only for what you use. So the entire question — the only question — is utilization: how many tokens you push through the box, month after month, versus what the same tokens cost on an API.

This article computes that break-even point three ways: a rented datacenter GPU, a rented consumer GPU, and a GPU you buy yourself. Every price is sourced, every throughput figure is either benchmarked or flagged as an assumption, and the final section covers the reasons to self-host that have nothing to do with cost — because for most solo founders, those are the only reasons that survive the math.

The short answer: Self-hosting beats API pricing only at sustained volume most solo founders never reach. A rented H100 serving Llama 3.3 70B costs $0.52 per 1M tokens at full utilization but $5.24 at 10% utilization, and only undercuts a hosted open-model API ($0.88 per 1M tokens) above roughly 2.9 billion tokens per month. An owned RTX 5090 box breaks even against that API at about 190 million tokens per month — and against the newest mini-tier API pricing ($0.20 per 1M blended), the rented GPU never breaks even at any utilization.

The two cost models, stated plainly

An API bill is simple: tokens in × input price + tokens out × output price. Prices are quoted per million tokens, and because real workloads mix input and output, we blend them. Throughout, we assume a 3:1 input-to-output ratio — typical for automations where prompts and retrieved context are longer than completions. Change the ratio and blended prices shift; the method does not.

A self-hosted bill has three parts: the hourly or amortized hardware cost (a cloud GPU‘s rate, or a purchased GPU spread over its life, plus electricity); throughput — tokens per second actually served under load, where most break-even posts quietly cheat with peak benchmark numbers a lone user never sees; and utilization — the fraction of the month the GPU serves at that throughput. A box busy 10% of the time produces tokens at ten times the per-token cost of the same box at 100%.

The formula is one line: cost per 1M tokens = hourly cost ÷ (tokens per second × 3,600) × 1,000,000 ÷ utilization. Everything below is that formula with real numbers.

What the API side charges in October 2026

These are the reference prices the self-hosted scenarios have to beat. OpenAI’s list prices come from its published model pages; hosted open-model prices come from Together AI’s catalog, synced from its models API on October 25, 2026.

API option	Input / 1M	Output / 1M	Blended (3:1) / 1M
GPT-6 Luna (OpenAI)	$0.10	$0.50	$0.20
GPT-4o mini (OpenAI, deprecated)	$0.15	$0.60	$0.26
GPT-OSS 120B (Together AI, open weights)	$0.15	$0.60	$0.26
GPT-4.1 mini (OpenAI, deprecated)	$0.40	$1.60	$0.70
DeepSeek V3.1 (Together AI)	$0.60	$1.70	$0.88
Llama 3.3 70B (Together AI)	$0.88	$0.88	$0.88
GPT-4.1 (OpenAI, deprecated)	$2.00	$8.00	$3.50
GPT-4o (OpenAI, deprecated)	$2.50	$10.00	$4.38

Two things in this table matter more than any single row.

First, the like-for-like comparison for a self-hosted Llama 3.3 70B is not GPT-4o — it is the hosted Llama 3.3 70B at $0.88 per million tokens: the identical model, served by someone else, with zero ops. That is the bar a self-hosted 70B setup has to clear.

Second, the API target moves. OpenAI deprecated GPT-4o, GPT-4o mini, GPT-4.1, and GPT-4.1 mini on October 14, 2026, with API shutdown scheduled for January 14, 2027 — and named GPT-6 Luna, at $0.10/$0.50, as the replacement for all four. The cheapest API tier just got roughly five times cheaper against the model it replaces. A self-hosted model is frozen at download day. Any break-even computed today is against a competitor whose prices fall every year.

What the hardware actually requires

Before pricing GPUs, size the model. VRAM needs follow a formula from LLM Hardware’s methodology guide: VRAM (GB) ≈ parameters (billions) × bytes per parameter × 1.2 + 2 GB — Q4_K_M uses 0.5 bytes per parameter, Q8_0 uses 1.0, FP16 uses 2.0. The 1.2 factor covers a short context; longer contexts add KV cache on top.

Model class (Q4_K_M)	Weights + short context	What it fits on
8B	~6.8 GB	Any 8 GB+ GPU
32B (e.g. Qwen3-32B)	~21.2 GB	One 24 GB card (RTX 4090)
70B (e.g. Llama 3.3 70B)	~44 GB	One 48 GB card, or 2 × 24 GB cards
70B at Q8_0	~86 GB	Multi-GPU (exceeds one 80 GB card)
70B at FP16	~170 GB	Multi-GPU only

Context is the trap. That ~44 GB figure assumes a short window. The same methodology adds roughly 6 GB for a 32K context (the exact KV cache for Qwen3-32B at 32K is ~8.6 GB at the default f16 cache), pushing a 70B Q4 deployment to roughly 50 GB — just past a single 48 GB card. Quantizing the KV cache (q8_0 and q4_0 cache types use about half and a quarter of the memory) claws some back, at a small quality cost on long contexts.

On serving software: Ollama is the easy on-ramp for a single user. For real traffic, vLLM is the standard — its PagedAttention memory management measured 2–4× the throughput of earlier serving systems in its peer-reviewed evaluation. In Spheron’s 2026 benchmark of Llama 3.3 70B (FP8) on a single H100 at 50 concurrent requests, vLLM served 1,850 tokens/second (SGLang 1,920; TensorRT-LLM 2,100; vLLM cold start ~62 seconds). Those H100 figures anchor our first scenario: published measurements, not guesses.

For the two consumer-GPU scenarios, no equivalent published benchmark exists for the exact model-and-card pair, so we print our planning assumptions and the sensitivity: 600 tokens/second aggregate for a 32B Q4 model on an RTX 4090 under vLLM batching, and 800 tokens/second on an RTX 5090 (whose 1.79 TB/s memory bandwidth is ~78% higher than the 4090’s 1.008 TB/s). If your measured throughput is half our assumption, double every per-token cost in those scenarios. The conclusions do not change.

Scenario 1: rented H100 in the cloud, 70B model

RunPod’s published pod pricing (official pricing page, updated September 27, 2026) lists an H100 SXM 80GB at $3.49/hour. That card serves Llama 3.3 70B at FP8 in vLLM at the benchmarked 1,850 tokens/second under load. Run 24/7, the pod costs $3.49 × 730 hours = $2,548 per month, electricity included. (Spheron’s on-demand H100 rate was $2.64/hour as of October 28, 2026 — cheaper; we use RunPod’s rate because any reader can verify it on a pricing page.)

Utilization	Tokens / month	Cost per 1M tokens
100%	4.86 billion	$0.52
50%	2.43 billion	$1.05
25%	1.22 billion	$2.10
10%	486 million	$5.24

Against the identical model hosted on Together AI at $0.88 per million, break-even is $2,548 ÷ $0.88 ≈ 2.9 billion tokens per month — about 60% sustained utilization, around the clock. Against GPT-6 Luna’s $0.20 blended price, break-even would need 12.7 billion tokens a month from a box whose theoretical maximum is 4.86 billion. It never breaks even. If a $0.10/$0.50 API model is good enough for your workload, no utilization level makes this GPU the cheaper option.

One more honest line item: a stopped pod still bills for its volume disk — $0.20/GB/month idle. A 70B model cache on a “paused” instance keeps costing money; the cloud meter never fully stops.

Scenario 2: rented RTX 4090 in the cloud, 32B model

RunPod lists the RTX 4090 24GB at $0.74/hour — $540/month run continuously. A 32B-class model at Q4_K_M (~21.2 GB) fits the card, and at our stated planning assumption of 600 tokens/second aggregate, the box tops out near 1.58 billion tokens per month. (The 48 GB RTX A6000 at $0.53/hour is the budget route to the full 70B at Q4, whose ~44 GB just fits — benchmark its throughput yourself before trusting any per-token figure for it.)

Utilization	Tokens / month	Cost per 1M tokens
100%	1.58 billion	$0.34
50%	788 million	$0.69
25%	394 million	$1.37
10%	158 million	$3.43

Break-even against the hosted 70B API ($0.88) lands at 614 million tokens per month, about 39% utilization — with an asterisk: a 32B model is a quality tier below the 70B it is compared against. Against GPT-4.1 mini’s $0.70 blended price, break-even is 772 million tokens per month. Against GPT-6 Luna at $0.20 blended, it needs 2.7 billion tokens a month — again, more than the hardware can produce.

Scenario 3: an RTX 5090 box you own

Buying changes the shape of the bill, not its existence. The RTX 5090 (32 GB GDDR7, 575W rated board power) launched at $1,999 MSRP in January 2025, but October 2026 street prices from independent trackers run from about $2,873 to over $4,100 — scarcity pricing, well above MSRP. Our planning model uses $2,900 for the card (the low end of that verified range) plus $800 for the rest of the system — CPU, board, RAM, PSU, case — an assumption we print rather than a price we verified.

• Amortization: $3,700 over 36 months ≈ $103/month
• Electricity: assume a 0.5 kW average draw around the clock (rated 575W at full load, far lower at idle) = 365 kWh/month × $0.18 ≈ $66/month. The rate is the EIA’s 2026 U.S. residential average (17.91¢/kWh, rounded); at California or New England rates (28–31¢/kWh) this line roughly doubles.
• Fixed cost: ≈ $168/month, before a single minute of your own maintenance time.

Serving the same 32B Q4 model at our assumed 800 tokens/second, the box can produce at most ~2.1 billion tokens a month:

Utilization	Tokens / month	Cost per 1M tokens
100%	2.10 billion	$0.08
25%	526 million	$0.32
10%	210 million	$0.80
5%	105 million	$1.60

This is the one scenario where self-hosting wins at plausible volumes: break-even against the hosted 70B API is ~190 million tokens per month (about 9% utilization); against hosted GPT-OSS 120B ($0.26 blended) it is ~642 million. But add one hour a month of maintenance time at $50/hour — driver updates, a CUDA breakage, an ill-timed restart — and fixed cost becomes $218/month, pushing the Together break-even to ~248 million tokens. Your time is a real line in this spreadsheet whether you write it down or not.

Now the reality check. A busy solo founder’s automation stack — support drafts, content pipelines, document processing, agents — might run 2,000 requests a day at ~2,000 tokens each: ~120 million tokens a month. At that volume the owned box runs at under 6% utilization and produces tokens at ~$1.40 per million, while the same work costs $106/month on the hosted 70B API or $24/month at GPT-6 Luna’s blended price. The API wins, and it is not close.

The costs the per-token math leaves out

Ops burden. An API is someone else’s pager. A self-hosted endpoint is yours: driver updates that occasionally break the serving stack, model swaps when a better open model drops, monitoring, restarts, and securing an internet-facing endpoint. None of it is hard, exactly. All of it is time — and for a solo founder, time is the scarcest input in the business.

The quality gap is real, and it moves. Llama 3.3 70B is capable, and Q4_K_M retains most of its quality (LLM Hardware’s guide estimates 95–98% of the unquantized model). But it is a fixed artifact from its release era, while the API side retired four models this month and replaced them with a cheaper, larger-context successor. The hosted option improves every quarter; the self-hosted one improves only when you do the work.

Architecture softens the blow. If you do self-host, keep the GPU out of the critical path. Put the always-on control plane — authentication, request queue, logging, webhook receivers — on a small, cheap VPS (a droplet is the usual choice), route workflow traffic through your automation layer (self-hosted n8n treats a local endpoint like any OpenAI-compatible API), and let the GPU be a replaceable worker. When it goes down, the queue backs up instead of the business stopping — and you can fail over to an API key for the hours that matter.

Note: the VPS sentence above also covers the one-VPS business-stack idea — the control plane belongs on a small VPS, not on the GPU box.

When self-hosting is actually the right call

Privacy and data control. If your prompts contain client data, contracts, health or financial details, or anything under an NDA, keeping tokens on hardware you control removes a third party from the chain entirely — no API logs, no retention policy to read, no sub-processor list. For many professional-services automations this is the whole requirement, and it justifies the premium the math above exposes.

Workload shape. Batch jobs that can saturate a GPU for hours — bulk document classification, embedding a large corpus, synthetic data generation — are the one pattern that reaches high utilization naturally, because the queue, not a human, sets the pace. Interactive chat almost never does.

Predictability at proven volume. If you have measured — not estimated — a sustained burn well past the break-evens above (say 300+ million tokens a month against mid-tier API pricing, on an owned box), the fixed cost becomes a feature: a flat bill that does not scale with your success. Few solo operations are there. Measure first, buy second.

FAQ

How many tokens a month do I need to burn before self-hosting pays off?
Against a hosted open-model API at $0.88 per million tokens: roughly 190 million tokens/month for an owned RTX 5090 box, 614 million for a rented cloud RTX 4090, and 2.9 billion for a rented H100. Against the cheapest current API tier (~$0.20 per million blended), the rented options never break even.

Is Ollama fast enough for production automation?
For one user or a low-volume internal tool, yes — it is the simplest way to run the models sized in this article. For concurrent traffic, vLLM’s continuous batching and PagedAttention are built for that load: published H100 benchmarks show throughput scaling from 120 tokens/second at one concurrent request to roughly 2,400 at one hundred. At volume, engine choice matters as much as the GPU.

Does quantization noticeably hurt output quality?
Q4_K_M is the community sweet spot: it cuts memory roughly in half versus Q8 and, per LLM Hardware’s guide, retains an estimated 95–98% of the model’s quality. Losses show up first in math, code, and long-context precision. If your workload is accuracy-critical, budget VRAM for Q8 and re-run this math — a 70B at Q8 needs ~86 GB.

Why not compare against GPT-4o pricing, where self-hosting looks great?
Because GPT-4o is deprecated — shutdown January 14, 2027, replaced by GPT-6 Luna at a fifth of the blended price. A break-even against a retiring price is a break-even against a ghost. We show the GPT-4o row for reference; decide on the prices that will actually be on your bill.

What about renting by the minute and shutting the GPU down when idle?
It genuinely helps — it converts fixed cost back toward variable. Two frictions remain: cold starts (vLLM took ~62 seconds to first token in the cited benchmark; loading a 70B model is slower) and storage that keeps billing while stopped. For spiky, latency-tolerant batch work it is often the best of both worlds; for interactive tools, the cold start is usually unacceptable.

Methodology

What we did: Every price came from a published source read in October 2026: RunPod’s official GPU pricing page (updated September 27, 2026, as reproduced by a pricing guide we opened), OpenAI’s model pages (read October 14, 2026), Together AI’s catalog (synced from its models API, October 25, 2026), Spheron’s published H100 benchmark, LLM Hardware’s VRAM guide (updated October 24, 2026), independent RTX 5090 street-price tracking, and the EIA’s 2026 residential electricity average. All cost-per-token and break-even figures are our own arithmetic from those inputs, using the printed formula, a 3:1 blend, and a 730-hour month.

What we did NOT do: We did not rent these GPUs or run these benchmarks ourselves, and we make no first-person testing claims. No published benchmark exists for our two consumer-GPU throughput figures, so those are printed as planning assumptions (600 tok/s RTX 4090; 800 tok/s RTX 5090) with the sensitivity stated. Street GPU prices are volatile; we used the low end of a tracked range and said so. Cooling, hardware failure, and replacement are not modeled.

Conflict disclosure: This article contains affiliate links to DigitalOcean and n8n only; neither company had input into the analysis. RunPod, Together AI, OpenAI, Spheron, and NVIDIA are mentioned editorially — we hold no affiliate relationship with them and no link here earns us anything from them.

AWL verdict

For a solo founder, the API is the default and self-hosting is the exception — the math is not ambiguous. Below roughly 200 million tokens a month, even the friendliest self-hosted setup (an owned RTX 5090 you already have a use for) loses to a hosted open-model API, and the newest mini-tier pricing has moved the break-even for rented datacenter GPUs past what the hardware can physically serve. Self-host when privacy or client contracts demand it, when batch workloads genuinely saturate a GPU, or when your measured — not hoped-for — volume clears the break-evens above. Until then, spend the GPU money on the business, keep an API key in the stack, and re-run this arithmetic every time API prices drop. They will.

Sources

RunPod official GPU pricing page (updated September 27, 2026), via Nano Banana’s pricing guide — https://www.nano-banana.live/blog/runpod-gpu-choice-ai-image-models.html (verified October 2026)

OpenAI model pricing pages and deprecation notice, read October 14, 2026 — https://cellcog.ai/blog/gpt-4o-api-shutdown/ (verified October 2026)

Together AI pricing catalog, synced from api.together.ai/models, October 25, 2026 — https://www.aipricing.guru/together-pricing/ (verified October 2026)

Spheron, “LLM Inference Optimization (2026)” — H100 serving benchmarks — https://www.spheron.network/blog/llm-inference-optimization-2026/ (verified October 2026)

LLM Hardware, “How Much VRAM for Local LLMs?” — updated October 24, 2026 — https://llmhardware.io/guides/how-much-vram-do-i-need (verified October 2026)

TrendInTech, “RTX 5090 vs RTX 4090” — specs and October 2026 street prices — https://trendintech.com/rtx-5090-vs-rtx-4090-native-performance-2026/ (verified October 2026)

ElectricRates.org, “Electricity Rates by State (2026)” — EIA average, 17.91¢/kWh — https://electricrates.org/blog/electricity-rates-per-kwh-by-state/ (verified October 2026)