Costs: local vs API, done with real numbers

You're weighing whether to run your AI locally or keep calling a cloud API. The question isn't "which one is more powerful" — you already know that. The question that actually matters is another one: what does it really cost me, and at what point does the hardware I buy once stop being cheaper than the subscription I pay every month. Here we try to answer with numbers, not vibes.

Two opposite cost models

The API is a variable cost: you pay per token, the bill grows with usage, and when you don't use it you don't pay. Local is a fixed cost: you buy the hardware once, you pay for it in one shot, and after that the marginal cost of every generation is basically just electricity.

That difference — fixed against variable — is the whole story. The person who uses it little never pays back the hardware. The person who uses it a lot crosses, one day, the point where the API is more expensive. That day is called the break-even point.

What an API call really costs

Prices are measured per million tokens. A million tokens is roughly 750,000 English words. Current list prices, verified on the official OpenAI and Anthropic sites:

Model	Input (per 1M)	Output (per 1M)
GPT-6 Astra	$10.00	$50.00
GPT-5.6 Sol	$4.00	$20.00
GPT-5.6 Terra	$2.00	$12.00
GPT-5.6 Luna	$0.20	$1.20
GPT-4.1	$2.00	$8.00
GPT-4.1 mini	$0.40	$1.60
Claude Opus 5.5	$4.00	$20.00
Claude Sonnet 5	$2.00	$10.00
Claude Haiku 4.5	$1.00	$5.00

The number that matters in practice is the output one, because that's what the model generates and you pay for on every response. A 1,000-token response costs $0.05 with Astra, $0.02 with Sol or Opus 5.5, $0.012 with Terra, $0.0012 with Luna.

Let's take a realistic round of conversation: 2,000 input tokens (the context you send) + 500 output tokens (the reply).

• GPT-6 Astra: 2,000/1M × $10.00 + 500/1M × $50.00 = $0.02 + $0.025 = $0.045 per turn
• GPT-5.6 Sol: 2,000/1M × $4.00 + 500/1M × $20.00 = $0.008 + $0.01 = $0.018 per turn
• GPT-5.6 Terra: 2,000/1M × $2.00 + 500/1M × $12.00 = $0.004 + $0.006 = $0.010 per turn
• GPT-5.6 Luna: 2,000/1M × $0.20 + 500/1M × $1.20 = $0.0004 + $0.0006 = $0.001 per turn
• Opus 5.5: 2,000/1M × $4.00 + 500/1M × $20.00 = $0.008 + $0.01 = $0.018 per turn

They don't look like big numbers. But the point isn't the single turn — it's how many turns you make.

What local costs

Local has two line items: the upfront investment (once) and the electricity (ongoing but small).

Upfront: an RTX 4090 24GB runs about €1,600, a used 3090 around €1,500, a 5090 32GB about €2,000. The rest of the machine (CPU, RAM, case, PSU) you either already have or you add it. We amortize the GPU alone over 3 years (36 months):

• 4090 at €1,600 → €44 per month
• 3090 at €1,500 → €42 per month
• 5090 at €2,000 → €56 per month

Electricity: a PC with a gaming GPU under load draws 400-500 watts. At €0.30 per kWh, an hour of full load costs roughly €0.12-0.15. If you use the machine an hour a day, you're at €3.60-4.50 per month. Idle draw (standby, GPU inactive) is negligible.

So local costs you, all in, around €45-60 per month of fixed cost, no matter how many generations you make. The software, for its part, costs nothing: llama.cpp and the runtimes built on it are open source, and the weights of open models (Qwen, Llama, Mistral) download free.

The break-even point

Now put the two curves together. Local is a horizontal line (about €50 per month). The API is a line that starts at zero and climbs. They cross when your monthly tokens pass a threshold:

Break-even (tokens/month) ≈ local fixed cost / API cost per token

Let's do it for a realistic mix (4 input tokens per 1 output, typical of work with long context):

API (4:1 in/out mix)	Blended cost per 1M tokens	Break-even at €50/month
GPT-6 Astra	~$14.00	~2.4M tokens
GPT-5.6 Sol	~$5.60	~5.6M tokens
Opus 5.5	~$6.40	~4.9M tokens
Claude Sonnet 5	~$3.20	~13M tokens
GPT-5.6 Terra / GPT-4.1	~$2.80	~15M tokens
GPT-4.1 mini	~$0.48	~57M tokens
GPT-5.6 Luna	~$0.32	~84M tokens

In human numbers: with the flagship model (GPT-6 Astra, $10/$50), local becomes worthwhile when you pass about 2.5 million tokens per month — a few thousand replies a day for a business. With GPT-5.6 Sol ($4/$20) the threshold climbs to ~5.5M tokens/month, to 13–15M with Terra or Sonnet. With a cheap model like Luna ($0.20/$1.20) it reaches 84M tokens: for personal use you rarely get there, and the cheap API stays the saner choice.

These are orders of magnitude, not a quote: prices change, lists get updated, and you weigh electricity and amortization however you like. But the method holds: the more you use and the pricier the models, the more competitive local becomes; the less you use or the cheaper the models, the more the API wins.

What actually moves the answer

The numbers say "it depends on tokens." But the real decision also depends on what you can't see in the table.

Long context. More context sent, more input tokens, more the API climbs — and local doesn't grow with context: it has the RAM it has. For loads with thousands of context tokens per call, the API curve gets very steep.

Multiple users or agents. A company serving ten employees or running agents 24/7 doesn't use "a little": it uses millions of tokens a day. That's exactly the profile that crosses break-even. A single user chatting an hour a day, no.

Model quality. Local gives you the open models (Qwen, Llama, Mistral) at the quality your VRAM allows. If the work demands the strongest frontier cloud model, local doesn't match it — and the API cost is the price of that quality.

Control and data. The numbers above don't include the value of not sending data out the door: GDPR, sensitive data, offline availability. For many use cases that's worth more than the cost delta. For others it's worth nothing.

Availability. Local always answers, no connection, no rate limits. The API has rate limits, spikes, dependence on a provider. If availability is a requirement, local has an edge the API doesn't — and one people often gladly pay for.

When one or the other is the right call

API when: personal or light use; you need the best quality today; you want to start without buying hardware; the load is irregular (you only pay when you use it).

Local when: intensive, steady use (many replies a day, multiple users, parallel agents); the context is long; the data can't leave; you need 24/7 offline availability; you want a predictable cost that doesn't rise with usage.

Hybrid: very common. Local for the volume work (classification, drafts, RAG, batch) and the API for the cases that need the top model. It's often the configuration that, on the numbers, ends up cheaper than either route taken alone.

In one line

The API is variable, local is fixed: the break-even point is where your monthly tokens pass the threshold the API prices set. For personal use you rarely get there, and the API stays the saner choice. For intensive, shared, or sensitive-data use, local doesn't just flip the bill: it adds control, data that stays yours, and availability that's always on — the reason it's often worth it a little before that point.

Article generated with AI