DeepSeek API Cost Calculator (2026)

Every DeepSeek API call follows the same math as OpenAI, Anthropic, or any other token-billed provider. There is no platform fee, no per-call fee, no minimum spend. You pay for what you send and what you get back, at the model's per-1M-token rate:

``` cost = (input_tokens / 1,000,000) × input_price_per_M + (output_tokens / 1,000,000) × output_price_per_M ```

The DeepSeek-specific adjustment that matters: cache-hit input. Portions of your prompt prefix that DeepSeek has seen in a recent prior call within the cache window bill at the cache-hit rate. On V3 and R1 that is exactly 10% of standard input (90% off). On V4-Flash and V4-Pro it drops to 2% and 0.83% respectively — close to free. Long stable system prompts, fixed tool schemas, and reused few-shot blocks are the typical winners. Cache activation is automatic — you do not pass a flag; DeepSeek's server-side cache matches your prompt prefix and applies the discount in billing.

Reasoning tokens on DeepSeek-R1 and DeepSeek-V4-Pro bill at the output rate even though they are not returned to the caller — the same shape as OpenAI's o-series. A model that thinks for 6,000 tokens before producing a 400-token answer bills 6,400 output tokens. Plan a 5-15x output budget on reasoning-heavy tasks vs straight chat tasks. R1 in particular has been measured generating 3,000-10,000 reasoning tokens on complex problems — model that into your per-call estimates or you will be surprised by the invoice.

Take the same representative call we use across every cost calculator on this site — a 1,000-token prompt that returns a 500-token answer, roughly a 750-word brief in and a 375-word reply out. At standard rates, the per-call cost lands as:

DeepSeek-V3: (1000 / 1,000,000) × $0.14 + (500 / 1,000,000) × $0.28 = $0.00014 + $0.00014 = **$0.00028 per call**.

DeepSeek-V4-Flash: 0.001 × $0.14 + 0.0005 × $0.28 = $0.00014 + $0.00014 = **$0.00028 per call**.

DeepSeek-V4-Pro: 0.001 × $0.435 + 0.0005 × $0.87 = $0.000435 + $0.000435 = **$0.00087 per call**.

DeepSeek-R1: 0.001 × $0.55 + 0.0005 × $2.19 = $0.00055 + $0.001095 = **$0.001645 per call** (assumes zero reasoning tokens, which is unrealistic — see below).

R1 with realistic reasoning overhead: assume R1 generates 3,000 reasoning tokens before the 500-token answer, billed as 3,500 output. Cost: 0.001 × $0.55 + 0.0035 × $2.19 = $0.00055 + $0.007665 = **$0.00822 per call**. Even with 5x output inflation from reasoning, R1 still beats GPT-5.5 ($0.020/call) by 2.4x and crushes the deprecated o1 ($0.045/call at standard rates) by 5.5x.

For non-reasoning workloads, the per-call number to anchor on is **$0.00028 on V3 or V4-Flash** — about 1/71st the price of the same call on GPT-5.5 ($0.020) and 1/3000th the price of the same call on GPT-5.5-pro ($0.120).

Multiply the per-call numbers by 100,000. This is a realistic mid-size workload — daily classification on 3,000+ records, weekly summarization, a low-volume agent loop:

DeepSeek-V3 / V4-Flash: **$28/month**. DeepSeek-V4-Pro: **$87/month**. DeepSeek-R1 (zero reasoning): **$165/month**. DeepSeek-R1 (realistic 3k reasoning per call): **$822/month**.

Compare directly: the same 100k-call workload on OpenAI GPT-5.5 costs $2,000/month. On V3, it costs $28 — a 71x reduction, or $1,972/month saved. On GPT-5.5-pro it costs $12,000/month; on DeepSeek-V4-Pro the equivalent quality tier (general-purpose, premium) costs $87/month — 138x cheaper.

Now apply the cache discount to V3, with 800 of every 1,000 input tokens being a stable system prefix that hits cache 80% of the time. Those 640 cached tokens × 100,000 calls = 64M tokens, dropping from $0.14/1M to $0.014/1M. The cached input cost: 64 × $0.014 = $0.90. Uncached input: 36M × $0.14/1M = $5.04. Output: 50M × $0.28/1M = $14.00. Total: **$19.94/month** vs $28 uncached — a 29% additional cut on already cheap pricing.

On V4-Flash with the same cache pattern (98% off on cache hits), the cached-portion cost drops to $0.18 (64M × $0.0028/1M). Total: $19.22/month. The marginal additional savings from V4-Flash's deeper cache discount over V3 is small at this volume — but at 10x+ scale, it compounds materially.

Now scale to 1M calls — a full-scale production workload (e.g., per-user summarization across a SaaS app with 30,000 active users running 33 calls/month each, or a high-volume classification pipeline):

DeepSeek-V3 / V4-Flash: **$280/month**. DeepSeek-V4-Pro: **$870/month**. DeepSeek-R1 (zero reasoning): **$1,645/month**. DeepSeek-R1 (realistic 3k reasoning per call): **$8,220/month**.

Apply the same 80%-of-input cached prefix at 80% hit rate to V4-Flash at 1M scale: cached tokens 640M × $0.0028/1M = $1.79. Uncached input 360M × $0.14/1M = $50.40. Output 500M × $0.28/1M = $140. Total: **$192.19/month** for 1 million calls. That is not a typo — under $200 for a production-scale workload that would cost $20,000 on GPT-5.5 standard pricing.

Side-by-side at 1M calls/month, identical token mix:

**OpenAI GPT-5.5**: $20,000/mo standard, ~$8,300/mo with full Batch + cache stack.

**OpenAI GPT-5.4-mini**: $3,000/mo standard, ~$1,200/mo with Batch + cache.

**DeepSeek-V3**: $280/mo standard, ~$200/mo with cache.

**DeepSeek-V4-Flash**: $280/mo standard, ~$192/mo with deep cache.

The cheapest tier on OpenAI (gpt-5.4-nano at $825/mo for this workload) is still 4-5x more expensive than the cheapest DeepSeek tier. The canonical lever order for scaling cost down on DeepSeek: (1) pick V3 or V4-Flash for non-reasoning tasks, (2) restructure prompts so the cacheable prefix is stable and front-loaded, (3) cap output length, (4) only reach for R1 when the task genuinely requires multi-step reasoning.

An agent loop is the worst-case cost shape — the model takes multiple turns per user query, replaying the full transcript each turn. Take a typical 5-turn loop with a 2,000-token system prompt + tools, growing context 800 tokens per turn (same shape as our OpenAI agent worked example for direct comparison):

Turn 1: 2,800 in / 200 out. Turn 2: 3,000 in / 200 out. Turn 3: 3,200 in / 200 out. Turn 4: 3,400 in / 200 out. Turn 5: 3,600 in / 200 out. Total: 16,000 input + 1,000 output. On DeepSeek-V3: 0.016 × $0.14 + 0.001 × $0.28 = $0.00224 + $0.00028 = **$0.00252 per 5-turn query** — about 9x a single call (the agent shape inflates cost on every provider).

Compare: the identical 5-turn loop on GPT-5.5 costs $0.11 per query. On DeepSeek-V3 it costs $0.00252 — a **43x reduction**. At 100k queries/month, GPT-5.5 bills $11,000; V3 bills $252.

Now apply cache. The 2,000-token system + tools prefix is stable across all 5 turns. If cache hits ~80% of those 2,000 tokens × 5 turns = 8,000 cached input tokens dropping from $0.14/1M to $0.014/1M: $0.00112 → $0.000112, saving roughly $0.001 per query (40% off the bill). For 100k queries/month: from $252 → $151. Cache structure is the single highest-EV change you can make to an agent prompt on any provider — DeepSeek included. Build cache-anchored prompts free with our code prompt builder.

On a 1,000-in / 500-out call, holding token volume constant:

**Input price ratio**: GPT-5.5 charges $5/1M, DeepSeek-V3 charges $0.14/1M. That is **35.7x cheaper input** on DeepSeek. **Output price ratio**: GPT-5.5 charges $30/1M, DeepSeek-V3 charges $0.28/1M. That is **107.1x cheaper output** on DeepSeek. The flatter input/output ratio on DeepSeek (2:1 vs OpenAI's 6:1) means output-heavy workloads see disproportionately larger savings vs input-heavy ones.

**Per-call cost ratio**: $0.020 on GPT-5.5 vs $0.00028 on DeepSeek-V3 = **71.4x cheaper** end-to-end. At 1M calls/month that is the difference between a $20,000 monthly bill and a $280 monthly bill — a $19,720 reduction with no other workflow change.

**Reasoning model comparison**: OpenAI's deprecated o1 charged $15 input / $60 output per 1M. DeepSeek-R1 charges $0.55 / $2.19. That is **27.3x cheaper input and 27.4x cheaper output** — roughly 96% cheaper end-to-end at comparable reasoning quality on public benchmarks (R1 is competitive with or beats o1 on MATH, AIME, and several code-reasoning tasks per published evals).

**Quality caveat**: DeepSeek-V3 and V4-Flash are *roughly* equivalent to GPT-5.5 on general chat, summarization, classification, code generation for common languages. They are not equivalent on every task. The gap typically appears on: long-context coherence past 64K tokens, novel multi-step reasoning the model has not seen patterns for, certain agentic tool-use patterns where OpenAI has invested heavily in fine-tuning. Run your own eval on your own task before you migrate a production workload.

**The rational decision rule**: for workloads where quality is comparable on a held-out eval of your actual task, DeepSeek is a no-brainer at 35-107x cheaper. For workloads where GPT-5.5 measurably wins your eval by more than ~10 percentage points on the metric you care about, the OpenAI premium may be justified — but the bar should be evidence, not vibes.

**DeepSeek-V3 ($0.14 / $0.28)**: the workhorse. General-purpose chat, summarization, classification, extraction, code generation in common languages, structured-output tasks. The default for most production traffic. 64K context. Use this unless you have a specific reason to reach for another tier.

**DeepSeek-V4-Flash ($0.14 / $0.28)**: same headline price as V3, with deeper cache discounts (98% off cache hits vs 90% on V3) and tuned for high-throughput low-latency. The sweet spot for high-volume cache-friendly workloads — long stable system prompts, repeated tool schemas, agent loops with fixed instruction blocks. If your prompt is cache-anchored, V4-Flash beats V3.

**DeepSeek-V4-Pro ($0.435 / $0.87)**: the premium general-purpose tier. Higher quality on complex reasoning, longer coherent generation, more reliable on agentic tool use. Roughly 3x V3's price — still 11x cheaper input and 34x cheaper output than GPT-5.5. Use when V3 quality is measurably insufficient on your task and you have not yet earned an upgrade to a true reasoning model.

**DeepSeek-R1 ($0.55 / $2.19)**: the reasoning model. Multi-step math, complex code synthesis with correctness constraints, scientific reasoning, planning. R1 generates chain-of-thought reasoning tokens (billed as output) before producing the visible answer. Budget 5-15x output inflation. Reach for R1 when the task genuinely requires reasoning depth that pattern-matching alone can't produce — not for chat, not for classification, not for summarization where it overspends without value-add.

**Tier decision shortcut**: start every new workload on V3 or V4-Flash. Only upgrade to V4-Pro or R1 when a held-out eval on your actual task shows the cheaper tier failing. The premium tiers exist for the cases that need them — most production traffic doesn't.

DeepSeek's cache-hit discount is the deepest of any major provider in 2026. On V3 and R1, cache hits bill at 10% of standard input (90% off). On V4-Flash, cache hits bill at $0.0028/1M — exactly 2% of standard ($0.14). On V4-Pro, cache hits bill at $0.003625/1M — 0.83% of standard ($0.435), or a 99.17% discount on the cached portion.

The cache is opportunistic and server-side. DeepSeek computes a fingerprint of your prompt prefix and caches it. Subsequent calls within the cache window that share the same prefix read from cache. The hard rule, identical to every other prompt-cache implementation: **caching is a prefix match, not a substring match**. Put your stable system prompt, tool definitions, and reusable few-shot examples at the start of the message array. User-specific dynamic content goes at the end.

A 1,500-token cached prefix on V4-Pro drops from $0.435/1M to $0.003625/1M — that is $0.000647 saved per call. At 1M calls/month, that is $647 saved on a workload that already costs under $1,000. The compounding effect of DeepSeek's already-low base price plus its deepest-in-market cache discount makes cache-anchored prompt design the single highest-EV optimization available on the platform.

Most LLM SDKs do not require code changes to opt in — caching activates automatically once you structure prompts prefix-first. The biggest mistake we see (identical to OpenAI): teams interpolate dynamic context (current date, user ID, session state) into the system prompt, which breaks every cache hit. Move that to a user message and the cache holds. Our prompt caching tutorial covers the structural rewrite that flips a non-caching prompt into a cache-anchored one — the structural rules apply identically on DeepSeek.

DeepSeek is a China-based provider, headquartered and operating under PRC jurisdiction. That is a load-bearing fact for any workload where data residency, jurisdictional exposure, or vendor sovereignty matters. The cost savings are real, but they do not erase regulatory or risk realities.

**Regulated industries — generally do not use DeepSeek for production**: US healthcare (HIPAA-covered data), US financial services with PII, EU workloads subject to strict GDPR data-residency interpretations, US federal contracts subject to FedRAMP or DoD compliance, any workload covered by export-controlled technical data (ITAR/EAR). The cost case for DeepSeek does not survive the compliance review in these domains. Use OpenAI Enterprise, Azure OpenAI, AWS Bedrock, or Anthropic on AWS instead — significantly more expensive, but with the residency and contractual posture your auditors will require.

**Data exposure**: API requests to DeepSeek are processed on infrastructure in mainland China. Treat every prompt and response as potentially observable by the provider. Do not send PII, customer financial data, trade secrets, source code under NDA, or anything you would not be comfortable being aggregated for model improvement. DeepSeek's published terms allow training-data usage of API submissions in some configurations — read the current ToS before integrating, not after.

**Reliability and SLA posture**: DeepSeek's commercial-grade SLAs and enterprise support are immature relative to OpenAI, Anthropic, or AWS Bedrock as of mid-2026. For mission-critical workloads where downtime translates directly to revenue loss, build in a fallback provider — most teams shipping DeepSeek in production run it as the primary cost-saver with a GPT-5.4-mini or Gemini fallback wired in via a simple failover layer.

**Where DeepSeek is great**: internal tools, developer-facing automation, content generation pipelines for non-sensitive material, prototyping, eval generation, batch processing of public data, side-projects, agentic workflows on synthetic or non-sensitive inputs, anywhere the cost reduction is the binding constraint and the compliance/residency surface is low. For these cases, the 35-107x cost gap is impossible to ignore.

**Mistake 1: defaulting to R1 for everything.** R1 is a reasoning model — it generates thousands of chain-of-thought tokens before the visible answer, all billed at the output rate. A simple classification task that needs 200 tokens of output will bill 3,000+ output tokens on R1 because the model 'thinks' first. Use V3 or V4-Flash unless the task genuinely needs reasoning.

**Mistake 2: huge system prompts that never get cached.** Identical anti-pattern to OpenAI. If your system prompt interpolates anything that changes between calls (timestamps, user names, context summaries), the cache never hits — and you lose the 90-98% discount that makes DeepSeek's already-low pricing into actually-free territory. Restructure so the system prompt is static and the dynamic context lives in user messages.

**Mistake 3: not capping output, especially on R1 and V4-Pro.** R1 in particular can generate 10,000+ tokens of reasoning on hard problems. Without a `max_tokens` ceiling, a single complex query can cost 5-10x what you budgeted. Set explicit output caps everywhere you control the consumption shape.

**Mistake 4: replaying full history every turn in a chat.** Summarize earlier turns into a compact 200-token recap once context exceeds 5,000 tokens. DeepSeek's input pricing is cheap, but at 1M-call scale even cheap input adds up — and the cache hit rate degrades sharply when context grows unboundedly.

**Mistake 5: assuming DeepSeek + GPT-5.5 are quality-equivalent on your task without measuring.** Run a held-out eval on 50-200 representative inputs from your actual production traffic before migrating. The cost case is overwhelming when quality is equivalent; it's a coin flip when quality is meaningfully worse. Don't assume — measure.

Every price in this guide comes from DeepSeek's official API pricing page at api-docs.deepseek.com/quick_start/pricing and the consumer-facing pricing page at deepseek.ai/pricing, fetched on 2026-06-20. Cross-verified against three independent corroborating sources: community pricing aggregators, recent integration commits in popular open-source projects (LiteLLM, OpenRouter), and the public DeepSeek developer documentation. When a number could not be verified against the official pages, it was omitted from this guide.

DeepSeek pushes price changes more aggressively than OpenAI or Anthropic — we've seen 4-6 pricing moves per year since 2024, generally downward as the company has competed on price. The V4-Flash and V4-Pro tiers launched in 2026 with the deepest cache discounts on the market. Treat the headline numbers as a snapshot, not a contract.

**How to verify before you budget**: open api-docs.deepseek.com/quick_start/pricing in an incognito window, copy the numbers for your target models into a spreadsheet, compare against this guide. If they match, this guide is current for your purposes. If they don't, trust the live page. Re-verify quarterly if your monthly bill is over $500 — DeepSeek's price moves can be material and they don't always come with formal changelog entries.

**What we omitted**: DeepSeek operates an inference-pricing tier and a separate Chat platform with consumer subscription pricing. This guide covers only the API. We also omit any rate-limit, throughput-tier, or volume-discount pricing that requires direct enterprise contact — those are negotiated and not published. If you are looking at 10M+ calls/month, reach out to DeepSeek sales directly; published rates are usually beatable at that volume on any provider.

**Reproducible methodology**: the GEO Playbook that drives every cost calculator on this site mandates curl-verification of every $ value before publishing. Every row in the table above has a citation; every worked example uses those rows; every FAQ answer reflects them. If you find a discrepancy with the live page, treat the live page as canonical and tell us — we re-fetch and update.