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 output | 1M 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 · period | Input (cached) | Input (fresh) | Output | Total |
|---|---|---|---|---|
| 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 calls | 8 / 1,076 (35.9 calls a day) |
| Input tokens served from cache | 166,006,400 |
| Input tokens that missed cache | 1,467,735 |
| Cache hit share | 99.1% |
| Output tokens | 660,277 (614 per call) |
| Input per call | 155,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
| Lever | What it changes | Effect on the bill |
|---|---|---|
| Cache hit share | input rate | up to 50× on flash input, 30× on v4-pro |
| Model tier | every rate | 3.3× on output, 4.4× on cache-miss input |
| Time of day | every rate | exactly 2×, reversible by scheduling |
| Output length | output line | linear — 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.