LLM API Pricing Compared: GPT, Claude, and Gemini Costs in 2026

An LLM API pricing comparison becomes misleading as soon as it collapses input and output into one number. GPT, Claude, and Gemini charge different rates for the two directions, and many real workloads are not balanced. A retrieval service may send a long context and return a short answer. A coding agent may produce thousands of output tokens across repeated tool turns.

This page compares the numbers. It is deliberately different from our existing gateway buying framework, which covers compatibility, integration work, and evaluation design. Here, the task is narrower: take dated public prices, apply them to the same token counts, and see what changes.

Current GPT, Claude, and Gemini API prices

The table below uses standard, non-batch API prices published by the model vendors and GlideflowAI’s live route prices on July 30, 2026. All amounts are USD per one million tokens.

Official sources:

• Anthropic’s Claude pricing page lists Opus 5 at $5/$25. It lists Sonnet 5 at a promotional $2/$10 through August 31, 2026, followed by $3/$15 from September 1.
• OpenAI’s API pricing page lists the standard short-context rates used here: GPT-5.5 at $5/$30 and GPT-5.4 at $2.50/$15.
• Google’s Gemini API pricing page lists Gemini 3.5 Flash standard at $1.50/$9 and Gemini 3.1 Flash-Lite standard text/image/video input at $0.25 with $1.50 output.

The Glideflow numbers are calculated from the live pricing endpoint as the public API specifies: model_ratio × 2 for input, then input × completion_ratio for output. The extra decimal places on Gemini are intentional. Rounding $1.1625 to $1.16 before a large estimate introduces avoidable error.

These rows are price comparisons, not equivalence claims. The APIs differ in context rules, caching, supported modalities, tools, rate limits, and native features. A model name exposed through a gateway also does not imply endorsement or a partnership with its developer.

The basic cost formula

For a request with no separately priced cache or modality terms:

request cost =
  (input tokens / 1,000,000 × input price)
  + (output tokens / 1,000,000 × output price)

Keep the two terms separate. A single “price per token” hides the part of the request that often dominates.

For example, 120,000 input tokens and 8,000 output tokens on the official GPT-5.5 standard price produce:

Input:  0.120 × $5  = $0.60
Output: 0.008 × $30 = $0.24
Total:                 $0.84

The same token counts on the current Glideflow GPT-5.5 route produce:

Input:  0.120 × $3  = $0.36
Output: 0.008 × $18 = $0.144
Total:                  $0.504

That arithmetic says nothing about whether the request succeeds, how long it takes, or whether every feature behaves the same. It gives you a budget line you can verify against usage records.

Scenario 1: long input, short answer

Consider a document-analysis job that sends 500,000 input tokens and returns 5,000 output tokens. This is a useful stress case for pricing because input outweighs output 100 to 1.

The formula for Claude Opus 5 official is 0.5 × $5 + 0.005 × $25 = $2.625. For Gemini 3.5 Flash official, it is 0.5 × $1.50 + 0.005 × $9 = $0.795.

Do not treat this table as a recommendation to send a 500,000-token prompt to every model. It is a price calculation using the same counts. Your client still has to respect each route’s current context and request limits, and the useful output may differ.

Caching can also change this scenario substantially. Anthropic, OpenAI, and Google publish model-specific cache terms; those terms are not uniform. If the 500,000-token prefix is reused, add cache-write and cache-read rows based on the exact provider and tier instead of applying the ordinary input rate to every turn.

Scenario 2: output-heavy generation

Now compare 30,000 input tokens with 60,000 output tokens. This shape can appear in code generation, migration drafts, or a multi-step agent transcript. Output is where the price spread becomes more visible.

GPT-5.5 official, for example, is 0.03 × $5 + 0.06 × $30 = $1.95. Only $0.15 comes from input. The other $1.80 comes from output.

This is why an output cap is a real cost control. Ask for the smallest useful artifact, stop an agent after the named test passes, and avoid automatically requesting both a full patch and a prose reproduction of the same patch. Shorter is not always better, but unbounded output makes the budget hard to predict.

Scenario 3: a monthly production estimate

Suppose a service handles 20,000 requests per month. Each request averages 8,000 input tokens and 800 output tokens. The monthly total is 160 million input tokens and 16 million output tokens.

Official standard-price calculations:

Current Glideflow menu calculations:

This workload is still an example, not an industry average. Replace the two token totals with your logs. If you do not have logs yet, instrument one week of traffic before negotiating a yearly budget.

Price differences inside each family

The family name alone is not enough for a cost estimate.

Claude Opus 5 and Sonnet 5 have different official prices, and Sonnet 5’s current official price is explicitly promotional. A spreadsheet built on $2/$10 without the August 31 end date will become stale. If you are examining Opus specifically, the deeper Claude Opus 5 cost guide covers cache reads, cache writes, reasoning tokens, and agent loops.

GPT-5.5 and GPT-5.4 also have different standard prices. OpenAI publishes separate long-context rates for some models, so do not assume the short-context row applies after crossing a documented threshold. This article uses the standard short-context rows because they give a clean like-for-like token calculation.

Gemini’s official table separates Standard, Batch, Flex, and Priority modes for supported models. It also distinguishes audio input from text/image/video input on Gemini 3.1 Flash-Lite. The $0.25 input figure in this comparison is the standard text/image/video rate, not the audio rate.

Those details make automated price scraping risky. A parser that grabs the first dollar amount next to a model name can silently mix tiers, modalities, or promotional periods.

What a gateway changes

A gateway can give one key and one compatible base URL access to several model families. That reduces the number of client integrations you maintain and lets you change an explicit model ID without moving credentials between three SDKs. The /models catalog exposes the currently configured IDs.

It also adds another operational layer. You need to test:

• the endpoint shape your client uses;
• streaming and tool calls;
• returned usage fields;
• model availability for your account or group;
• error handling and retries;
• billing behavior for caching or non-text modalities.

Price is one reason to evaluate a gateway, not a substitute for that test. If you need a provider-native beta feature, direct access may be the clearer choice. If your application switches among families using ordinary OpenAI-style chat requests, a compatible gateway may reduce integration work.

The correct comparison is therefore:

token cost
+ retry cost
+ engineering and operations cost
+ the cost of requests that do not complete the task

Only the first term appears in a public price table.

Build a comparison from your own logs

Export one representative week with these columns:

timestamp, route, model_id, input_tokens, output_tokens,
cache_write_tokens, cache_read_tokens, status, retries, task_type

Then price each row with a dated rate card. Do not overwrite old prices when a vendor changes a rate; attach an effective date. This keeps historical invoices explainable.

For agent workloads, add turn_count and a completion result such as tests_passed. A model with a lower per-token price can still cost more per accepted task if it produces longer loops or more retries. That outcome must come from your experiment, not from an unsourced benchmark claim.

Before sending production traffic, compare one small request through the native provider and one through the gateway route. Inspect the usage records, response format, and tool behavior. You can generate a restricted starter configuration on /start, then check the live rate again on /pricing before running the monthly calculation.