Last updated: November 12, 2026 (Claude Fable 5.2 price added; all other figures as of September 28, 2026)
For most teams, an API is still cheaper than running a large LLM locally. In our worked example, a coding-agent workload of 300 million input and 20 million output tokens a month costs about $200 on the Kimi K2.6 API, $475 on Claude Sonnet 5.5 and $907 on Claude Opus 5.5, versus roughly $1,400 a month for a four-Mac Studio cluster running the same Kimi model. Local hardware wins on privacy, offline use and sustained, batched utilization, not on the price of occasional tokens.
September 22, 2026 put both sides of this question on sale on the same day. Anthropic released Claude Opus 5.5 at $4 per million input tokens and $20 per million output tokens, and Apple started selling the new Mac Studio with M5 Max and M5 Ultra, pitched at companies that want to run AI on their own machines. Apple’s hardware chief Johny Srouji put the pitch plainly to Reuters: “Once you have the machine on your desk, you’ve paid for it. … There’s no cost per token.”
There is a cost per token. It is just hidden in amortization, electricity, administration and, above all, utilization. This guide prices one realistic workload three ways, shows the formula, and gives you a calculator you can run on your own numbers.
What changed in September 2026?
Cloud tokens got cheaper at the top. Anthropic says Opus 5.5 “performs at the level of Claude Fable 5.1 on most work”, which lists at $10/$50, and that at default settings it “will cost 40% less than Opus 5 on typical workloads”. Read that carefully: the list price is only 20% lower than Opus 5 ($5/$25). The rest of Anthropic’s 40% comes from the model using fewer tokens at its default effort, which depends on your workload. Opus 5.5 also has an unusually low cache-read price of $0.20 per million tokens, 0.05x the input price.
Local hardware got more memory and bandwidth. The Mac Studio M5 Ultra starts at $5,499 with 96 GB of unified memory, offers 1.2 TB/s of memory bandwidth, and can be configured to 256 GB now and 512 GB later. Apple says Thunderbolt 5 with RDMA lets several Mac Studios cluster for “up to 3x faster performance for distributed AI inference”.
How do you calculate the real cost of a local LLM?
The cost of a local token is a fixed monthly cost divided by the tokens you actually produce. That denominator is where most comparisons go wrong: they assume the machine runs at full speed 24 hours a day.
(hardware ÷ amortization months + electricity + admin time + space/networking)
÷ (tokens produced per month ÷ 1,000,000)
For an API the formula is simpler, but not as simple as the headline price. You need to split input into cached and uncached tokens, and decide whether work can go through a batch API.
+ cache writes × write price + output × output price (× 0.5 if batched)
Two traps apply to both. First, tokens are not comparable across model families: Anthropic notes that Claude models from 4.7 onward use a tokenizer that produces roughly 30% more tokens for the same text. Compare cost per completed task, not cost per token. Second, quality is not equal. An open model on your desk and a frontier model in the cloud do not finish the same share of tasks on the first attempt. A cheaper model that needs two retries is not cheaper.
One workload, priced six ways
To make the comparison concrete we use one workload: a small engineering team running coding agents. Agents are input-heavy because they re-read files and history on every step. Our assumptions are 300 million input tokens a month, of which 70% are cache hits, cache writes equal to 10% of the cached volume, and 20 million output tokens. Prices are the providers’ list prices on September 28, 2026.
| Option | Price per 1M tokens (in / cache hit / out) | Monthly cost for this workload | Note |
|---|---|---|---|
| Claude Fable 5.2 API | $8 / $0.20 / $40 | $1,772 | Most capable widely released Claude model since November 9, 2026 (price as of November 12, 2026) |
| Claude Fable 5.1 API (previous version, legacy) | $10 / $0.25 / $50 | $2,215 | Replaced by Fable 5.2; still available |
| Claude Opus 5.5 API | $4 / $0.20 / $20 | $907 | Anthropic says Fable 5.1-level on most work |
| Claude Sonnet 5.5 API | $2 / $0.20 / $10 | $475 | Everyday coding and agent work |
| Kimi K2.6 API (Moonshot) | $0.95 / $0.16 / $4.00 | $199 | Same open model as the cluster below |
| 4× Mac Studio M5 Ultra 256 GB running Kimi K2.6 | no per-token fee | ≈ $1,425 | $1,055 hardware over 36 months + ~$70 power + ~$300 admin |
The cluster line needs its assumptions spelled out. Kimi K2.6 has one trillion total parameters and 32 billion active per token, and its native INT4 checkpoint is roughly 600 GB. Four 96 GB base machines cannot hold it, so we price four 256 GB machines at about $9,499 each, the price reported for that configuration, or $37,996 in total. Over 36 months that is $1,055 a month. For power we use Apple’s measured maximum of 385 W per M5 Ultra, which overstates typical inference draw. Admin time is a placeholder of four hours a month at $75 an hour; replace it with your own figure.
The result is not close. For the same open model, the API is about seven times cheaper than the cluster at this volume. Even against Opus 5.5, the cluster costs more while running a different, generally less capable model.
Why can’t the cluster just run more to break even?
This is the part most calculators miss. A local machine’s throughput caps how many tokens it can produce, and for large models that cap sits below the break-even point.
Third-party reports put the WWDC Kimi K2.6 demo at about 25–28 tokens per second, and Jeff Geerling measured about 30 tokens per second for Kimi K2 Thinking on four M3 Ultras linked with RDMA. At 28 tokens per second, a single generation stream running 24/7 for 30 days produces about 72.6 million tokens. At Moonshot’s $4 output price, 72.6 million output tokens cost about $290 through the API, far below the cluster’s $1,055 monthly hardware cost alone. At single-stream speed, the cluster cannot break even against the same model’s API no matter how hard you run it.
Two factors could change that, and both need measuring on your own setup rather than assuming:
- Batching. Serving several requests at once raises total throughput, because the weights are read once per step for the whole batch. Cloud providers depend on this. How much a Mac cluster gains from concurrent streams on MLX depends on the model, context length and runtime, and we have not found an independent benchmark for this configuration.
- Prompt processing. Agents send long prompts. On a single M3 Ultra, DeepSeek R1 with an 11,000-token prompt processed input at about 189 tokens per second on MLX and generated at about 11. In our workload, 90 million uncached input tokens at 190–450 tokens per second take 56 to 132 hours of compute before a single output token is written. MacStories measured the M5 Ultra cutting time to first token on a 64K prompt from 59.7 to 24.4 seconds versus M3 Ultra. That is a real improvement, and still slow for an interactive agent.
Add those up and our 20-million-output workload keeps the cluster busy for roughly 250 to 330 hours a month as a single queue. It can technically process the volume, but as a batch job, not as a responsive tool for five developers working at the same time.
A rough rule for generation speed helps sanity-check any hardware claim: decode speed is bounded by memory bandwidth divided by the bytes read per token. Kimi K2.6 at INT4 reads about 16 GB of active weights per token, so one M5 Ultra at 1.2 TB/s has a theoretical ceiling near 75 tokens per second before any overhead, and real systems land well below it. The same arithmetic explains why a 128 GB DGX Spark at 273 GB/s runs large models slowly despite fitting them in memory.
When does local hardware actually win?
Local wins when you change one of three variables: model size, utilization or constraints.
Smaller models. A single 256 GB M5 Ultra running a 27-billion-parameter model is a different proposition. MacStories measured Qwen3.8 27B at about 48 tokens per second of generation and 1,701 tokens per second of prompt processing on the M5 Ultra. Our workload would take about 130 hours of compute a month. The cost is about $264 a month of amortization plus roughly $7 of electricity. That undercuts Claude Sonnet 5.5’s $475, but only if a 27B model is good enough for your tasks, and it undercuts nothing if your team spends extra hours correcting its output.
High, steady, batchable utilization. If you have a queue that never empties, such as nightly document processing, classification or embedding generation, and the work tolerates latency, local hardware amortizes well. Note that the same property also unlocks the API’s cheapest mode: batch APIs typically cost 50% of list price, and on Anthropic that discount stacks with cache pricing. Opus 5.5 through the Batch API costs $2 per million input and $10 per million output tokens. Compare local batch work against API batch prices, not against interactive prices.
Constraints that money does not solve. Some data cannot leave your premises for contractual or regulatory reasons. Some workloads must run offline, in a factory, a vessel or a secure facility. Some teams need a fixed, auditable model version that no provider can deprecate; Moonshot already offers newer models than Kimi K2.6 on its platform, but the K2.6 open weights remain yours to run. In these cases the comparison is not local versus API. It is local versus not doing the work.
What about NVIDIA GPUs and rented cloud GPUs?
The Mac Studio’s advantage is capacity per dollar of memory, not raw speed. NVIDIA hardware generally processes prompts much faster, which matters for agents and long contexts, but large memory is expensive. The RTX PRO 6000 Blackwell with 96 GB lists at $16,000 on NVIDIA’s marketplace as of September, up from $8,565 at launch. The DGX Spark costs $4,699 with 128 GB of memory but only 273 GB/s of bandwidth.
Renting is the middle path. On-demand H100s cost roughly $2.69 to $4.29 per GPU-hour and B200s about $5.98 to $6.99 across Runpod and Lambda. Renting gives you datacenter throughput and batching without buying hardware, but at hourly rates the same utilization rule applies: an idle rented GPU is the most expensive token source of all. Our earlier analysis of self-hosting GLM-5.2 on H200s found a break-even in the billions of output tokens per month, which is typical for datacenter-scale self-hosting. For the managed middle ground, see hosted versus self-hosted NVIDIA NIM.
How much does electricity add?
Less than most people expect, and much less than depreciation. Apple lists the M5 Ultra Mac Studio at 9 W idle and 385 W at maximum.
| Scenario | Energy per month | US commercial (14.53¢/kWh, EIA, July 2026) | Poland, business 20–499 MWh/yr (1.12 PLN/kWh, Eurostat H2 2025, excl. VAT) |
|---|---|---|---|
| 1× M5 Ultra at max, 24/7 (upper bound) | 277 kWh | $40 | 310 PLN |
| 1× M5 Ultra, 130 busy hours at max | 50 kWh | $7 | 56 PLN |
| 4× M5 Ultra, 254–330 busy hours at max | 391–508 kWh | $57–74 | 438–569 PLN |
| 4× M5 Ultra at max, 24/7 (upper bound) | 1,109 kWh | $161 | 1,241 PLN |
Micro-businesses in Poland pay more: Eurostat puts the under-20 MWh band at about 1.52 PLN per kWh before VAT. Even then, electricity rarely exceeds 10–15% of the monthly cost of a local cluster. The number that decides the outcome is how many useful tokens you get out of the hardware before it is obsolete.
Run the numbers yourself
The script below reproduces the table above. Change the workload, prices and hardware to match your case; the defaults are the assumptions used in this article.
# Monthly workload, in millions of tokens
INPUT_M, CACHE_HIT_SHARE, OUTPUT_M = 300, 0.70, 20
cached = INPUT_M * CACHE_HIT_SHARE
uncached = INPUT_M - cached
cache_writes = 0.10 * cached # share of cached prefix re-written
def api_cost(p_in, p_out, p_hit, p_write=None, batch=False):
p_write = p_in * 1.25 if p_write is None else p_write
cost = uncached * p_in + cached * p_hit + cache_writes * p_write + OUTPUT_M * p_out
return cost * (0.5 if batch else 1.0)
def local_cost(hw_usd, months, watts, busy_hours, kwh_price, admin_usd=0):
energy = watts / 1000 * busy_hours * kwh_price
return hw_usd / months + energy + admin_usd
def busy_hours(prefill_tps, decode_tps):
return (uncached * 1e6 / prefill_tps + OUTPUT_M * 1e6 / decode_tps) / 3600
print("Opus 5.5 API ", round(api_cost(4, 20, 0.20)))
print("Sonnet 5.5 API ", round(api_cost(2, 10, 0.20)))
print("Kimi K2.6 API ", round(api_cost(0.95, 4.00, 0.16, p_write=0)))
h = busy_hours(prefill_tps=190, decode_tps=28) # 4-node cluster, single stream
print("Cluster busy h ", round(h))
print("4x M5 Ultra ", round(local_cost(4 * 9499, 36, 4 * 385, h, 0.1453, admin_usd=300)))
print("Max output/mo M", round(28 * 86400 * 30 / 1e6, 1)) # throughput ceilingIf the busy-hours figure exceeds about 720, the hardware cannot serve your workload at all. If it is far below 720, you are paying for idle silicon. The profitable zone for local inference is narrow: busy most of the month, with work that tolerates queueing.
Decision checklist
- Choose an API if your load is bursty, you need frontier-level quality, your agents use long contexts, or nobody on the team wants to run infrastructure. Use prompt caching and batch processing before considering hardware; together they can cut an API bill by more than half.
- Choose a single local machine if a model of up to roughly 30–70 billion parameters is good enough, data must stay on-premises, or you want predictable, fixed costs for a small team.
- Choose a local cluster only if you need a very large open model on-premises for privacy or sovereignty reasons, and accept that you are paying for control rather than saving money.
- Rent GPUs for bursts of batch work on open models, fine-tuning runs or evaluations, and shut them down afterwards.
- Measure cost per completed task on a sample of real work before committing either way. Our AI agent ROI calculator helps frame the value side.
For the software side of running models locally, see our comparison of Ollama, LM Studio and llama.cpp. For API-side cost modelling beyond list prices, see LLM inference cost comparison and the best inference APIs. Polish readers can find the version of this analysis with PLN prices in Lokalna AI czy API?
If the numbers point you to an API for open models such as Kimi K2.6 or GLM-5.3, the provider matters too: the same model can cost half as much on one route as on another. See Ollama Cloud vs OpenRouter for a side-by-side price check.
The bottom line
The September launches show AI cost falling from two directions, but they do not fall at the same rate for everyone. Cloud prices fall for everyone the day a provider cuts them. Local hardware only gets cheaper per token if you keep it busy, and the largest models are exactly the ones a desk-sized cluster keeps busy most slowly. For most teams in 2026, the rational default is an API with caching and batching, with local hardware reserved for data that cannot leave the building and for smaller models that fit comfortably on a single machine.
FAQ
Is running an LLM locally cheaper than using an API?
Usually not for large models. In our example, a four-Mac Studio cluster running Kimi K2.6 costs about $1,425 a month, while the same model’s API costs about $199 for the same workload. Local becomes cheaper mainly for smaller models, steady batch work, or when data cannot leave your premises.
How much does Claude Opus 5.5 cost?
Claude Opus 5.5 lists at $4 per million input tokens and $20 per million output tokens, with cache reads at $0.20 per million. Through the Batch API it costs half: $2 input and $10 output.
Can a Mac Studio run a trillion-parameter model?
Not a single one today. Kimi K2.6 at its native INT4 precision needs roughly 600 GB of memory. At WWDC in June, four linked Mac Studios ran it at a reported 25–28 tokens per second. The 512 GB M5 Ultra ships in late October.
How much electricity does a Mac Studio use for AI?
Apple lists the M5 Ultra Mac Studio at 9 W idle and 385 W maximum. Running flat out all month costs about $40 at US commercial rates or about 310 PLN at Polish business rates, and less under typical inference loads.
Why is prompt processing speed important for local AI?
Agents and coding tools send long prompts. On Apple Silicon, reading a prompt is much slower than on datacenter GPUs, so a long context can take tens of seconds or minutes before the first output token appears.
What is the best way to cut an LLM API bill?
Use prompt caching for repeated context, send non-urgent work through a batch API at about 50% off, and route simpler tasks to a smaller model. Measure cost per completed task, not per token.
Why run an LLM locally at all?
For privacy and data residency, offline operation, a fixed model version that cannot be deprecated, and predictable costs. These are control benefits, and for large models they usually cost more than an API.
Sources and further reading
- Anthropic, Introducing Claude Opus 5.5.
- Anthropic, Claude API pricing.
- Apple Newsroom, The new Mac mini and Mac Studio are available today.
- Apple, Mac Studio technical specifications.
- Apple Support, Mac Studio power consumption and thermal output.
- Apple WWDC26, distributed inference with MLX.
- Reuters (via Star-Advertiser), Apple takes aim at Microsoft and Nvidia with AI-ready Macs.
- Moonshot AI, Kimi K2.6 model card.
- Kimi platform, API pricing.
- MacStories, M5 Ultra Mac Studio review for local AI.
- Jeff Geerling, 1.5 TB of VRAM on Mac Studio with RDMA over Thunderbolt 5.
- DeepSeek R1 prompt processing and generation on M3 Ultra (llama.cpp vs MLX).
- US EIA, Electric Power Monthly, Table 5.6.A.
- Eurostat, Electricity prices for non-household consumers.
- Runpod, GPU cloud pricing.
- Lambda, GPU cloud pricing.
Prices checked on September 28, 2026; Claude Fable 5.2 price added November 12, 2026. Hardware prices for 256 GB and 512 GB configurations and third-party throughput figures should be re-checked before purchasing decisions.

