Research-backed calculator guide

DeepSeek API Cost Calculator: Cache Hits, Peak Pricing and Search/Fetch

Calculate DeepSeek API spend with cache-hit and cache-miss tokens, UTC peak pricing, and separately metered Search and Fetch requests.

What the current search results cover

I reviewed the first ten organic pages returned for “DeepSeek API cost calculator” in a dated, locale-limited web snapshot taken on 2 November 2026. This is a snapshot of one search context, not a claim about global rankings or permanent result order.

The set contained one first-party pricing documentation page, several embedded calculators, model-price databases, token counters, and long pricing guides. The calculator formats generally ask for input and output tokens, API calls, or a word/character proxy. Some add model comparison, a cache-hit percentage, or a simple monthly example. The longer guides explain token pricing, caching, and peak/off-peak scheduling with tables and worked arithmetic. Visual treatment is mostly forms, rate cards, comparison tables, and explanatory callouts rather than charts or scenario dashboards.

Freshness varies. The inspected pages included dates from March 2026 through October 2026, including pages updated on October 4, October 19, and October 25, while some pages did not show a clear update date. Several results still centered older V3, V3.2, V2, or R1 assumptions. The deepest pages were useful for examples and cost context, but they often mixed a direct DeepSeek rate with a reseller, router, or historical model record. The model-price pages were convenient lookup tools, yet their displayed inputs did not consistently preserve DeepSeek’s direct peak schedule or current Search/Fetch rules.

The supportable gap is specific: in this ten-page snapshot, I did not find another inspected calculator that exposed all of these as separate, auditable inputs and outputs in one estimate: cache-hit input, cache-miss input, peak-share weighting, successful Search requests, and successful Fetch requests. That is a product-format observation for this dated sample, not a claim that no other calculator exists or that any competitor never ranks.

DeepSeek’s meters and current rate card

DeepSeek’s official pricing page states that model prices are listed per 1 million tokens and that model usage is based on total input and output tokens. The model table distinguishes cache-hit input from cache-miss input, then prices output separately. ^[1]

For the direct API rate card checked on 2 November 2026, the useful V4 records are:

These are USD per 1 million tokens. A cache hit is still input-token usage, but it uses the cache-hit input rate. Do not classify every repeated or cacheable prefix as a hit. For a production estimate, use the cache-hit token count reported by the API or your usage export. If you only have a theoretical hit percentage, label it as an assumption and compare it with a no-cache case.

The official schedule defines peak as 01:00–04:00 and 06:00–10:00 UTC, Monday through Friday, excluding Chinese public holidays. All other hours are off-peak, including weekends and Chinese public holidays in full. ^[1] A 25% peak-share assumption therefore means that 25% of the relevant token meter is charged at the peak rate; it does not mean 25% more tokens.

Thinking mode, tool calls, retries, application hosting, storage, taxes, and negotiated account terms should not be silently folded into these public token rates. If a workflow creates more output tokens or sends larger tool schemas and histories, those tokens belong in the appropriate input or output field. If another service charges for retrieval, orchestration, or observability, model it separately. The AI token cost calculator is useful when you need a provider-neutral token sanity check, while model pricing comparison can hold one workload constant across rate cards.

Search and Fetch are separate request charges

DeepSeek documents Search and Fetch as standalone raw JSON APIs. Search finds pages and returns structured results; Fetch retrieves one page and returns Markdown content. The endpoints use the same bearer authentication and are separate from the model token meters. ^[2]

The current official price is $0.75 per 1,000 successful Search requests and $0.75 per 1,000 successful Fetch requests. ^{[1] [2]} This means:

Search cost = successful Search requests ÷ 1,000 × $0.75 Fetch cost = successful Fetch requests ÷ 1,000 × $0.75

A successful request is narrower than an attempted request. DeepSeek’s guide says a request is billable only when it returns HTTP 200 and produces a result: Search must return a non-empty results array, while Fetch must return page content. Failed requests, empty Search results, and timeouts are not billed. The Search count parameter controls how many results are returned; it does not multiply the per-request price. ^[2]

The effective-window detail matters for existing integrations. DeepSeek’s guide says that when the API is used through DeepSeek Harness, Claude Code, or Codex, server-side tool calls already hit the Search and Fetch APIs. Those calls were described as free before per-request billing began at 00:00 Beijing time on 1 November 2026. For a 2 November 2026 budget, treat successful Search and Fetch tool calls after that effective point as billable unless the applicable account terms say otherwise. Do not replace the request count with returned tokens or result count. ^{[1] [2]}

Search and Fetch also have independent account-level limits: the guide lists 100 QPS for Search and 25 QPS for Fetch, with additional per-domain limits for Fetch. Those are capacity constraints, not extra cost units. ^[2]

Formula and exclusions

Let p be the share of a meter incurred during peak windows, expressed from 0 to 1. For each token meter, calculate a blended rate:

Blended rate = off-peak rate + p × (peak rate − off-peak rate)

Then:

Monthly model cost = (cache-hit tokens ÷ 1,000,000 × blended hit rate) + (cache-miss tokens ÷ 1,000,000 × blended miss rate) + (output tokens ÷ 1,000,000 × blended output rate)

Monthly DeepSeek estimate = monthly model cost + Search cost + Fetch cost

This approach assumes one peak-share value for the three token meters. If your scheduler is different for input and output, use separate shares and calculate each line independently. The calculator’s result is a planning estimate, not an invoice quote.

State these assumptions beside the result:

• Model and version: use the current direct model record, not a similarly named router or reseller record.
• Token classification: cache-hit and cache-miss counts are separate; output is never entered as cache-hit input.
• Schedule: peak share is based on UTC timestamps and excludes Chinese public holidays from peak windows.
• Search/Fetch eligibility: count successful responses under DeepSeek’s documented billing rule, not attempted calls, empty results, or timeouts.
• Scope: exclude tax, credits, infrastructure, provider changes, contract discounts, and other vendor meters unless you add them as explicit assumptions.

Do not use this formula to estimate a hosted product’s subscription, a third-party router’s fee, or a self-hosted GPU budget. For retrieval systems with embeddings, vector storage, and reranking, use the RAG cost calculator and keep DeepSeek generation and Search/Fetch lines separate.

Worked scenario: Flash with cache and web retrieval

Assume a monthly workload using deepseek-flash with 8 million cache-hit input tokens, 12 million cache-miss input tokens, and 4 million output tokens. Assume 25% of each token meter occurs during peak windows. Also assume 15,000 successful Search requests and 6,000 successful Fetch requests. These are illustrative assumptions, not provider usage data.

The blended Flash rates are:

• Cache-hit input: $0.003 + 25% × ($0.006 − $0.003) = $0.00375 per million.
• Cache-miss input: $0.15 + 25% × ($0.30 − $0.15) = $0.1875 per million.
• Output: $0.60 + 25% × ($1.20 − $0.60) = $0.75 per million.

The token portion is:

• Cache hits: 8 × $0.00375 = $0.03.
• Cache misses: 12 × $0.1875 = $2.25.
• Output: 4 × $0.75 = $3.00.
• Model total: $5.28.

The separate web-tool portion is:

• Search: 15 × $0.75 = $11.25.
• Fetch: 6 × $0.75 = $4.50.

The estimated monthly total is therefore $5.28 + $11.25 + $4.50 = $21.03. In this scenario, Search and Fetch cost more than model tokens, which is exactly why collapsing them into a token estimate would understate the workflow budget. The same token mix would cost about $19.97 with all token usage off-peak and about $24.20 with all token usage at peak, before any other charges.

FAQ

Are DeepSeek cache hits free?

No. Cache-hit input is billed at a lower per-million-token rate than cache-miss input, but it remains a billable model meter. Use observed cache-hit tokens rather than assuming a repeated prompt always hits the cache. ^[1]

What are DeepSeek’s peak hours?

Peak hours are 01:00–04:00 and 06:00–10:00 UTC, Monday through Friday, excluding Chinese public holidays. Weekends, full Chinese public holidays, and all other hours are off-peak. ^[1]

Does Search or Fetch use token units?

No. Search and Fetch are charged per successful request at $0.75 per 1,000 for each API. Returned page content, result count, or content tokens do not replace the request meter. ^[2]

Are failed Search and Fetch calls billed?

The official guide says failed requests, empty Search results, and timeouts are not billed. A billable request must return HTTP 200 and produce a non-empty Search result or Fetch page content. ^[2]

Does the Search count parameter increase cost?

No. count changes how many Search results are returned, but DeepSeek states that it does not change the per-request price. One successful Search request remains one request for billing purposes. ^[2]

Can I use this calculator for OpenRouter DeepSeek usage?

Use the direct DeepSeek mode only for direct DeepSeek API rates and rules. A router may publish a different rate card, fee policy, or cache treatment. For that case, use the OpenRouter cost calculator and verify the router’s current model record.