DeepSeek API pricing

How DeepSeek API pricing works

DeepSeek bills "the number of tokens × price", deducted from a prepaid balance. Each request has three token counts, and each has its own price:

• Input, cache miss: input tokens DeepSeek has not cached yet. The first time a prompt is seen, all of it is a miss.
• Input, cache hit: the start of your prompt that matches a prefix DeepSeek already cached. Caching is on for every account, with no code change.
• Output: the answer plus the model's reasoning. Thinking mode is on by default, and its reasoning tokens are billed as output.
• Time of day: peak hours are 01:00–04:00 and 06:00–10:00 UTC, Monday to Friday. Every other hour is off-peak, and all three prices are half.
• Search and Fetch: two standalone tool APIs, $0.75 per 1,000 successful requests each.

Every response reports what it was billed on: usage.prompt_cache_hit_tokens, usage.prompt_cache_miss_tokens and usage.completion_tokens, which includes completion_tokens_details.reasoning_tokens. This function prices one response from those fields:

PRICES = {  # peak; off-peak is half of each
    "deepseek-flash":  {"hit": 0.006, "miss": 0.30, "output": 1.20},
    "deepseek-v4-pro": {"hit": 0.044, "miss": 1.32, "output": 3.96},
}

def cost_usd(model: str, usage: dict, off_peak: bool = False) -> float:
    p = PRICES[model]
    total = (usage["prompt_cache_hit_tokens"] * p["hit"]
             + usage["prompt_cache_miss_tokens"] * p["miss"]
             + usage["completion_tokens"] * p["output"]) / 1_000_000
    return total / 2 if off_peak else total

DeepSeek's rule of thumb is 1 English character ≈ 0.3 token and 1 Chinese character ≈ 0.6 token; the exact count is the one in usage. DeepSeek also publishes an offline tokenizer on its token usage page. For a quick estimate across providers, paste a prompt into the token counter.

Every DeepSeek API price, peak and off-peak

The full price list from DeepSeek's Models & Pricing page, USD per million tokens:

Both models take the OpenAI format at https://api.deepseek.com and the Anthropic format at https://api.deepseek.com/anthropic, and support thinking and non-thinking modes, JSON output, tool calls and the Responses API. Prices are the same whichever format you call.

DeepSeek peak and off-peak hours in your time zone

Peak hours are 01:00–04:00 and 06:00–10:00 UTC, Monday to Friday, except Chinese public holidays. Everything else is off-peak: weekends, Chinese public holidays in full, and 17 of the 24 hours of every weekday. Peak covers 35 of the 168 hours in a week, about 21%. Here are the peak windows in local winter time:

In practice: US working hours are off-peak (on the West Coast until 5 p.m.), European mornings until 11:00 are peak, and East Asian working hours are mostly peak. Daylight saving time moves the local rows by an hour from March; the UTC row doesn't change.

• Schedule work that can wait. Nightly evaluations, document backfills, data enrichment and report generation cost half if they run outside the windows above. That's DeepSeek's version of a Batch API, without the 24-hour wait.
• Leave a margin at the edges. The pricing page doesn't say whether a long request that crosses 01:00 or 06:00 UTC is billed at the start or end rate. Stop scheduled jobs a few minutes early.
• Count holidays in your budget. Chinese public holidays are off-peak all day, so a month with Golden Week or Spring Festival costs less for the same traffic.

What V4.1 Flash and V4 Pro cost for the same job

Take 1 million classification requests a month, each with 1,000 input tokens and a 20-token answer, with no cache hits and thinking turned off:

Pro costs 4.4× Flash on input and 3.3× on output. Flash is also the one with image input and 5× the concurrency, so start on Flash and move a request type to Pro only when Flash fails your evaluation set.

Thinking is where a DeepSeek bill can quietly double. It's on by default, and every reasoning token is billed at the output price. If the classifier above left thinking on and the model reasoned for 300 tokens before each 20-token answer, Flash would add $360 a month, more than the whole peak bill, and Pro would add $1,188. The thinking section shows how to turn it off. The LLM cost optimization guide covers routing between models and the other levers.

Context caching: a cache hit costs 2% of a miss

DeepSeek's context caching is on by default and stores prompt prefixes on disk. There is no cache write fee, no storage fee and no minimum length documented. A hit is billed at $0.006 on Flash against $0.30 for a miss, 98% off; on Pro $0.044 against $1.32, about 97% off. The rules, from DeepSeek's context caching guide:

• A hit needs a full match of a cached unit. Each request saves a prefix unit at the end of your input and another at the end of the output. A later request hits only if it starts with one of those units exactly.
• Multi-turn chats hit naturally. Turn 2 re-sends turn 1 plus a new message, so turn 1 (input and answer) is a hit.
• Shared prefixes are learned. If two requests share a start (the same system prompt and document, different questions), the first two miss, DeepSeek then saves the shared part, and the third hits.
• Long inputs are cut into units at fixed intervals, so a very long prompt can still hit part of the way.
• Best effort. Hits are not guaranteed, a cache takes seconds to build, and unused caches are cleared within a few hours to a few days.
• `user_id` isolates the cache between your end users, for privacy. Users with different user_id values don't share each other's cached prefixes.

What caching is worth on a chat or agent workload: 100,000 requests a month, each 20,000 input tokens of which 15,000 are a repeated prefix (system prompt, tools, history), and 500 output tokens:

Caching and off-peak together cut this bill by 83 to 84%. To keep the hit rate high: put stable content first (instructions, tool definitions, reference documents), keep history append-only, don't put a timestamp or request ID at the top of the prompt, and log prompt_cache_hit_tokens to see the real rate. The same rules apply on every provider; the Anthropic prompt caching guide explains why prefix order matters, and the context engineering guide covers what to keep in the prompt at all.

Thinking mode: reasoning tokens are billed as output

Both models think by default at high effort. Reasoning comes back in reasoning_content, is counted in completion_tokens, and is billed at the output price. You have two controls: turn thinking off, or lower the effort to low (max raises it).

from openai import OpenAI

client = OpenAI(api_key="<DeepSeek API key>", base_url="https://api.deepseek.com")

response = client.chat.completions.create(
    model="deepseek-flash",
    messages=[{"role": "user", "content": "Classify this ticket: ..."}],
    extra_body={"thinking": {"type": "disabled"}},  # or keep it on with reasoning_effort="low"
)
print(response.usage)  # completion_tokens now holds the answer only

• Without tools, earlier reasoning is not added to the next turn's context, even if you send it back. It costs output once.
• With tools, you must pass back the reasoning_content of earlier turns, and it is added to the context. An agent pays for its reasoning once as output, then again as input on every later call, usually at the cache-hit price because the history is unchanged.

DeepSeek vs Claude, GPT and Gemini prices

List prices per million tokens, from each provider's pricing page:

• Small models: Claude Haiku 5.5 and GPT-6 Luna have a lower uncached input and output price than V4.1 Flash, even off-peak. Flash is cheaper on cache hits, so it wins on agent and chat traffic where most input is a repeated prefix.
• Mid-tier models: V4 Pro is cheaper on every price than Claude Sonnet 5.5, GPT-6.1 Sol and Gemini 3.1 Pro. Against Sonnet 5.5 and GPT-6.1 Sol it costs 34% less on input and 60% less on output at peak, and 67% and 80% less off-peak.
• Tokens are not the same size. DeepSeek's rule of thumb is 0.3 tokens per English character, against about 0.25 for GPT and Gemini and 0.4 for current Claude models, so the same text is roughly 1.2× the tokens of GPT and 0.75× those of Claude.
• Batch: Claude, OpenAI and Gemini halve prices through a Batch API that returns within 24 hours; DeepSeek halves them by the clock.

Price per task depends on the workload, not the price list. The LLM pricing comparison runs the same app through every Claude, GPT and Gemini model; the provider pages have the full lists for Claude and Gemini. Quality per dollar is a separate test: run your own evaluation set before switching.

Other charges and billing rules

• Search and Fetch APIs: $0.75 per 1,000 successful requests each, at any hour. The pages they return cost input tokens when you put them in a prompt.
• Images (V4.1 Flash only) are billed as input tokens. Images are resized before inference, with a maximum token count per image; DeepSeek's token usage page has a calculator by width and height.
• Prepaid balance: charges come out of your topped-up balance, and a granted balance, if you have one, is used first.
• Concurrency: 2,500 concurrent requests on Flash and 500 on Pro per account; past that you get HTTP 429. Raising the limit is free on request.
• Prices can change. DeepSeek moved to peak and off-peak pricing on August 16, 2026, lowered prices with V4.1 Flash on September 10, 2026, and kept them unchanged with the October 17 Flash-1017 update. We check the pricing page and update this one when it changes.

Frequently asked questions