Seek-Chat: DeepSeek API Cost Calculator

Use the rate tables and worked examples on this page to estimate spend per request, day, month, or year for deepseek-v4-flash, deepseek-v4-pro, and deepseek-v4-flash-vision-exp. Take your cache-hit and cache-miss input tokens, output tokens and request volume from the API’s returned usage object, and—when using Vision—add the image tokens it reports. For the complete rate table and model-selection guidance, see our DeepSeek API pricing guide.

The most reliable estimate comes from the provider-returned usage object. The fields to read are the Chat Completions cache-hit, cache-miss and completion counters; the Responses input_tokens, input_tokens_details.cached_tokens and output_tokens; and, on the Anthropic-compatible surface, the input and output counters — which do not separate cache detail, so treat their input figure as cache-miss unless you can establish otherwise. Pre-request text and image-token calculations are planning estimates; DeepSeek’s returned usage and billing records remain authoritative.

The calculator is below. It applies the rates on this page to your own volume, token mix, cache-hit rate and billing window, entirely in your browser. DeepSeek’s returned usage and billing records remain authoritative.

DeepSeek API cost calculator

Off-peak rates checked September 3, 2026 against the published price list. Peak is twice off-peak. The arithmetic runs in your browser; nothing you enter is sent anywhere.

Tier Fast Pro Vision Everyday questions, drafting, short code.

Requests per month

Average input tokens per request

Average output tokens per request

Cache-hit rate

50%

The share of input tokens billed at the cheaper cache-hit rate.

Pricing window Off-peak Peak (twice off-peak) A mix of both

Estimated monthly cost $5.0025

Monthly cost by component

Component	Tokens per month	Cost
Cached input	7,500,000	$0.0525
Uncached input	7,500,000	$1.6500
Output	5,000,000	$3.3000

Cost per request

$0.000500

Cost per 1,000 requests

$0.5003

Output is the largest part of this bill at 66.0% of the total. Output is billed at three times the uncached input rate here, so asking for shorter answers moves this number most.

This is a planning estimate. DeepSeek's returned usage and its billing records remain authoritative. The rates, the peak window and the cache-hit detail are on the pricing page.

How DeepSeek API Cost Is Calculated

DeepSeek bills input and output tokens separately. Input tokens are split between the lower cache-hit rate and the regular cache-miss rate. Vision images are resized and converted into input tokens, which are billed with text input. The cost equation is:

request cost =
  (cache-hit input tokens / 1,000,000 x cache-hit price)
+ (cache-miss input tokens / 1,000,000 x cache-miss price)
+ (output tokens / 1,000,000 x output price)

• Cache-hit input: Chat Completions reports prompt_cache_hit_tokens; Responses reports cached input in input_tokens_details.cached_tokens.
• Cache-miss input: Chat Completions reports prompt_cache_miss_tokens; for Responses, subtract cached input from input_tokens.
• Output: generated completion or output tokens, including billable reasoning-token usage where applicable.
• Vision images are not calculated here. The Vision tier applies the correct token rates, but the calculator has no image input and cannot count image tokens. deepseek-v4-flash-vision-exp converts each image into input tokens based on resized dimensions, with a documented upper bound of 384 tokens per image. Work out that figure separately and add it to the average input tokens you enter, or the estimate will be short by the whole image cost.
• Anthropic-compatible usage: when a response exposes only input_tokens and output_tokens, treat the whole input figure as cache-miss rather than inferring a cache split the response does not report.
• Volume: per-request cost multiplied by the number of requests. The calculator takes one volume figure — requests per month — and reports a monthly total, a cost per request and a cost per 1,000 requests. It does not project a year.

Worked DeepSeek API Cost Examples

The first three static examples preserve the rates in effect on August 3, 2026 and remain readable without JavaScript. They are historical pre-cutover calculations, not estimates at today’s current off-peak or peak rates.

Example 1: Flash Chatbot With a 50% Cache-Hit Rate

Assume 800 input tokens, 400 output tokens, a 50% cache-hit rate, and 2,000 requests per day:

• Cache-hit input: 400 / 1,000,000 x $0.0028 = $0.00000112
• Cache-miss input: 400 / 1,000,000 x $0.14 = $0.000056
• Output: 400 / 1,000,000 x $0.28 = $0.000112
• Total: $0.00016912 per request, $0.33824 per day, $10.1472 per 30-day month, or $123.4576 per 365-day year.

Example 2: The Same Workload on V4 Pro

Using the same 800 input tokens, 400 output tokens, 50% cache-hit rate, and 2,000 requests per day, V4 Pro costs $0.00052345 per request. That projects to $31.407 per 30-day month or $382.1185 per 365-day year. The comparison isolates the price difference; it does not measure whether Pro’s output quality reduces retries or downstream work.

Example 3: How Caching Changes a Flash RAG Budget

For 10,000 input tokens, 1,000 output tokens, and 100,000 requests per month, a 0% hit-rate estimate is $168.00 per month. A theoretical 100% input cache-hit estimate is $30.80 per month, a difference of $137.20. This is a planning boundary, not a promised saving: DeepSeek documents caching as best-effort, and only persisted matching prefixes count as hits. Use observed usage fields instead of assuming 100%. Read our DeepSeek context caching guide for prefix design and measurement.

Current-Rate Verification Examples

These deterministic examples use the current off-peak and weekday peak matrices. Peak values are exactly twice the corresponding off-peak values; automatic weekend pricing uses the off-peak column when the Beijing-time rule applies.

Vector	Off-peak	Peak
Flash: 1K cache-miss input + 500 output	$0.0005500000	$0.0011000000
Flash: 1K cache-hit input + 500 output	$0.0003370000	$0.0006740000
Pro: 1K input, 50% cache hit + 500 output	$0.0013310000	$0.0026620000
Pro: 10K input, 80% cache hit + 1K output	$0.0034760000	$0.0069520000
Flash: 800 input, 50% cache hit + 400 output × 60K requests	$21.2880	$42.5760
Vision: 1K cache-miss input + 500 output	$0.0005500000	$0.0011000000
Vision: estimated 1920×1080 image input only (369 tokens)	$0.0000811800	$0.0001623600

Current rates are in the table above, and on the pricing page. Both are rechecked against DeepSeek’s published figures and dated.

Original Deterministic Calculator Test Matrix

We created the following frozen arithmetic vectors for the August 3, 2026 calculator review. Each expected result was recomputed independently from the published price table. This validates calculator math; it is not a claim about a live API invoice, model quality, latency, or cache availability.

Test vector	Model	Input / output	Cache hit	Expected cost per request	Check
F-01: no cache	V4 Flash	1,000 / 500	0%	$0.0002800000	Exact formula match
F-02: full input hit	V4 Flash	1,000 / 500	100%	$0.0001428000	Exact formula match
P-01: mixed cache	V4 Pro	1,000 / 500	50%	$0.0006543125	Exact formula match
P-02: RAG profile	V4 Pro	10,000 / 1,000	80%	$0.0017690000	Exact formula match
V-01: volume projection	V4 Flash	800 / 400	50%	$10.1472 per 60,000 requests	30-day month

Original Live DeepSeek API Cost Test

On August 3, 2026, we ran an English-only synthetic cache test against the live DeepSeek API. The reusable prompt contained 1,580 input tokens, and each response contained 8 output tokens. We sent the same prompt twice to V4 Flash, then sent it once to V4 Pro. The table uses the exact token counters returned by the API and calculates cost from the official rates in effect on that test date.

Live request	Model	Input / output	Cache hit / miss	Calculated cost	Observed result
First Flash request	deepseek-v4-flash	1,580 / 8	0 / 1,580	$0.0002234400	Exact expected text returned
Repeated Flash request	deepseek-v4-flash	1,580 / 8	1,536 / 44	$0.0000127008	94.32% lower calculated cost
First Pro request	deepseek-v4-pro	1,580 / 8	0 / 1,580	$0.0006942600	Exact expected text returned

The repeated Flash request demonstrates why real cache counters matter: 1,536 of 1,580 prompt tokens were reported as cache hits, while 44 remained cache misses. The calculator reproduced all three costs before display rounding. This test confirms the formula and usage-field handling for this workload; it does not guarantee the same cache-hit rate for another prompt, account, region, or time.

There is no token counter here: counting tokens exactly requires the tokenizer, and guessing badly would be worse than not guessing. As a rough planning figure, English prose runs about four characters per token, and the calculator below takes token counts as its input. Use the API’s returned usage for anything you are billed on.

DeepSeek documents rough planning ratios of about 0.3 token per English character and 0.6 token per Chinese character, but tokenization varies by language, model, code, and formatting. For Vision, estimate from the resized image dimensions before a request. For billing reconciliation, always use the token fields returned by the API.

Limits and Assumptions

• Currency and units: US dollars per 1 million tokens, before taxes, credits, grants, account-level adjustments, or provider rounding.
• Time period: one month, as entered. The calculator does not convert to a daily or annual figure, so it makes no assumption about how many days a month or a year contains.
• Token source: use Chat Completions prompt_cache_hit_tokens, prompt_cache_miss_tokens, and completion_tokens, or Responses input_tokens, input_tokens_details.cached_tokens, and output_tokens. Where a response exposes only an Anthropic-compatible input and output counter, with no cache split, enter the whole input figure as cache-miss and set the cache-hit rate to zero. You type these numbers in; the calculator does not read them from a response.
• Vision image estimates: images are resized and converted to input tokens, with a documented upper bound of 384 tokens per image. There is no image input and no dimension estimator in this calculator — work the figure out from DeepSeek’s published method and fold it into the average input tokens you enter. If you are entering real usage returned by the API, the image tokens are already inside that number; do not add them twice.
• Cache behavior: the cache-hit percentage is an estimate unless it comes from observed responses. Caching applies to matching input prefixes, works on a best-effort basis, and does not discount output tokens.
• Model limits: Flash, Pro, and Vision Exp have a 1M context length and a maximum output of 384K. Vision accepts up to 600 images per request; the maximum dimension is 8,192 pixels per side, dropping to 4,096 pixels when a request contains 15 or more images.
• Concurrency: the published per-model limits are 2,500 concurrent requests for Flash, 500 for Pro, and 2,500 for Vision Exp. Concurrency and 429 handling affect throughput but do not change the token-price formula.
• Unmodeled usage: system prompts, tool schemas, conversation history, retries, failed application attempts that still generated tokens, and reasoning tokens can increase real usage.
• Pricing period: each estimate uses one selected matrix. Resolve the August 16, 2026 cutover, the weekday UTC peak windows, and—effective August 23, 2026 in Beijing—the all-day weekend off-peak rule from the request timestamp. For mixed traffic, calculate each period separately.

Methodology and Verification

We rechecked DeepSeek’s official Models & Pricing, Token & Token Usage, Vision, Context Caching, Responses API, and Anthropic API documentation on August 22, 2026. We verified all three current models, rate matrices, context and output limits, concurrency, DeepSeek’s published image-to-token method, weekday UTC windows, and the Beijing-time weekend boundary. The historical pre-cutover matrix, original August 3, 2026 vectors, and live request costs remain frozen. This update used no account balance, invoice, promotion, tax calculation, or new paid DeepSeek request.

For production monitoring, record the provider-returned usage fields for every request, keep the API surface and model with each record, resolve its pricing period from the request timestamp, and reconcile derived estimates with DeepSeek billing records. For Vision, treat the pre-request dimension result as a plan and the returned image-inclusive usage as the source of truth. Our DeepSeek token usage fields guide explains the counters; the DeepSeek API guide covers setup and request structure; and the DeepSeek API updates tracker records model and pricing changes.

DeepSeek API Cost Calculator FAQ

How much does the DeepSeek API cost?

Current per-million-token cache-hit, cache-miss, and output rates are $0.007/$0.22/$0.66 off-peak and $0.014/$0.44/$1.32 at peak for Flash and Vision, and $0.022/$0.66/$1.98 off-peak and $0.044/$1.32/$3.96 at peak for Pro.

How do I calculate DeepSeek API cost?

Multiply cache-hit input, cache-miss input, and output tokens by their separate per-token prices, add the three amounts, then multiply by request volume.

Do DeepSeek V4 Flash and Vision Exp cost the same?

Yes. The current published token rates are the same, but only deepseek-v4-flash-vision-exp accepts image input. Images are converted to billable input tokens.

How are DeepSeek Vision image tokens calculated?

DeepSeek resizes each image while preserving aspect ratio and converts the resized dimensions into tokens, with a documented upper bound of 384 tokens per image. This calculator does not estimate image tokens — work the figure out with DeepSeek’s documented method, then add it to the average input tokens you enter. Usage returned by the API remains authoritative.

When do DeepSeek peak and weekend off-peak rates apply?

On weekdays, peak windows are 01:00–04:00 and 06:00–10:00 UTC (09:00–12:00 and 14:00–18:00 Beijing time). Effective 00:00 Beijing time on August 23, 2026, Saturdays and Sundays in Beijing time are off-peak all day.

Does DeepSeek context caching reduce API cost?

It can reduce input cost when DeepSeek reports a cache hit. Caching is best-effort, so use returned cache-hit and cache-miss token counters rather than assuming a hit rate.

Does the calculator import a usage object?

No. It takes numbers you type: volume, average input and output tokens, cache-hit rate and billing window. To use real figures, read prompt_tokens, prompt_cache_hit_tokens and completion_tokens from a returned usage object and enter the averages yourself. The fields to read are listed earlier on this page.

How can I get an accurate DeepSeek token count?

Use the usage object returned by the API. Character-based text estimates and pre-request image dimension estimates are planning approximations.

What is the difference between this calculator and the pricing page?

The pricing page is the rate and model reference, and it is where the rates are verified. This calculator applies those same rates to a token mix, cache behavior, billing window and monthly volume, and shows what the bill breaks down into. Both read the same figures, checked on the same date.

Is this an official DeepSeek calculator?

No. Seek-Chat.com is an independent guide and this calculator is our own. DeepSeek platform usage and billing records remain authoritative, and the arithmetic here runs entirely in your browser — nothing you enter is sent to us or to anyone else.

Sources and Related Guides

• DeepSeek Models & Pricing — three current models, token rates, concurrency, weekday peak windows, and the Beijing-time weekend rule.
• DeepSeek Vision — image inputs, resizing, token billing, supported formats, and image limits.
• DeepSeek Token & Token Usage — text approximations, DeepSeek’s published image-to-token method, and provider-returned usage guidance.
• DeepSeek Context Caching — cache persistence, matching rules, usage fields, and best-effort limitations.
• DeepSeek Responses API — Responses usage fields, cached input details, and Vision input support.
• DeepSeek Anthropic API — compatibility scope and supported request fields.
• DeepSeek V4 Flash Vision Exp — independent model guide and image-input overview.
• DeepSeek API Pricing — detailed rate comparison and purchasing context.
• DeepSeek Context Caching Explained — practical cache-friendly prompt design.
• DeepSeek Token Usage Fields — logging and interpreting Chat, Responses, and Anthropic-compatible usage.
• DeepSeek API Updates — current changes that can affect estimates.
• DeepSeek API Guide — authentication, models, endpoints, and request examples.

Last verified: August 22, 2026. Pricing and schedule rules are time-sensitive. Recheck the official source before making a purchasing or production decision.