Is a Local LLM Actually Cheaper Than the API? The Break-Even Math

"Just run it locally, it's free." You have read that under every thread about API bills, and it quietly drops the two costs that actually decide the question: the hardware, spread over its life, and your own time. A local LLM is not free; it trades a per-token API bill for a mostly fixed monthly cost, and the honest question is at what token volume the fixed cost finally beats the variable one.

This post builds that break-even as reproducible arithmetic. Every API price is the vendor's list price, every throughput and power figure is from a published benchmark, and the local numbers are modeled from documented specs with the assumptions stated inline.

Why is "local is free" the wrong comparison?#

The claim compares an API invoice against a local cost of zero, and that missing zero is the whole error. A local model still runs on hardware you bought, draws power you pay for, and needs setup and upkeep that costs your time. The right comparison loads both columns and asks where they cross.

The shapes of the two bills are opposites. The API is 100% variable: send nothing and you pay nothing, send more and it scales linearly, and the vendor absorbs scaling and uptime. The local rig is mostly fixed: you pay the amortized hardware and the baseline power whether the box is busy or idle. That difference, not a headline token price, is what decides the answer.

The API bill is pure variable cost; the local bill is mostly fixed cost you pay whether you send 1M or 100M tokens.

So the real question is a volume question. At low usage the API's variable bill is tiny and the rig's fixed cost looks absurd; at high usage the fixed cost spreads thin and the per-token bill balloons. Somewhere between the two, the lines cross.

What does the API side actually cost?#

API pricing is quoted per million tokens (MTok) and split into input and output, with output the expensive half. To compare against a flat local cost, collapse it to one blended rate using a token mix you actually run. The table below uses a 70% input, 30% output mix; change the mix and the blended number moves.

The worked blend for Haiku 4.5 is 0.7 × $1 + 0.3 × $5 = $2.20 per 1M tokens. Two things stand out. First, the nano-class tiers sit so far below Haiku that local hardware struggles to beat them on cost at all. Second, three levers push the API side lower still: prompt caching (cache reads bill at 0.1x input), the Batch API (50% off), and simply choosing the smallest model that clears your quality bar. The prompt caching guide shows how the caching lever alone can cut a repeated-prefix workload by close to 90%, which pushes the local break-even even further out. Check current Claude pricing before you model your own case.

The blended rate is the number to fight over, because it is the slope of the API line. Halve it with a smaller model or caching and you double the token volume you would need before local pays back. That is why the honest version of this question is never "is local cheaper" but "is local cheaper than the specific, already-optimized API tier I would otherwise use".

What does the local side actually cost?#

The local bill has three lines, and most "free" claims show none of them. Hardware amortization is the big one; electricity is usually smaller; your time is the line nobody invoices but everybody pays. Model each from documented specs and the total is far from zero.

Take a single RTX 4090 build, roughly $3,500 all-in in mid-2026. Amortized over three years that is about $3,500 / 36 = $97 per month before a single token. Power adds a modest amount: the card draws up to about 450W under load, so four hours a day at the US average residential rate (about 17.8 cents per kWh) is 0.45 kW × 4 h × 30 days × $0.178 ≈ $10/month. Run it 24/7 and that line climbs steeply, with cited heavy-use figures near $52/month for a 600W draw.

At low volume the local rig's fixed cost dwarfs the API bill. Modeled from June-2026 prices and a 3-year amortization.

Hardware choice changes the shape of the bill. A 192GB M3 Ultra Mac Studio starts well past $5,600, a much higher fixed cost, but it sips power (160-180W under a 70B load) and holds big models in unified memory. The 4090 is cheaper to buy and faster on small models, but its 24GB of VRAM forces large models onto slow CPU offload. Neither is "free"; they just distribute the fixed cost differently.

Two limits keep a single rig from being an unlimited token faucet. Throughput: a 4090 does 100-plus tokens per second on an 8B model, but a 70B model spills past its 24GB of VRAM and drops to roughly 8-18 tokens per second on partial CPU offload. And your time: setup, quantization, driver breakage, and uptime are real hours every month. If you want to feel the local path before pricing it out, connect Ollama to n8n and compare runners in Ollama vs LM Studio vs Jan. Roll up the cash lines and the build is about $110 per month fixed before you cost your own time at all.

Where do the lines cross?#

Divide the fixed local cost by the blended API rate and you get the break-even token volume. Against Haiku-class pricing that is about 50 million tokens per month ($110 divided by $2.20 per 1M). Below that the API is cheaper; above it the rig wins on cash. The crossover moves with every input, so model it rather than guess.

Change any one of these and the crossover moves. The post gives the formula so you can plug in your own.

The API tier you compare against changes the answer more than anything else.

Read it as a sliding scale. Against a cheap nano tier you may never recoup the hardware on cost alone. Against a premium tier the crossover arrives early, because every token you stop buying at $11 per million pays the rig back fast. Most real workloads that justify local are both high-volume and aimed at replacing a mid-or-premium tier.

Three gates decide it: volume, quality, and whether you can own uptime or must keep data local.

So should you go local? A decision you can defend#

Go local when three things hold at once: you are consistently above the break-even volume for your tier, an open-weight model clears your quality bar, and you can own setup and uptime. If any one fails, the API is usually cheaper and far less work. Privacy or compliance can override the math entirely.

The quality and speed caveats are real. An open-weight 70B model like Llama 3.3 70B scores about 86% on standard MMLU, essentially level with GPT-4o, but it trails frontier models on hard reasoning and coding and on the tougher MMLU-Pro, and a single consumer GPU runs it slowly. The API also scales horizontally while your one box does not.

Privacy, control, and predictability can justify local below break-even; quality, latency, and your time can justify the API above it.

What can flip the decision below break-even is everything the spreadsheet does not price. Data that never leaves your machine answers a privacy or compliance requirement no discount can, which is the usual reason to build something like a local RAG over private documents even at low volume. No rate limits, a flat and predictable monthly cost, and offline operation are worth real money to some teams. Those are judgment calls, not cells in a model, and they are legitimate reasons to self-host even when the API is technically cheaper.

How do you run the math for your own workload?#

Use four inputs and one division. Take your model's input and output prices, pick a token mix to get a blended dollars-per-million rate, estimate your rig's monthly fixed cost (hardware divided by its life, plus electricity), then divide the fixed cost by the blended rate. That quotient is your break-even token volume.

Then sanity-check it against reality before you buy anything. Estimate your true monthly token volume from a week of real usage, not a hopeful guess, and compare it to the break-even you just computed. If you are not comfortably above it on a tier you would actually use, stay on the API, cut the bill with caching and a smaller model, and re-run this math when your volume or the prices move.