LLM API pricing compared: OpenAI, Claude, Gemini, DeepSeek and Grok

TL;DR

• On LLM API pricing as of October 15, 2026, the mid-tier flagships from OpenAI (gpt-6.1-sol), Anthropic (Claude Sonnet 5.5) and Google (Gemini 4 Argon) all list $2 per million input tokens and $10 per million output tokens.
• DeepSeek is the cheapest of the five providers on list price, and it is the only one that discounts by time of day: off-peak rates are half the peak rates.
• OpenAI, Anthropic and Google each charge 50 percent of standard rates for batch requests, and cache reads cost between 2.5 and 10 percent of base input on most current models.
• Scheduled changes are already on the pages: Gemini 4 Argon doubles on December 1, 2026 and Gemini 3.8 Flash doubles on January 1, 2027.
• Comparing providers on one bill needs per-request cost data that applies each provider’s own rules, which is what gateways such as Bifrost compute from a synced pricing catalog.

LLM API pricing is the per-token rate a model provider charges for text sent to a model (input) and text the model generates (output), usually quoted in US dollars per million tokens. As of October 15, 2026, those list prices range from $0.10 to $10 per million input tokens and from $0.40 to $50 per million output tokens across the five providers compared here: OpenAI, Anthropic, Google, DeepSeek and xAI. The list price is only the starting point. Batch queues, prompt caches, long-context thresholds, data-residency surcharges and, in DeepSeek’s case, the hour of the day each change what a request actually costs.

How LLM API pricing works

Every major provider bills by the token, with separate rates for input and output and a discounted rate for input served from a prompt cache. Output is always the most expensive class, typically four to six times the input rate, and reasoning tokens a model generates while thinking are billed at the output rate even when the API does not return them.

A token is the unit a model reads and writes: a fragment of a word, a number or a punctuation mark. Google’s token guide estimates that a Gemini token “is equivalent to about 4 characters” and that 100 tokens is about 60 to 80 English words. DeepSeek’s documentation puts one English character at roughly 0.3 tokens. The ratios differ because each provider uses its own tokenizer, and that difference matters when comparing prices: Anthropic’s pricing page notes that Claude 4.7 and later models use a tokenizer that “produces approximately 30% more tokens for the same text,” so the same prompt can cost more on a model with an identical per-token price.

A single request can carry up to six billable components, shown in Figure 1:

• Uncached input: prompt tokens processed at the base input rate.
• Cached input: prompt tokens read from a cache, billed at a fraction of the input rate.
• Cache writes: tokens stored in a cache, billed at 1.25 to 2 times the input rate where the provider charges for writes.
• Visible output: the answer the application receives.
• Reasoning tokens: internal thinking tokens, billed as output. OpenAI’s reasoning guide states that they “are not visible via the API” but are billed as output tokens.
• Tool fees: per-call charges for server-side tools such as web search, on top of the tokens those tools add to the context.

Figure 1: Output and reasoning tokens share the highest rate, so they usually dominate the bill even when they are a minority of the tokens.

Tool use also adds hidden input. Anthropic’s pricing page lists a tool-use system prompt of 286 tokens on Claude Sonnet 5.5 that is added whenever tools are present, before counting the tool definitions themselves. The broader cost dynamics of models that think before answering are covered in the reasoning-model era has a cost problem.

LLM pricing comparison: flagship models

The flagship and mid-tier models from the three largest labs now share a price point: $2 per million input tokens and $10 per million output tokens for OpenAI’s gpt-6.1-sol, Anthropic’s Claude Sonnet 5.5 and Google’s Gemini 4 Argon. They separate on cached-input rates, long-context rules and scheduled price changes rather than on the headline number.

All prices are per million tokens, in US dollars, at standard (non-batch) rates, from each provider’s pricing page as of October 15, 2026. “Cached input” is the cache-hit or cache-read rate.

Three patterns stand out. First, output prices differ more than input prices: grok-4.7 charges $6 per million output tokens against $10 for its peers, which matters for generation-heavy work. Second, Anthropic is the only one of the three large labs that bills its current models at one rate across the whole context window; its pricing page states that “a 900k-token request is billed at the same per-token rate as a 9k-token request” on Claude 4.6 and later models other than Haiku 5.5. Third, DeepSeek’s flagship undercuts the field on every column at peak rates and halves again off-peak.

For a ranking of these models on capability rather than price, see the top AI models of October 2026; for models whose weights can be self-hosted, the open-weight model rankings.

OpenAI API pricing

OpenAI’s API pricing page lists gpt-6.1-sol at $2 input, $0.10 cached input and $10 output per million tokens, gpt-6-luna at $0.10, $0.01 and $0.50, and the top model, gpt-6-astra, at $10, $1 and $50. Every current model has four service tiers: Standard, Batch, Flex and Fast.

The OpenAI pricing page splits each current model into short-context and long-context columns, with the boundary at 272K input tokens. Above it, gpt-6.1-sol’s input rate doubles to $4 and its output rate rises 50 percent to $15. Older models remain listed at their original prices, including gpt-5.4 at $2.50 and $15, gpt-5-mini at $0.25 and $2, and gpt-4o at $2.50 and $10.

The service tiers work as follows:

• Batch halves the price. OpenAI’s Batch API guide describes “50% lower costs” for asynchronous jobs that complete within 24 hours.
• Flex charges batch rates for synchronous requests. The flex processing guide trades lower cost for “slower response times and occasional resource unavailability,” and states that a request rejected with a 429 Resource Unavailable error is not charged.
• Fast (renamed from Priority on July 30, 2026) doubles the price: gpt-6-sol lists $4 input and $20 output in Fast mode. An Ultrafast tier for gpt-6-astra and gpt-6.1-sol costs six times standard.

Prompt caching is automatic on recent models, but GPT-5.6 and later models charge for cache writes. OpenAI’s prompt caching guide states that writes cost 1.25 times the uncached input rate and reads cost 0.1 times, or 0.05 times on gpt-6.1-sol, which is why its cached rate ($0.10) is half that of gpt-6-sol ($0.20) at the same $2 input price. The guide’s own arithmetic: one write and nine full reads cost 2.15 times the ordinary input cost, against 10 times with no cache.

Two surcharges apply on top. Regional processing (data residency) endpoints carry a 10 percent uplift for models released on or after March 5, 2026, and so do FedRAMP endpoints. Web search costs $10 per 1,000 calls plus the search content tokens at model rates. The page also notes that gpt-5.6-sol’s promotional pricing runs “at least through November 21, 2026.”

Claude API pricing

Anthropic’s pricing page lists Claude Sonnet 5.5 at $2 input and $10 output per million tokens, Claude Opus 5.5 at $4 and $20, Claude Haiku 5.5 at $0.10 and $0.50 for prompts up to 100,000 tokens, and Claude Fable 5.1 at $10 and $50. Batch requests cost half, and cache-read discounts are the deepest of any provider compared.

The Anthropic pricing page prices prompt caching in three parts: a 5-minute cache write at 1.25 times base input, a 1-hour cache write at 2 times, and cache hits at a model-specific fraction. Hits cost 0.1 times base input on most models, 0.05 times on Claude Opus 5.5 and Sonnet 5.5, and 0.025 times on Claude Fable 5.1. Anthropic’s own break-even rule: caching “pays off after one cache read for the 5-minute duration” and after two reads for the 1-hour duration. The page adds that these multipliers stack with the Batch API discount and with data residency.

Other pricing rules on the page:

• Batch API: 50 percent off input and output. Claude Sonnet 5.5 drops to $1 and $5.
• Long context: Claude 4.6 and later models, except Haiku 5.5, bill the full 1M-token window at standard rates. Haiku 5.5 rises to $0.50 input and $2.50 output when the prompt exceeds 100,000 tokens, and the higher price applies to the whole request.
• Fast mode (research preview): Claude Opus 5.5 costs $8 input and $40 output, double its standard rate. It is not available with the Batch API.
• Data residency: specifying US-only inference with inference_geo applies a 1.1 times multiplier to every token category on Claude 4.6 and later models.
• Tools: web search costs $10 per 1,000 searches; web fetch has no charge beyond tokens; code execution includes 1,550 free hours per organization per month, then $0.05 per hour per container.

A pricing history note is also on the page. Claude Sonnet 5 launched at introductory prices of $2 and $10, with an increase to $3 and $15 scheduled for September 1, 2026. Anthropic’s footnote states that the scheduled increase “will not occur.” Claude Haiku 4.5, still listed, costs ten times Haiku 5.5 at $1 and $5.

Gemini API pricing and the free tier

Google’s Gemini Developer API lists Gemini 4 Argon at $2 input and $10 output per million tokens through November 30, 2026, doubling to $4 and $20 on December 1. Gemini 3.8 Flash costs $0.75 and $3.75 through December 31, then doubles. Google is the only provider here with a free tier on production models.

The Gemini API pricing page offers five service tiers per model: Standard, Batch, Flex, Priority and an invite-only Contributor tier. Batch and Flex cost half of Standard. Priority costs 1.8 times Standard: Gemini 4 Argon lists $3.60 input and $18 output in Priority until its December price change. The Contributor tier is priced like Batch, but Google marks its content as used to improve Google’s products.

The free tier covers input and output tokens at no charge on models including Gemini 3.8 Flash, Gemini 3.6 Flash, Gemini 3.5 Flash-Lite, Gemini 3.1 Flash-Lite and Gemini 2.5 Flash-Lite. Gemini 4 Argon and Gemini 3.1 Pro Preview are not available on it. The trade-off is stated on the page: free-tier content is used to improve Google’s products, and paid-tier content is not.

Gemini pricing rules worth knowing:

• Thinking tokens: every output price is labeled “including thinking tokens.”
• Caching: implicit caching is on by default for Gemini 2.5 and newer, and Google passes the savings on automatically. Gemini 4 Argon supports only implicit caching. Explicit caches on supported models also carry a storage charge per million tokens per hour, $0.50 for Gemini 3.8 Flash through December 31.
• Long context: Gemini 3.1 Pro Preview charges $2 and $12 up to 200K-token prompts and $4 and $18 above.
• Grounding: 5,000 free Google Search grounding requests per month, shared across Gemini 3 and newer models, then $14 per 1,000.

The budget models are where Gemini competes hardest. Gemini 3.1 Flash-Lite lists $0.25 input and $1.50 output; Gemini 2.5 Flash-Lite lists $0.10 and $0.40, the lowest output price from any of the three large labs. A deeper walk through Google’s tiers is in Gemini API pricing in 2026 and how to cut what you pay.

DeepSeek API pricing and off-peak rates

DeepSeek’s API lists two models: deepseek-flash, served by DeepSeek-V4.1-Flash, at $0.30 input and $1.20 output per million tokens at peak, and DeepSeek-V4-Pro at $1.32 and $3.96. Off-peak rates are half the peak rates, and cache-hit input costs about 2 to 3 percent of the cache-miss price.

DeepSeek is the only provider among the five that prices by the clock. Its pricing page defines peak hours as 01:00 to 04:00 and 06:00 to 10:00 UTC, Monday through Friday, excluding Chinese public holidays; every other hour, including whole weekends, is off-peak. That makes off-peak the default for most of the week: 133 of its 168 hours.

Both models have a 1M-token context window and a maximum output of 384K tokens, support thinking and non-thinking modes, and expose OpenAI-format and Anthropic-format base URLs. Vision is supported on Flash only. DeepSeek publishes no batch tier; the off-peak discount plays the same role for work that can wait.

Billing is prepaid. The page states that fees are deducted from a topped-up or granted balance, using the granted balance first, and that DeepSeek “reserves the right to adjust” prices, recommending users check the page regularly.

Grok API pricing

xAI’s models page lists grok-4.7, its recommended model for code and chat, at $2 input, $0.50 cached input and $6 output per million tokens for prompts under 200,000 tokens. At 200,000 tokens and above, every token in the request bills at double: $4, $1 and $12.

The xAI models page gives grok-4.7 a 500K-token context window and lists several cheaper options:

• grok-4.3 and the grok-4.20 reasoning, non-reasoning and multi-agent variants: $1.25 input, $0.20 cached and $2.50 output, with a 1M-token context.
• grok-build-0.1: $1 input, $0.20 cached and $2 output, with a 256K-token context.

xAI’s long-context rule is the strictest of the five: “requests whose prompt reaches the listed token threshold are billed at the higher rate for all tokens in the request,” including output. The page notes that not every model accepts Batch API requests and directs readers to each model’s page, so no batch discount is listed alongside the main table. Grok’s $6 output price against $2 input gives it the lowest output-to-input ratio among the flagships compared, three to one against five to one elsewhere.

Cheapest LLM API by tier

The cheapest LLM API on list price is DeepSeek’s Flash model off-peak, at $0.15 input and $0.60 output per million tokens. Among the three large labs, OpenAI’s gpt-6-luna and Anthropic’s Claude Haiku 5.5 tie at $0.10 input and $0.50 output, and Google’s Gemini 2.5 Flash-Lite lists $0.10 and $0.40.

“Cheapest” has three qualifications. The first is capability: a small model that fails a task and triggers a retry or an escalation to a larger model costs more than the larger model would have cost alone. The second is token count: because tokenizers differ, a model with a lower per-token price can still need more tokens for the same text. The third is the cache: a workload with a long, stable system prompt will often find the cached-input column matters more than the input column.

Routing is the usual response to the capability problem: send easy requests to a small model and hard ones to a flagship. The mechanics and trade-offs are covered in model routing for cutting LLM token costs.

Discounts and surcharges that change the bill

The billed rate per token is the list price multiplied by up to four modifiers: service tier (batch, flex or fast), long-context tier, cache multiplier and region or time-of-day adjustments. Most stack. A batched, cached request on Claude Sonnet 5.5 pays 5 percent of the half-price batch input rate on its cached tokens.

Figure 2: Each modifier multiplies the one before it, so a batched, cached request can cost a small fraction of the list price.

Two cells need context. Google’s Gemini page notes that its prices “may differ” from those on Google Cloud’s Gemini Enterprise Agent Platform, and Anthropic’s models bought through Amazon Bedrock or Google Cloud follow those clouds’ own price lists, where regional endpoints carry a 10 percent premium over global ones for Claude 4.5 and later. A team buying the same model through a cloud marketplace should price it from that marketplace’s page, not the lab’s.

The cache columns have the largest effect on agent and chat workloads, where a long system prompt, tool definitions and conversation history repeat on every turn. The difference between provider-side prompt caching and gateway-side semantic caching, which returns stored answers for similar questions without calling the model at all, is compared in gateways with semantic caching for OpenAI and Anthropic costs.

AI token cost: a worked example

A customer-support agent handling 10,000 requests a day, each with a 5,000-token cached prefix, 1,000 new input tokens and 800 output tokens, costs about $3,150 a month on Claude Sonnet 5.5 or gpt-6.1-sol at standard rates. The same traffic costs $1,238 on Gemini 3.8 Flash and $387 on DeepSeek Flash at peak.

The workload over 30 days is 300,000 requests: 1.5 billion cached input tokens, 300 million uncached input tokens and 240 million output tokens (output includes any reasoning tokens). The calculation uses each provider’s standard cached-input rate and ignores cache-write charges, which recur only when a cached prefix expires.

The table shows four things the per-token lists hide:

• Output dominates. Output is 12 percent of the tokens but around three quarters of the cost on most rows. Shortening answers or capping reasoning effort saves more than trimming prompts.
• Cache rates reorder the field. grok-4.7 has the cheapest output among flagships, but its $0.50 cached-input rate makes its cached prefix cost five times Sonnet 5.5’s, and it lands only about 11 percent cheaper overall.
• Caching halves the bill. Without the cache, the same Sonnet 5.5 traffic would cost $6,000 a month: 1.8 billion input tokens at $2 plus $2,400 of output.
• Batch and cache stack. If the work could wait for the Batch API, Sonnet 5.5 would cost $1,575: $300 uncached input at $1, $75 cached input at 5 percent of $1, and $1,200 output at $5.

Scheduled price changes move the same table. On December 1, Gemini 4 Argon’s row doubles to $6,300. On January 1, 2027, Gemini 3.8 Flash’s doubles to $2,475. If the traffic runs mainly on weekends and outside 01:00 to 10:00 UTC on weekdays, DeepSeek’s rows halve. A budget built on October’s list prices would be wrong for two of these models within three months. For more ways to bring the totals down, see how to cut LLM API and token costs.

Tracking LLM API costs across providers

A team using more than one provider needs per-request cost computed with each provider’s own rules (cache rates, long-context tiers, batch rates, off-peak clocks) and charged to the team, product or customer that made the call. Provider dashboards cover one provider each; gateways and proxies that see every request can price them together.

The options fall into three groups. Each provider’s console reports usage and spend for its own API keys, which is accurate but siloed. Application-level metering reads the usage fields from each response and prices them in the team’s own code, which works until the rate tables go stale. Gateways in the request path compute cost centrally: Cloudflare AI Gateway reports cost as “an estimation based on the number of tokens” and lets users set custom costs for negotiated rates, and the LiteLLM proxy tracks spend for keys, users and teams from a model cost map that can be synced from GitHub.

Bifrost, an open-source AI gateway written in Go and released by Maxim AI under the Apache 2.0 license, implements the pricing rules described in this survey in its cost engine, which is why it is the worked example here. Its model catalog documentation describes:

• Pricing sync: the gateway downloads a pricing sheet at startup and, when a config store is attached, re-syncs it every 24 hours by default; the interval and the source URL are configurable.
• Tiered pricing: separate rates above 100K, 128K, 200K and 272K tokens, matching the thresholds OpenAI, Anthropic, Google and xAI publish.
• Time-of-day pricing: models can declare weekly peak windows and an off-peak multiplier; the docs cite DeepSeek’s V4 lineup as the example, with peak or off-peak decided by the request’s start time.
• Cache-aware costing: cache-read and cache-write tokens are priced at their own rates when the provider reports them, and batch and priority rates are separate fields in each pricing entry.

Figure 3: The price lookup happens after the response, from usage the provider reports, so cached and reasoning tokens are costed at their own rates.

The priced request then feeds governance. Applications authenticate with virtual keys, and the budget and limits system checks every applicable budget (provider config, virtual key, team and customer) before a request proceeds; “any single budget failure blocks the request,” and the same cost is deducted from each level afterward. Budgets reset daily, weekly, monthly, quarterly or yearly, optionally aligned to calendar boundaries in UTC. The built-in logging records tokens, cost and latency per request, asynchronously, with filters on cost range. Bifrost reaches 25+ providers and 10,000+ models through one OpenAI-compatible API, and its published benchmark reports 11 µs of added overhead per request at 5,000 RPS on an AWS t3.xlarge.

Enterprise tier. Budget alerting to Slack, Microsoft Teams, PagerDuty and webhooks, per-project budgets and log exports are part of Bifrost Enterprise.

The design of budgets, rate limits and virtual keys is examined at length in this publication’s guide to LLM cost management at the gateway.

Further reading on the same pattern covers monitoring LLM API costs in production and LLM API rate limiting with virtual keys and budgets. The project’s own LLM cost optimization write-up covers cost optimization inside Bifrost itself.

What list prices leave out

List prices describe the rate, not the bill. Four factors they do not capture are tokenizer differences between models, rate limits that force traffic onto pricier tiers, retries after failures, and prices that change on a published schedule.

Tokenizers. Per-token prices compare cleanly only when token counts match, and they do not. Anthropic’s 30 percent figure for its newer tokenizer is one documented case; Google’s four-characters-per-token and DeepSeek’s 0.3-tokens-per-character estimates are not directly comparable either. The only reliable comparison is to run a sample of real prompts through each candidate and read the usage the API returns.

Rate limits and capacity. Cheap tiers can be unavailable. OpenAI’s Flex can return 429 Resource Unavailable, DeepSeek publishes a concurrency limit of 2,500 for Flash and 500 for V4-Pro, and Gemini’s free tier runs at lower rate limits. A workload that overflows a cheap tier spills onto standard or priority rates, or onto a second provider. How teams handle that spillover is the subject of this publication’s piece on LLM failover and load balancing.

Retries and failures. A request that times out after generating output may be billed and then retried. OpenAI states that rejected Flex requests are not charged, but most providers do not publish a general rule for partially completed requests.

Scheduled changes. This survey records at least four in-flight changes on the providers’ own pages: Gemini 4 Argon doubling on December 1, Gemini 3.8 Flash doubling on January 1, gpt-5.6-sol’s promotional price running “at least through November 21,” and Anthropic’s cancelled Sonnet 5 increase. A cost model built once and not refreshed will drift. Teams comparing gateways for multi-provider traffic can find the main options in the top LLM gateways for Anthropic, OpenAI and Gemini.

Choosing a provider on price

LLM API pricing in October 2026 rewards reading past the headline rate. The three largest labs have converged on $2 input and $10 output for their mid-tier flagships, so the differences that move a bill sit in the cached-input column, the long-context threshold, the batch and flex tiers, and the dates printed in the footnotes.

For latency-sensitive, cache-heavy agent traffic, Claude Sonnet 5.5 and gpt-6.1-sol are priced identically, and Anthropic’s flat rate across a 1M-token window favors very long prompts. For generation-heavy work, grok-4.7’s $6 output rate is the lowest among flagships. For work that can wait, the batch tiers at OpenAI, Anthropic and Google halve the bill, and DeepSeek’s off-peak hours do the same without a queue. For the lowest absolute cost, DeepSeek Flash, gpt-6-luna, Claude Haiku 5.5 and Gemini’s Flash-Lite models sit within a few cents of each other per million input tokens, and the choice comes down to which one passes the workload’s own tests.

Whatever the choice, the comparison has a short shelf life. Two of the models in this survey change price within three months of publication, so per-request cost data that applies each provider’s current rules is worth more than any table, this one included.