Self-hosting beats frontier and mid-tier APIs at high, steady volume, and rarely beats small models or hosted open models. On rented B200s at $6.69 an hour, a model serving 3,000 tokens per second per GPU at 80% busy costs about $0.77 per million tokens, against $4.00 blended for Claude Sonnet 5.5 and $0.20 for Claude Haiku 5.5. One 8-GPU node costs $39,070 a month, so it pays off only when you would otherwise spend more than that on the API, and only if an open model is good enough for the work.
Claude, OpenAI and Gemini API prices today
Standard prices per million tokens for short prompts, without caching or batch discounts. The blended column assumes three input tokens for every output token, a common mix for chat, retrieval and agents.
| Model | Tier | Input | Output | Blended (3:1) |
|---|---|---|---|---|
| Claude Opus 5.5 Anthropic | Frontier | $4.00 | $20.00 | $8.00 |
| GPT-6 Astra OpenAI | Frontier | $10.00 | $50.00 | $20.00 |
| Gemini 4 Argon Google · $4 / $20 from December 1, 2026 | Frontier | $2.00 | $10.00 | $4.00 |
| Claude Sonnet 5.5 Anthropic | Mid | $2.00 | $10.00 | $4.00 |
| GPT-6.1 Sol OpenAI | Mid | $2.00 | $10.00 | $4.00 |
| GPT-6.1 Terra OpenAI | Mid | $1.00 | $5.00 | $2.00 |
| Gemini 3.8 Flash Google · $1.50 / $7.50 from January 1, 2027 | Mid | $0.75 | $3.75 | $1.50 |
| Claude Haiku 5.5 Anthropic · Prompts up to 100K tokens | Small | $0.10 | $0.50 | $0.20 |
| GPT-6 Luna OpenAI | Small | $0.10 | $0.50 | $0.20 |
| GLM-5.3 Together AI | Open model, hosted | $1.40 | $4.40 | $2.15 |
| DeepSeek V4.1 Flash Together AI | Open model, hosted | $0.30 | $1.20 | $0.52 |
| gpt-oss-120B Together AI | Open model, hosted | $0.15 | $0.60 | $0.26 |
Two things change the real API bill. Cached prompt tokens cost 5% of the input price on Claude Opus 5.5 and Sonnet 5.5, and as little as 5% to 10% on OpenAI and Google, so agents that resend the same context pay far less than the list price. Batch processing is 50% off on all three. Prices also move: Gemini 4 Argon doubles on December 1, 2026. See every scheduled price change.
Self-hosted cost per million tokens
A GPU bills by the hour, so its cost per token is the hourly price divided by the tokens it serves in that hour:
Cost per million tokens = GPU price per hour ÷ (tokens per second × 3,600 × utilization) × 1,000,000
Throughput is the hard part. It depends on the model, quantization, batch size and prompt length. A large dense model at low batch might serve about 1,000 tokens per second per GPU. A quantized mixture-of-experts model near saturation can serve over 10,000. One published vLLM benchmark measured 11,698 tokens per second per B200 for MiniMax-M2.5 in NVFP4, which is $0.16 per million tokens at Lambda's on-demand price with the GPU fully busy.
On B200s rented at $6.69 per GPU-hour:
| Tokens per second per GPU | 80% busy | 40% busy | 24% busy (working hours) |
|---|---|---|---|
| 1,000 | $2.32 | $4.65 | $7.74 |
| 3,000 | $0.77 | $1.55 | $2.58 |
| 10,000 | $0.23 | $0.46 | $0.77 |
Read it against the API table. At 3,000 tokens per second and 80% busy, $0.77 undercuts every frontier and mid-tier model on the list, and GLM-5.3 on a hosted API. It does not undercut Claude Haiku 5.5, GPT-6 Luna, or DeepSeek V4.1 Flash and gpt-oss-120B on a hosted API. Traffic that only follows working hours leaves GPUs about 24% busy across the week, which roughly triples the cost. Why utilization moves the cost per token.
The break-even volume
GPUs rent in 8-GPU nodes, so the real question is volume. One node costs about $39,070 a month around the clock. This is how many tokens a month that money buys on each API, against what the node can serve:
| API model | Tokens a month for $39,070 | Node serves this at 3,000 tok/s, 80% busy? |
|---|---|---|
| Claude Opus 5.5 | 4.9B | Yes, self-hosting can win |
| Claude Sonnet 5.5 | 9.8B | Yes, self-hosting can win |
| GPT-6.1 Terra | 20B | Yes, self-hosting can win |
| Gemini 3.8 Flash | 26B | Yes, self-hosting can win |
| GLM-5.3 | 18B | Yes, self-hosting can win |
| DeepSeek V4.1 Flash | 74B | No, the API is cheaper |
| Claude Haiku 5.5 | 195B | No, the API is cheaper |
At 3,000 tokens per second and 80% busy, one node serves about 50B tokens a month. If you spend less than $39,070 a month on Claude Sonnet 5.5, a node can't pay for itself on cost. If you spend more and an open model handles the work, it can. Against Claude Haiku 5.5, the API would buy more tokens than the node can serve.
What the per-token price leaves out
- 01Quality
An open model on your GPUs is not Claude, GPT or Gemini. If it needs more retries or more review per task, compare cost per finished task, not per token. Tokenizers also differ, so the same text is a different token count.
- 02People
Serving, upgrades, monitoring and on-call. The API price already includes them; your GPU price doesn't.
- 03Idle capacity
The API charges only for tokens you send. A GPU charges every hour, so quiet nights and weekends raise the cost of every token you do serve.
- 04Discounts
Cache hits and batch pricing can cut an API bill by half or more for the right workloads. Compare against what you actually pay, not the list price.
- 05Control
Self-hosting fixes your price per hour, keeps data on your infrastructure and removes rate limits. Sometimes that, not cost, is the reason to do it.
Which one to choose
| Option | Best when | Watch for |
|---|---|---|
| Frontier API (Opus 5.5, GPT-6 Astra, Gemini 4 Argon) | The hardest tasks, where quality decides the outcome | The highest per-token prices; move simpler work off it |
| Small API model (Haiku 5.5, GPT-6 Luna) | High-volume classification, extraction, routing and short answers | Quality on harder prompts; long-prompt pricing on Haiku |
| Open model on a hosted API (GLM, DeepSeek, gpt-oss) | Testing open models, or open-model volume below a node | Provider-to-provider price and speed differences |
| Self-hosted on your GPUs | Steady volume above a node's cost, data that can't leave, or rate limits that block you | Utilization, staff, and whether the open model is good enough |
Most teams end up with a mix: a frontier model for the hard work, a small or open model for volume, and their own GPUs once one workload is big and steady enough to keep a node busy.
How to decide with your own data
- 01Measure tokens by feature
Record each call's model, input and output tokens, and the feature or customer it served. The decision is per feature, not per company.
- 02Re-price on cheaper APIs first
A small model or an open model on a hosted API is often most of the saving with none of the hardware. Compare Claude Sonnet 5.5 and DeepSeek V4.1 Flash.
- 03Estimate GPUs on your volume
Use the GPU vs API calculator with your token volume, GPU price and a throughput you have measured.
- 04Once GPUs run, meter them
Split the GPU bill by each request's GPU time, track utilization by the hour, and see which API features would cost less on your spare capacity. See how self-hosted LLM cost per call works.
LLM API vs self-hosted cost: frequently asked questions
Is self-hosting an LLM cheaper than the Claude, OpenAI or Gemini API?
Against frontier and mid-tier APIs it can be, at high and steady volume. One 8-GPU B200 node rented on demand costs about $39,070 a month, the same as roughly 9.8B tokens a month on Claude Sonnet 5.5 at a 3-to-1 input-to-output mix. Against small models such as Claude Haiku 5.5 or GPT-6 Luna, and against open models on hosted APIs, self-hosting rarely wins on cost alone.
How do you calculate the cost per million tokens of a self-hosted LLM?
Divide the GPU's hourly cost by the tokens it serves in an hour, then multiply by a million: hourly price ÷ (tokens per second × 3,600 × utilization) × 1,000,000. The tokens per second depend on the model, quantization, batch size and the mix of prompt and output tokens.
How many tokens per second does a B200 serve?
It ranges widely. A large dense model at low batch may serve around 1,000 tokens per second per GPU, while a quantized mixture-of-experts model near saturation can serve over 10,000. One published vLLM benchmark measured 11,698 tokens per second per B200 for MiniMax-M2.5 in NVFP4 at 8K input and 1K output.
What does the API price include that self-hosting doesn't?
The API price includes idle capacity, scaling, upgrades, monitoring and on-call, plus discounts such as cache hits at 5% to 10% of the input price and batch processing at 50% off. Self-hosting needs people and at least one whole GPU node, and an open model is not the same model as Claude, GPT or Gemini.
Should I use an open model through a hosted API before self-hosting?
Usually yes. GLM-5.3, DeepSeek and gpt-oss run on per-token APIs such as Together AI, so you can test quality and measure volume without GPUs. Self-host when your volume would keep a node busy and the hosted open-model price is still higher than your GPU cost per token.
Do API price changes affect the comparison?
Yes. Gemini 4 Argon doubles to $4 input and $20 output per million tokens on December 1, 2026, and Gemini 3.8 Flash doubles on January 1, 2027. A rented GPU's hourly price is fixed by your contract, so price changes move the break-even point.
API, GPUs or both
See your API and GPU cost per customer in one place.
Ganivra prices every Claude, OpenAI and Gemini call and splits your GPU bill across self-hosted calls, so both show up in the same margin. 14-day free trial, no credit card required.
Prices checked November 5, 2026: Anthropic, OpenAI, Google, Together AI, and Lambda (B200 on-demand price listed from November 16, 2026). Throughput benchmark: InferenceX, May 2026. Self-hosted figures count input and output tokens together and exclude staff.