LLM Model Pricing in July 2026: Every Major API and Open Model

Use this when you want one current, apples-to-apples view of what large language models cost in July 2026 — across the closed-API frontier, the open-weight models that now match it, and the hosting providers (Together AI, Groq, Fireworks, Hugging Face, and others) that serve those open models.

The fast answer: in July 2026 the LLM market has three price tiers that matter. Closed frontier APIs (GPT-5.5, Claude Opus 4.8, Gemini 3.1 Pro) run roughly $2–$5 per 1M input and $9–$30 per 1M output. Open-weight models (DeepSeek V4, Llama 4, Qwen 3.6, GLM-5, GPT-OSS) hosted on specialist providers are 5–50x cheaper per token — often $0.05–$0.60 per 1M. And the same open model costs different amounts depending on which host serves it, because Together AI, Groq, Fireworks, DeepInfra, and Hugging Face each price their own hardware and margin. "Cheapest" depends on your workload shape and which host you route to, not on a single rate card.

Pricing pages have never been harder to compare. Closed vendors quote per-token rates by model family. Open-model hosts quote per-token rates that differ for the same weights. Aggregators add a credit fee. Cloud marketplaces bury it in a region matrix. This guide puts all three worlds in one place, in the same units, for July 2026.

If you want to compare what these choices mean after deployment — the actual bill, not the rate card — see AI cost monitoring. For a closed-API-only deep dive, the companion AI API pricing guide has the full closed-vendor breakdown.

Quick answer

For a July 2026 snapshot:

• Closed frontier APIs are the premium tier: GPT-5.5 and Claude Opus 4.8 sit at $5 input / $25–$30 output per 1M tokens. You pay for managed reliability, tooling, and the top of the reasoning frontier.
• Open-weight models have stopped being the budget alternative and become a default. DeepSeek V4, Llama 4, Qwen 3.6, GLM-5, and OpenAI's GPT-OSS family match closed models on many workloads at a fraction of the price.
• Open-model hosting is a market of its own. The same GPT-OSS-120B model is ~$0.15/$0.60 on Groq, ~$0.039/$0.19 on DeepInfra, and ~$0.35/$0.75 on Cerebras — because you are buying each provider's hardware, throughput, and margin, not just the weights.
• The trap is that "cheap" is fragile. A model switch, a prompt-length change, or a routing tweak can erase the savings overnight. Track spend by workload, not by the rate card. See LLM cost monitoring.

How to read LLM pricing in 2026

Almost all text LLMs are still priced per million tokens, split into input (the prompt you send) and output (the response generated). A token is roughly 0.75 English words, so ~1,300 tokens per 1,000 words. Three rules carry most of the cost math:

1. Output is priced higher than input — usually 3–6x. Output-heavy workloads (long generations, agents) are dominated by the output rate; retrieval-heavy RAG is dominated by the input rate.
2. Context size can change the rate, not just the volume. Several 1M-context models (Claude, Gemini) move to higher long-context pricing above 200K input tokens. See long-context pricing above 200K tokens.
3. Caching and batch are real discounts. Cached input and Batch APIs commonly cut 50% each and can stack. On some hosts (Groq, Fireworks) a cached + batched call runs at ~25% of the on-demand rate.

The formula that turns any rate card into a monthly estimate:

Monthly cost = ((input_tokens/1,000,000 × input_rate)
             +  (output_tokens/1,000,000 × output_rate))
             ×  requests_per_month

Closed frontier APIs (July 2026)

These are the managed, proprietary-weight APIs. Rates below are the current list prices for this July 2026 snapshot.

Mistral rates are market-quoted ranges; validate the exact SKU and deployment path at checkout.

How to think about the closed tier: at the flagship level, OpenAI and Anthropic have converged — GPT-5.5 and Claude Opus 4.8 share the $5 input rate and differ mainly on output ($30 vs $25). The real spread is at the low end (Gemini 2.5 Flash Lite, GPT-5 Mini, Grok 4.1-fast) and in the batch/cache discounts. For the head-to-head, see OpenAI vs Anthropic pricing. Bedrock and Vertex are governance choices as much as price choices — Bedrock vs Vertex AI pricing covers what teams actually pay.

Open-weight models (July 2026)

In 2026 open-weight models stopped being the budget option and became the default for high-volume work. These are openly downloadable weights (licenses vary — open-weight is not always OSI open-source), served either self-hosted or through the hosting providers in the next section. Representative served-API rates:

The headline is unit economics: an open-weight model like DeepSeek V4 Flash or GPT-OSS-120B can be 10–50x cheaper per token than a closed flagship, and several now clear the quality bar for classification, extraction, summarization, and bulk coding. The trade-off moves from "quality vs price" to "who operates it, and at what reliability." See Closed vs open AI models in 2026 for the portfolio framing.

Open-model hosting providers (July 2026)

This is the part most pricing guides skip. The same open weights cost different amounts depending on who serves them — because you are renting that provider's hardware, throughput, and margin. Below is what the leading hosts charge and how their pricing models differ.

The one number that matters most: the price of the same model varies wildly by host. GPT-OSS-120B is ~$0.039/$0.19 on DeepInfra, ~$0.15/$0.60 on Groq, and ~$0.35/$0.75 on Cerebras. That is not a quality difference in the weights — it is a difference in hardware, speed, and margin. The cheapest per-token host is not automatically the best value: Groq and Cerebras charge more but deliver dramatically higher throughput, which can lower total cost for latency-bound or agentic workloads that would otherwise stall.

How to choose a hosting provider

• Optimizing pure per-token cost at scale? DeepInfra (owns its stack, no aggregator margin) and Together AI (broad catalog) are the usual starting points.
• Latency- or throughput-bound (chat, agents, tool loops)? Groq and Cerebras win on speed, which often beats a lower per-token rate on total cost.
• Want one API across many hosts with failover? OpenRouter (aggregator) or Hugging Face Inference Providers (pass-through routing) — you trade a small fee for portability.
• Need fine-tuning or dedicated capacity? Together AI (LoRA fine-tuning), Fireworks (tuning + speed tiers), or Baseten (dedicated deployments).
• GPU-heavy or non-text models? Replicate's compute-time model fits better than per-token.
• Enterprise governance already on a hyperscaler? Route open models through Bedrock or Vertex Model Garden — see Hugging Face vs direct provider APIs.

What this costs in practice

A worked example — a content-moderation classifier: 400-token input, 50-token output, 2M requests/month.

Same task, ~26x spread — driven first by open vs closed, then by which host serves the open model. This is exactly why the rate card is a starting point, not an answer: the only number that matters is what the workload actually bills once it is live.

The pricing traps to watch

• Output-length blindness. Output is 3–6x input. A verbose system prompt or an agent that "thinks out loud" quietly multiplies the output bill.
• Long-context cliffs. Claude and Gemini move to higher rates above 200K input tokens. RAG pipelines that grow their retrieved context drift over the cliff without anyone changing a model.
• Same-model host drift. Routing a model through a different host (or letting an aggregator re-route) can change your effective rate 3–10x with no code change.
• Idle GPU on dedicated endpoints. Hugging Face Endpoints, Baseten dedicated, and self-hosting bill for capacity, not tokens — an always-on GPU costs the same at 5% utilization as at 95%.
• Tool-call and feature surcharges. xAI bills web/X/code tool calls separately; several hosts price vision and audio differently from text.

Every one of these is invisible on a pricing page and obvious on the invoice. That gap is the whole reason to monitor spend by workload rather than trust the rate card.

FAQ

What is the cheapest way to run an LLM in July 2026?

For most high-volume text workloads, an open-weight model (GPT-OSS, Llama 4, DeepSeek V4 Flash, Qwen 3.6) on a direct-stack host like DeepInfra or Together AI is the cheapest per token — often $0.04–$0.20 per 1M input. The cheapest closed option is a low tier like Gemini 2.5 Flash Lite ($0.10/$0.40) or GPT-5 Mini ($0.25/$2.00). "Cheapest overall" and "cheapest for your workload" are different questions — see cheapest AI API for chat, RAG, and coding.

Why does the same open model cost different amounts on different hosts?

Because you are paying for the provider's hardware, throughput, and margin — not the weights, which are free to download. In July 2026, GPT-OSS-120B is roughly $0.039/$0.19 on DeepInfra, $0.15/$0.60 on Groq, and $0.35/$0.75 on Cerebras. The pricier hosts typically deliver far higher tokens-per-second, which can reduce total cost on latency-bound or agentic workloads even at a higher per-token rate.

Are open models actually cheaper than closed APIs once you include infrastructure?

On hosted open-model providers (Together AI, Groq, Fireworks, DeepInfra, Hugging Face), yes — you pay per token with no infrastructure to run, and the rates are 5–50x below closed flagships. If you self-host, you must add GPU, autoscaling, observability, and on-call costs, which only pay off at steady high volume. Most teams start managed and self-host later.

What do the open-model hosting providers charge?

Roughly, per 1M tokens on popular open models in July 2026: DeepInfra is the cheapest direct (e.g. GPT-OSS-120B $0.039/$0.19); Groq runs $0.05–$0.60 with batch/cache discounts; Fireworks spans ~$0.20 (8B) to ~$0.90 (70B); Together AI's catalog spans $0.05–$9; Cerebras is ~$0.50–$1.50 with the highest throughput. Hugging Face routes at pass-through provider rates (no markup), and OpenRouter aggregates hosts with ~5.5% credit fee and no inference markup.

How do I compare LLM providers on price fairly?

Put every option in the same units ($/1M input and $/1M output), estimate your average input and output tokens per request, multiply by monthly volume, and apply any batch/cache discount you can actually use. Then validate against real spend — list prices ignore retries, tool calls, long-context cliffs, and idle capacity. StackSpend does this continuously across providers: AI cost monitoring.

Track LLM spend across every provider

The hard part of LLM pricing in 2026 isn't any single rate card — it's that a modern stack spans a closed API, one or two open-model hosts, and sometimes an aggregator on top, each invoicing separately in different units on different cycles. The combined picture doesn't exist unless you build it.

Connect your providers to StackSpend for one view of total LLM spend, model-level breakdown, daily anomaly detection, and pace-to-forecast alerts — so a model switch or a runaway agent is caught the day it moves, not on the invoice. Start with LLM cost monitoring or provider setup guides for OpenAI, Anthropic, and Hugging Face.

Related reading

• Current AI API Pricing (July 2026): OpenAI, Grok, Anthropic, Gemini
• Closed vs Open AI Models in 2026: A Practical, Balanced Guide
• Cheapest AI API in 2026 for Chat, RAG, and Coding
• OpenAI vs Anthropic Pricing in 2026
• Long-Context AI Pricing in 2026: What Happens Above 200K Tokens
• Hugging Face vs Direct Provider APIs: Cost Trade-offs in 2026

References

• OpenAI Pricing
• Anthropic Claude API Pricing
• Google Vertex AI Generative Pricing
• Amazon Bedrock Pricing
• xAI Models and Pricing
• Mistral Pricing
• Together AI Pricing
• Groq On-Demand Pricing
• Fireworks AI Serverless Pricing
• DeepInfra Pricing
• Hugging Face Inference Providers Pricing
• Hugging Face Inference Endpoints Pricing
• OpenRouter Provider Directory
• Cerebras Pricing
• SambaNova Pricing
• DeepSeek Models and Pricing