Cost & models

Cost & models

Price pages tell you the rate. They do not tell you what a task costs, because a task is not one request. These pages pair the rate with the bill.

ONE TASK · 200K IN / 20K OUTsame work, 7.3× the price$0.00$0.06$0.12flash · off-peak$0.0155flash · peak$0.0311v4-pro · off-peak$0.0568v4-pro · peak$0.1135api-docs.deepseek.com · checked 2026-11-18
$0.00$0.05$0.10flash · off-peak$0.0155flash · peak$0.0311v4-pro · off-peak$0.0568v4-pro · peak$0.1135one task · 200K input (180K cached) + 20K output
Source: api-docs.deepseek.com pricing · checked 2026-11-18Arithmetic on published rates, not a measured bill

What DeepSeek charges, as of 2026-11-18

Prices below are read from DeepSeek's own pricing page on 2026-11-18 and are per 1M tokens. Peak hours are 01:00–04:00 and 06:00–10:00 UTC, Monday to Friday; everything else, including weekends and Chinese public holidays, is off-peak.

Billing item (per 1M tokens) flash · off-peak flash · peak v4-pro · off-peak v4-pro · peak
Input, cache hit$0.003$0.006$0.022$0.044
Input, cache miss$0.15$0.30$0.66$1.32
Output$0.60$1.20$1.98$3.96
Context / max output1M context · 384K max output (both models)

Why the cache-hit column decides your bill

Input at cache-miss rates costs 50× what cached input costs on flash, and 30× on v4-pro. An agent loop re-sends its context on every step, so the difference between "cache is working" and "cache is not" is the difference between cents and dollars for the same task.

One task, four prices

Take a loop that ends with 200K input tokens of which 180K are cached, plus 20K output. Same work, four bills:

Model · periodInput (cached)Input (fresh)OutputTotal
flash · off-peak$0.00054$0.00300$0.01200$0.0155
flash · peak$0.00108$0.00600$0.02400$0.0311
v4-pro · off-peak$0.00396$0.01320$0.03960$0.0568
v4-pro · peak$0.00792$0.02640$0.07920$0.1135

That is a 7.3× spread for identical output. The two levers are model choice and when the job runs — neither requires changing your prompt.

Run your own numbers

Defaults are one agent session: 20K input tokens per turn, 80% of it served from cache, 800 output tokens, 40 turns a day, 30% of them in peak hours.

Cost per turn
$0.0015
Cost per day
$0.0587
Cost per 30 days
$1.76
Peak / off-peak split
70 / 30
Same workload on the other model
$7.14

Arithmetic on official rates, not a bill. Your cache-hit share is the number you cannot guess — measure it before you trust any of this.

What our own agent actually spent

Last 30 days on this machine: 1,076 API calls in 8 sessions, 99.1% served from cache, 156K input tokens per call. Recomputed at off-peak rates: $1.11 for the month. The preset rounds per-call averages, so it lands within a cent.

Aggregated from the agent runtime database — aggregates only, no prompts, no session titles. · DeepSeek pricing

Prices read 2026-11-19 ·api-docs.deepseek.com

What our own agent actually spent

This is the part no pricing page can give you: our own numbers, from the runtime database of the machine that writes this site. Last 30 days, captured 2026-11-19:

Measured (last 30 days)Value
Sessions / API calls8 / 1,076 (35.9 calls a day)
Input tokens served from cache166,006,400
Input tokens that missed cache1,467,735
Cache hit share99.1%
Output tokens660,277 (614 per call)
Input per call155,645 tokens
Cost, recomputed at off-peak rates$1.11 for the month — $0.037 a day
The same month priced entirely at peak$2.23
Cost as the runtime itself estimated it$0.83

We cannot tell you what share of those calls landed in peak hours: the runtime records tokens per call, not the clock. So the $1.11 is the off-peak floor and $2.23 the all-peak ceiling — the real bill is somewhere between, and that is why the calculator asks you for a peak share instead of pretending it knows.

Two numbers for the same month, 25% apart, and we are publishing both. The $0.83 is what the agent's own accounting produced from its price snapshot; the $1.11 is us re-doing the arithmetic against the price page read on 2026-11-19. The gap is the cost of a stale price table, not of a mistake — and it is the reason every number on this page carries a read date.

Three things keep our bill at a dollar. The workload is one machine doing one site, not a fleet. The cache hit share is 99.1%, because an agent loop re-sends the same prefix on every turn and the prefix rarely changes. And most of it runs off-peak, because we work in UTC+8 where the peak window is the afternoon.

A chatbot's workload looks nothing like this: no stable prefix, no cache, short output, and the bill is dominated by tokens you type. If you are pricing a chat app, the defaults in the calculator above (80% cache, 20K tokens per turn) are closer to your reality than our measured 99%.

How a bill is actually assembled

Every request is three lines, and the whole pricing page fits in one formula:

cost = (in_hit × rate_hit + in_miss × rate_miss + out × rate_out) / 1M

In peak hours every rate on the right doubles. That is the entire model — there are no tiers, no minimum, no monthly platform fee.

A chat bill is dominated by the output line: you type ninety tokens, the model writes nine hundred. An agent bill is dominated by input, because the loop re-sends its whole context on every turn. By the twentieth turn of a coding session you are paying to re-read the same files, the same tool schemas and the same skill instructions — which is why the cache column matters more here than on any chat pricing page.

Where cache misses come from

Caching is prefix-based: the provider stores a hash of everything up to a point, and a new request reuses it only if that prefix is byte-identical. Change anything at the front — a system prompt edit, an added tool, a re-ordered skill list, a timestamp at the top of the context — and everything after it is a miss, at 50× the cached rate.

That has a practical consequence people miss: adding one line to your system prompt costs far more than the line itself, because it invalidates the cached prefix behind it. Editing the prompt mid-session is the single most expensive habit in agent work.

The 80% default in the calculator is a placeholder. Our own measured share is 99.1% — and that is why our monthly bill is about a dollar (see the table above). Do not copy our number into your budget: measure yours by running the same task twice with token logging on, and read the cache-hit counters from the response, not from the prompt you designed.

Peak hours in your own clock

Peak is 01:00–04:00 and 06:00–10:00 UTC, Monday to Friday, excluding Chinese public holidays. In UTC+8 those become 09:00–12:00 and 14:00–18:00 — the entire working day in China, with a two-hour gap in the middle.

If your agent runs on a schedule rather than on demand, moving it four hours later halves the price of those turns and changes nothing else. That is the cheapest optimisation on this page, and the one nobody does because it feels like a detail.

The levers, ranked by what they actually move

LeverWhat it changesEffect on the bill
Cache hit shareinput rateup to 50× on flash input, 30× on v4-pro
Model tierevery rate3.3× on output, 4.4× on cache-miss input
Time of dayevery rateexactly 2×, reversible by scheduling
Output lengthoutput linelinear — no multiplier, and at high cache-hit share it becomes the largest line

What changed on 2026-11-18

Server-side search and fetch calls made by the model stopped being billed per call at 12:00 Beijing time on 2026-11-18: the results are now appended to the model's context and billed as input tokens. Direct Search API and Fetch API calls are still $0.75 per 1,000 successful requests.

For a browsing agent this moves money from a predictable per-call line into the input line — the side where a cache miss costs fifty times a hit. If your agent searches on every turn, re-read your last bill before assuming the old per-call arithmetic still holds.

What this calculator does not do

  • It does not know your tokens. Turns per day, tokens per turn and cache-hit share are inputs you have to measure; every default here is a guess about a workload.
  • It does not model retries. A failed call that is retried is billed twice, and rate-limit backoff means those retries often land in peak hours.
  • It does not include vision. Only flash supports images; v4-pro does not, so an image-heavy workload cannot be priced on the pro column at all.
  • It does not price resellers. OpenRouter and similar services add their own margin and their own peak rules on top of these rates.
  • It assumes a flat month. Real months have spikes, experiments and the week you left a loop running overnight.

Source and method

Numbers: api-docs.deepseek.com/quick_start/pricing, read on 2026-11-19 and unchanged from our 2026-11-18 reading. The worked example is arithmetic on those rates, not a measured bill — we mark it as arithmetic on purpose. The cache-hit default is our guess, stated as a guess. When we publish our own monthly bill, this page gets a measured column beside the computed one, and any that disagree stay visible.