AI API pricing is difficult to compare because the cheapest input-token rate rarely produces the cheapest production workflow. Output tokens may cost several times more than input, cached prompts can change the bill, context-length tiers may apply, and a lower-priced model may require more retries or human correction.
This guide compares current public list prices for representative OpenAI, Anthropic Claude, Google Gemini, and Alibaba Qwen text models. It also converts the rates into one normalized workload so you can estimate a real budget instead of choosing from a price-per-million-token table alone.
Price check: Rates were checked against official provider pages on July 29, 2026. Prices are in US dollars per 1 million tokens unless stated otherwise. Providers can change model names, preview status, regional availability, context thresholds, discounts, and prices. Confirm the linked official page before making a production purchasing decision.
Quick answer: which AI API is cheapest?
For raw token cost, Qwen's lower-priced models are the least expensive options in this comparison. Gemini is also highly price-competitive, especially in its Flash and Flash-Lite families. OpenAI and Claude generally carry higher list prices, but their models may still have the lowest cost per successful task when they reduce retries, tool errors, review time, or fallback traffic for a specific workload.
There is no universal winner:
- Choose by task quality first: Test your own prompts, tools, schemas, languages, and edge cases.
- Model input and output separately: Output-heavy generation can produce a very different ranking from classification or extraction.
- Include failure costs: Retries, fallback calls, human review, and customer-visible errors all affect the effective price.
- Recheck discounts and thresholds: Caching, batches, context length, regional endpoints, and introductory pricing can materially change the total.
AI API pricing comparison table
The following table groups representative models into flagship, balanced, and budget bands. These are buying bands, not claims of equivalent quality or capability.
| Provider | Model | Comparison band | Input / 1M tokens | Output / 1M tokens | Important pricing note |
|---|---|---|---|---|---|
| OpenAI | GPT-5.6 Sol | Flagship | $5.00 | $30.00 | Standard text-token list price |
| Anthropic | Claude Opus 5 | Flagship | $5.00 | $25.00 | Standard prompt and completion price |
| Gemini 3.1 Pro Preview | Flagship | $2.00 | $12.00 | Rate shown for prompts up to 200K tokens; higher long-context tier applies above that threshold | |
| Alibaba Cloud | Qwen3.7-Max | Flagship | $2.50 | $7.50 | Global deployment, up to 256K-token context tier |
| OpenAI | GPT-5.6 Terra | Balanced | $2.50 | $15.00 | Standard text-token list price |
| Anthropic | Claude Sonnet 5 | Balanced | $2.00 | $10.00 | Introductory price through August 31, 2026; $3.00 input and $15.00 output from September 1, 2026 |
| Gemini 3.6 Flash | Balanced | $1.50 | $7.50 | Standard paid tier; Batch is listed separately | |
| Alibaba Cloud | Qwen3.7-Plus | Balanced | $0.40 | $1.60 | Global deployment, up to 256K-token context tier |
| OpenAI | GPT-5.6 Luna | Budget | $1.00 | $6.00 | Standard text-token list price |
| Anthropic | Claude Haiku 4.5 | Budget | $1.00 | $5.00 | Standard prompt and completion price |
| Gemini 3.5 Flash-Lite | Budget | $0.30 | $2.50 | Standard paid tier; lower Batch pricing is listed separately | |
| Alibaba Cloud | Qwen3.7-Flash | Budget | $0.03 | $0.13 | Global deployment rate shown for requests up to 32K tokens; higher context tiers cost more |
Official sources: OpenAI API pricing, Anthropic Claude pricing, Gemini API pricing, and Alibaba Cloud Model Studio pricing.
Normalized workload cost: 1,000 production jobs
Static token rates become more useful after you apply the same request shape to every candidate. Assume a workload processes:
- 1,000 completed jobs
- 20,000 input tokens per job
- 2,000 output tokens per job
- no cached-input or batch discount
- no retries or fallback calls
That equals 20 million input tokens and 2 million output tokens.
The formula is:
workload cost = (input tokens / 1,000,000 × input rate)
+ (output tokens / 1,000,000 × output rate)
Flagship-band estimate
| Model | Input cost | Output cost | Total for 1,000 jobs |
|---|---|---|---|
| GPT-5.6 Sol | $100.00 | $60.00 | $160.00 |
| Claude Opus 5 | $100.00 | $50.00 | $150.00 |
| Gemini 3.1 Pro Preview | $40.00 | $24.00 | $64.00 |
| Qwen3.7-Max | $50.00 | $15.00 | $65.00 |
Balanced-band estimate
| Model | Input cost | Output cost | Total for 1,000 jobs |
|---|---|---|---|
| GPT-5.6 Terra | $50.00 | $30.00 | $80.00 |
| Claude Sonnet 5, introductory rate | $40.00 | $20.00 | $60.00 |
| Gemini 3.6 Flash | $30.00 | $15.00 | $45.00 |
| Qwen3.7-Plus | $8.00 | $3.20 | $11.20 |
Claude Sonnet 5's same workload becomes $90.00 at the published September 1, 2026 rate: $60.00 of input plus $30.00 of output.
Budget-band estimate
| Model | Input cost | Output cost | Total for 1,000 jobs |
|---|---|---|---|
| GPT-5.6 Luna | $20.00 | $12.00 | $32.00 |
| Claude Haiku 4.5 | $20.00 | $10.00 | $30.00 |
| Gemini 3.5 Flash-Lite | $6.00 | $5.00 | $11.00 |
| Qwen3.7-Flash | $0.60 | $0.26 | $0.86 |
These totals are arithmetic comparisons, not performance rankings. A model that costs $11 per thousand jobs is not cheaper in practice if only 70% of its results are accepted while a $30 model achieves a 98% acceptance rate.
Compare cost per successful task, not token cost alone
A better production metric is cost per accepted result:
cost per accepted result = total model spend / accepted results
Suppose two candidates each process 1,000 jobs:
| Candidate | Model spend | Accepted results | Cost per accepted result |
|---|---|---|---|
| Lower-list-price model | $20 | 700 | $0.0286 |
| Higher-list-price model | $30 | 980 | $0.0306 |
The lower-price model still wins narrowly in this example, but the gap is much smaller than the list-price difference suggests. Add engineering time, customer escalations, or a paid fallback for the 300 rejected results, and the ranking may reverse.
For each model, record at least:
- Acceptance rate: The percentage of outputs that pass your automated and human quality gates.
- Retry rate: How often the same model must be called again.
- Fallback rate: How often traffic moves to a more expensive model.
- Average output length: Verbose models can create a larger bill even when input rates are low.
- Latency at the target percentile: A cheap model that misses your product SLA may be unusable.
- Tool and schema reliability: Invalid structured output or failed tool calls create hidden cost.
- Human review minutes: Manual correction can dominate token spend in business workflows.
How OpenAI API pricing works
OpenAI separates uncached input, cached input, and output pricing, and lists additional processing options such as Batch and Flex for supported models. Output rates are much higher than input rates in the models above, so response-length controls matter.
OpenAI may be a strong fit when your application is already built around its APIs and the selected model performs reliably on your evaluation set. For OpenAI-first teams, direct integration can be operationally simple. For teams that continually test other providers, the cost of maintaining separate clients, credentials, limits, and reporting becomes part of the comparison.
How Claude API pricing works
Anthropic prices standard Claude requests by input and output tokens and publishes separate rules for prompt caching, long-context requests, and batch processing. The Claude Sonnet 5 introductory period is especially important for budgeting: a pilot launched in August 2026 should not extrapolate the introductory rate into September without adjustment.
Claude pricing should be evaluated alongside long-context behavior, tool use, code quality, and the amount of review a workflow requires. For coding agents and complex business tasks, a higher token rate can be economical if the model completes more tasks without intervention.
How Gemini API pricing works
Google lists free and paid Gemini API tiers, model-specific input and output rates, and separate Batch rates for supported models. Some Gemini models also price prompts differently when context crosses a threshold, so average prompt size is not enough—you need the distribution of request sizes.
Gemini's Flash and Flash-Lite lines are attractive for high-volume workloads, while Pro models target harder tasks. Preview labels also matter: production teams should verify lifecycle status, limits, and migration plans in addition to price.
How Qwen API pricing works
Alibaba Cloud Model Studio lists global-deployment Qwen prices with context-length tiers for several models. Qwen3.7-Flash is extremely inexpensive for short requests in the published table, but the rate rises at larger context windows. Region, deployment mode, and the exact model ID should therefore be captured in every benchmark.
Qwen is compelling for cost-sensitive routing, multilingual applications, and teams that want an additional provider candidate. As with every model family, test quality, safety, latency, tool behavior, and regional availability before routing production traffic.
Cached input, Batch, and context tiers can change the winner
The headline comparison intentionally uses standard uncached synchronous rates. Real workloads may pay less—or occasionally more—because of these variables:
Cached input
Large repeated system prompts, tool definitions, policies, and document prefixes may qualify for cached-input pricing. Measure the actual cache-hit rate instead of assuming every repeated token receives the discount.
Batch processing
OpenAI, Anthropic, and Google publish discounted asynchronous or batch options for supported use cases. Batch can be valuable for evaluations, enrichment, offline classification, and nightly document processing, but it is not a substitute for a low-latency interactive endpoint.
Long-context thresholds
Gemini and Qwen publish context-dependent tiers for some models, and Anthropic documents long-context pricing conditions. A few very large requests can raise the blended rate even when the median request is small.
Different tokenizers
One million tokens from one provider is not necessarily the same amount of source text or code under another provider's tokenizer. Use provider-reported usage from actual calls rather than estimating every model from one tokenizer.
Regional and platform differences
Cloud marketplace, regional, data-residency, or managed-platform prices may differ from a provider's direct global API. Keep the endpoint and billing entity beside every price in your evaluation sheet.
A practical AI API pricing evaluation workflow
Use this seven-step process before selecting a default model:
- Freeze a representative test set. Include routine prompts, hard prompts, long context, tool calls, structured output, multilingual cases, and known failure modes.
- Pin exact model IDs. Do not benchmark an alias that may silently move to a newer model.
- Run each candidate with the same acceptance rubric. Score task accuracy, format validity, safety, latency, and reviewer effort.
- Capture provider-reported usage. Store input, cached input, output, retries, and errors for every call.
- Apply the correct price tier. Include context thresholds, cache hits, batches, introductory periods, and regional rates.
- Calculate cost per accepted result. Include fallback and retry spend, not only first-call spend.
- Canary the winner in production. Monitor quality and cost drift before expanding traffic.
A multi-model product should repeat this process whenever a provider changes pricing, releases a new model, retires a preview, or modifies an alias.
When a unified AI API gateway helps
Direct provider accounts are reasonable when one vendor is the clear standard. The operational burden grows when a product needs OpenAI for one workflow, Claude for another, Gemini for a high-volume path, and Qwen for a cost-sensitive or regional route.
A unified access layer can reduce integration overhead by providing one credential, one OpenAI-compatible endpoint, and one usage view across supported models. It does not remove the need to test provider-specific capabilities or read current pricing rules.
Flatkey is designed for this multi-model workflow. You can inspect the current model pricing catalog, compare candidates, and use an OpenAI-compatible integration to change model IDs without maintaining a separate client pattern for every provider. For implementation details, see the multi-model prompt testing workflow and the AI API cost tracking guide.
AI API pricing comparison checklist
Before approving a provider or model, confirm:
- [ ] Official price page and check date are recorded.
- [ ] Exact model ID, region, endpoint, and lifecycle status are pinned.
- [ ] Input, cached input, and output rates are separate.
- [ ] Context-length thresholds are included.
- [ ] Introductory pricing has an expiration date in the forecast.
- [ ] Batch assumptions match the product's latency needs.
- [ ] Real tokenizer usage comes from test calls.
- [ ] Retry, fallback, and human-review costs are included.
- [ ] Cost per accepted result is calculated.
- [ ] A production canary verifies the benchmark result.
Frequently asked questions
Is Gemini API cheaper than OpenAI API?
For the representative models and standard rates in this July 29, 2026 comparison, Gemini has lower raw token prices than the corresponding OpenAI buying bands. The better production value still depends on task quality, output length, retries, latency, and accepted-result rate.
Is Claude API more expensive than OpenAI API?
It depends on the selected models. Claude Opus 5 and GPT-5.6 Sol have the same $5 input rate in this snapshot, while Claude Opus 5 has a lower output rate. Claude Sonnet 5's introductory rate is below GPT-5.6 Terra, but Anthropic publishes a higher Sonnet 5 rate beginning September 1, 2026.
Why is Qwen API pricing so low?
Alibaba Cloud positions different Qwen models and context tiers for different workloads. The lowest Qwen3.7-Flash rate applies to shorter contexts, and higher tiers cost more. Low list price should be validated against quality, latency, availability, and operational requirements.
Which provider offers the cheapest API for coding agents?
There is no reliable answer from token rates alone. Coding agents generate long conversations, repeat tool schemas, produce substantial output, and may incur expensive retries. Benchmark repository navigation, patch quality, test success, tool-call validity, and human intervention, then calculate cost per accepted coding task.
How often should AI API pricing be reviewed?
Review official prices at least monthly and whenever a provider launches a model, changes a preview, announces an introductory period, or updates context and caching rules. High-volume teams should automate price-version checks and alert on material changes.
Final recommendation
Use the pricing table to create a shortlist, not a final routing decision. Qwen and Gemini lead on raw cost in many bands in this snapshot, while OpenAI and Claude may justify higher rates on workflows where quality and reliability reduce retries or review.
The durable method is simple: benchmark exact model IDs, use provider-reported token usage, apply every pricing rule, and optimize for cost per accepted task. Then keep at least one validated alternative ready, because pricing and model performance change faster than most production roadmaps.
