DeepSeek API pricing is low enough to attract attention, but the raw token rate is only the first line in a production budget. Cache behavior, output length, thinking tokens, batch eligibility, context tiers, retries, and model lifecycle changes can all move the real cost.
This guide compares DeepSeek with representative OpenAI, Anthropic Claude, Google Gemini, and Alibaba Qwen models using official public pricing checked on July 27, 2026. It also shows a reproducible cost-per-request example and a refresh workflow your team can reuse as provider rates change.
Pricing snapshot: Provider pricing changes frequently. Treat every figure below as a dated comparison, then verify the linked first-party pricing page before purchasing credits or setting production routing policy.
DeepSeek API pricing at a glance
DeepSeek's official API table currently centers two V4 model IDs. Both support non-thinking and thinking modes, and automatic context caching can sharply reduce the price of repeated input.
| DeepSeek model | Cache-hit input / 1M tokens | Cache-miss input / 1M tokens | Output / 1M tokens | Published concurrency limit |
|---|---|---|---|---|
deepseek-v4-flash |
$0.0028 | $0.14 | $0.28 | 2,500 |
deepseek-v4-pro |
$0.003625 | $0.435 | $0.87 | 500 |
Source: DeepSeek Models & Pricing.
The gap between cache-hit and cache-miss input is unusually large. That makes prompt structure and repeated context economically important. A workload that repeatedly sends the same policy, schema, document prefix, or long system prompt can behave very differently from an ad hoc chat workload even when total token counts look similar.
Concurrency also belongs in the pricing discussion. A lower token rate does not automatically produce a lower cost per successful request if the application needs extra queues, fallbacks, or retries to meet its traffic target.
DeepSeek vs OpenAI, Claude, Gemini, and Qwen pricing
There is no perfect model-to-model equivalent across providers. The table below uses current representative text models to normalize the mechanics of input and output billing—not to claim equal quality, latency, context behavior, or tool performance.
| Provider and model | Standard input / 1M | Cached input / 1M | Output / 1M | Important pricing condition |
|---|---|---|---|---|
| DeepSeek V4 Flash | $0.14 | $0.0028 | $0.28 | Automatic context caching; thinking and non-thinking modes |
| DeepSeek V4 Pro | $0.435 | $0.003625 | $0.87 | Lower published concurrency than Flash |
| OpenAI GPT-5.4 | $2.50 | $0.25 | $15.00 | Batch and lower-priority processing can change effective cost |
| Anthropic Claude Sonnet 5 | $2.00 | $0.20 | $10.00 | Introductory pricing through August 31, 2026; standard pricing starts September 1 |
| Google Gemini 3.6 Flash | $1.50 | $0.15 plus storage | $7.50 | Standard paid tier; Batch and Flex list lower rates |
| Alibaba Qwen3.7-Max | $1.65 | Context-cache discount available | $4.951 | List price; region, context tier, and temporary promotions may change billing |
Official references: OpenAI API pricing, Anthropic Claude pricing, Gemini API pricing, and Alibaba Cloud Model Studio pricing.
The headline result is clear: DeepSeek's published text-token rates are materially lower in this snapshot. The operational conclusion is less automatic. Provider models differ in capability, output behavior, included reasoning tokens, service tiers, regional availability, caching implementation, and lifecycle stability. A production comparison needs both price and workload evidence.
A reproducible cost-per-request comparison
Assume one successful request uses:
- 2,000 uncached input tokens
- 500 output tokens
- Standard synchronous processing
- No tools, grounding, images, audio, or storage charges
- No retries or failed requests
- No volume commitments or temporary discounts
The formula is:
request cost = (input tokens / 1,000,000 × input rate) + (output tokens / 1,000,000 × output rate)
| Model | Cost per request | Cost for 10,000 requests |
|---|---|---|
| DeepSeek V4 Flash | $0.000420 | $4.20 |
| DeepSeek V4 Pro | $0.001305 | $13.05 |
| Qwen3.7-Max | $0.005776 | $57.76 |
| Gemini 3.6 Flash | $0.006750 | $67.50 |
| Claude Sonnet 5, introductory rate | $0.009000 | $90.00 |
| GPT-5.4 | $0.012500 | $125.00 |
These numbers are arithmetic, not a quality-adjusted ranking. If one model produces longer answers, requires more retries, needs additional tool calls, or fails more often on the target task, the apparent token-price advantage can shrink or reverse.
For a deeper budgeting method, use a cost-per-AI-API-request framework that includes retries and successful outcomes rather than tokens alone.
Why cache economics can dominate DeepSeek cost
Using the standard input rate for every request can overstate DeepSeek spend when repeated context consistently hits the cache. It can also understate spend if prompts change too much to benefit.
Track these fields separately:
- Cache-eligible input tokens: Stable prefixes, shared instructions, repeated documents, or schemas.
- Cache-hit input tokens: The portion actually billed at the provider's cache-hit rate.
- Cache-miss input tokens: New or modified input billed at the full rate.
- Output tokens: Including reasoning or thinking tokens when the provider counts them as output.
- Cache storage and write charges: Relevant for providers that bill storage duration or cache creation separately.
Do not move one provider's assumed cache-hit percentage into another provider's forecast without measurement. DeepSeek automatic caching, OpenAI cached input, Anthropic prompt caching, Gemini context caching, and Qwen context caching do not have identical rules or charge structures.
Batch discounts are useful—but not interchangeable
OpenAI advertises a 50% Batch API discount. Anthropic's Batch API also offers 50% discounts on input and output tokens. Gemini 3.6 Flash lists Batch input at $0.75 and output at $3.75 per million tokens, half of its Standard paid-tier rates. Qwen pricing documentation separates list prices, batch discounts, context tiers, and temporary regional promotions.
Batch pricing only helps when the workload can accept asynchronous completion windows and the selected model or endpoint is eligible. Do not use a batch rate to forecast an interactive chat, agent loop, or latency-sensitive production request.
Five factors to normalize before choosing the cheapest API
1. Compare cost per successful task
Run the same representative evaluation set through each candidate model. Record tokens, retries, tool calls, latency, and task success. Divide total spend by successful outcomes.
2. Separate thinking from non-thinking workloads
DeepSeek V4 supports both modes. Qwen3.7-Max also supports thinking and non-thinking modes, while Gemini includes thinking tokens in output pricing for the compared model. A short-answer support workflow and a reasoning-heavy agent should not share one blended estimate.
3. Keep context tiers visible
Some providers increase rates for larger prompts or publish tiered prices by input length. If production prompts can cross a tier boundary, model that boundary explicitly instead of using the cheapest row for every request.
4. Measure retry and fallback overhead
The useful numerator is all provider spend, including failed attempts. The useful denominator is completed business tasks. This is where observability and centralized request logs become part of pricing analysis.
5. Track model aliases and retirement dates
Aliases can move to new snapshots, and models can be retired or repriced. Pin versions where stability matters, document fallback behavior, and assign an owner to review provider lifecycle notices.
Direct DeepSeek access vs a unified API gateway
Direct provider access can be sufficient when one team uses one model family, one billing account, and one region. The operational burden grows when the team adds provider-specific keys, invoice formats, rate limits, fallback paths, and usage controls.
A unified access layer can make comparison easier by centralizing request logs, spend visibility, quotas, and routing policy. It does not make different models identical, and teams should still validate model-specific behavior and endpoint support.
Flatkey provides one OpenAI-compatible gateway for multiple model families with centralized usage tracking. Review the current model pricing and available routes, then compare them against direct provider pricing for your workload and region.
You can also use the broader AI model pricing comparison and the focused DeepSeek vs Qwen cost guide when building a shortlist.
A scheduled DeepSeek pricing refresh workflow
DeepSeek pricing interest is high and the rate card can change quickly. Treat this page—and your internal cost model—as a maintained asset.
| Refresh step | Evidence to capture | Approval question |
|---|---|---|
| Check official DeepSeek pricing | Model IDs, cache-hit input, cache-miss input, output, concurrency | Did any rate or model name change? |
| Check lifecycle notices | Alias changes, retirement dates, version mapping | Does production code need migration? |
| Refresh comparison providers | Current OpenAI, Claude, Gemini, and Qwen representative rates | Is the comparison still fair and clearly qualified? |
| Recalculate workloads | Input, output, cache, batch, retries, successful tasks | Did the economic winner change for any workload? |
| Review regional conditions | Availability, taxes, promotions, currency, service tier | Are local costs materially different? |
| Validate internal routes | Pricing page, comparison guides, quota content | Do all conversion and education links still work? |
| Record the check date | Source URLs, reviewer, changed fields, next review | Is the page ready to republish? |
Schedule this review monthly, and trigger an out-of-cycle check when a provider announces a new flagship model, retirement, promotion, or billing change.
Frequently asked questions
How much does the DeepSeek API cost?
On July 27, 2026, DeepSeek listed V4 Flash at $0.14 per million cache-miss input tokens, $0.0028 per million cache-hit input tokens, and $0.28 per million output tokens. V4 Pro was $0.435, $0.003625, and $0.87 respectively. Recheck the official pricing page before budgeting.
Is DeepSeek cheaper than OpenAI, Claude, Gemini, and Qwen?
Its published text-token rates are lower than the representative models in this dated snapshot. That does not prove the lowest cost per successful task. Output length, retries, capability, caching, batch eligibility, and operations all matter.
Does DeepSeek charge less for cached input?
Yes. The official V4 table publishes a separate cache-hit input rate that is much lower than the cache-miss rate. Actual savings depend on whether production requests generate cache hits.
Should I compare provider rates or gateway rates?
Compare both. Direct provider rates establish a baseline. Gateway pricing should be evaluated with its included access, billing, routing, observability, support, and operational controls.
How often should a DeepSeek pricing page be updated?
Monthly is a practical baseline for a commercial comparison page. Also refresh immediately after a model launch, retirement notice, pricing change, or significant promotion.
The decision rule
Start with the official token table, but do not stop there. Measure a representative workload, separate cached and uncached input, include output and retries, and compare cost per successful task. Then schedule the source review so today's inexpensive route does not become tomorrow's stale assumption.
Explore Flatkey pricing to compare current model routes and put the refresh workflow into practice.
