DeepSeek API Pricing: Peak Hours, Cache Lanes, and Your Real Bill
Two developers looked up DeepSeek API pricing one day apart. The first, on August 15, found Flash at $0.14 per million input tokens. The second, on August 17, found the same lane ranging from $0.22 to $0.44. Neither source was wrong. Between those two dates, DeepSeek switched to peak and off-peak billing — and most of the pricing pages you'll find today still show the world before the switch.
This guide works from the API's current rate card, effective August 16, 2026 at 16:00 UTC, taken from the official pricing page. We'll cover the three billing lanes, when peak hours hit your timezone, what a real 2-billion-token month actually cost on the API, how to estimate your own bill, and seven levers that move it down.
The Current Rate Card (Since August 16, 2026)
All prices are per 1 million tokens, in US dollars, for the three callable models:
| Billing lane | deepseek-v4-flash | deepseek-v4-pro | deepseek-v4-flash-vision-exp |
|---|---|---|---|
| Input, cache hit, off-peak | $0.007 | $0.022 | $0.007 |
| Input, cache hit, peak | $0.014 | $0.044 | $0.014 |
| Input, cache miss, off-peak | $0.22 | $0.66 | $0.22 |
| Input, cache miss, peak | $0.44 | $1.32 | $0.44 |
| Output, off-peak | $0.66 | $1.98 | $0.66 |
| Output, peak | $1.32 | $3.96 | $1.32 |
Three footnotes from the official page matter as much as the numbers. Off-peak rates are exactly half of peak rates — the whole table collapses to one rule if you remember that. The vision model prices image tokens as input, converted by image dimensions. And expenses deduct from your granted balance before your topped-up balance, with the platform reserving the right to adjust prices — so treat this table as a snapshot with a timestamp, not a permanent constitution.
How big is a million tokens, in human terms? Roughly 3.3 million characters of English — a few novels' worth — because one English character runs about 0.3 tokens, and one Chinese character about 0.6. (The official token usage guide has the conversion details.) A chat request with a long document attached might carry 50K input tokens and return 2K output tokens. Multiply that by a few thousand requests and you're in the millions per day — which is when the rate card starts to feel like a real budget document.
One more framing device for the table: think of it as three meters on the side of your house. Every request runs all three at once — the cache-miss meter (the expensive one), the cache-hit meter (nearly free), and the output meter (priciest per unit at peak Pro). We'll come back to the meters.
Peak and Off-Peak Hours: The Electricity Bill Model
Peak pricing is the oldest trick in the utility business. Same electricity, same washing machine — run it at 2 AM and the meter spins at half price. The DeepSeek API's version: peak hours are 01:00–04:00 and 06:00–10:00 UTC, Monday through Friday. Everything else is off-peak, including all weekend long.
Translated across timezones:
| Timezone | Peak (Mon–Fri) | Everything else |
|---|---|---|
| UTC | 01:00–04:00 + 06:00–10:00 | Nights, gaps, full weekends |
| Beijing | 09:00–12:00 + 14:00–18:00 | Evenings + weekends |
| US Eastern | 21:00–00:00 + 02:00–06:00 | Daytime + weekends |
Look at that middle row: peak hours are the Chinese workday. And look at the last row: the Americas' working day — US morning through afternoon — lands almost entirely in DeepSeek's off-peak window. If you're building in New York or São Paulo, the night-rate discount applies to your nine-to-five by accident of geography. If you're in Beijing, the off-peak window is your evenings and Saturdays.
The switch took effect August 16 at 16:00 UTC — August 17 at midnight, Beijing time. Anyone whose billing alert went off that week wasn't hallucinating (mine did, and I assumed the alert was broken before assuming the price had): relative to the old flat rates, off-peak input runs roughly fifty percent higher, off-peak output roughly doubled, and peak rates land around three to four and a half times the old flat numbers depending on the lane. We'll unpack why every tutorial disagrees with every other tutorial in a later section.
Three Meters: Cache Hit, Cache Miss, and Output
Back to the meters. Every bill is three readings multiplied by three rates:
The cache-miss meter runs whenever the model reads tokens it hasn't recently seen — a fresh system prompt, a new document, a one-off question. At $0.22–$1.32 per million depending on model and hour, this is where budgets go to die.
The cache-hit meter runs when a request reuses a prefix the infrastructure already holds from a recent request — the same system prompt, the same document, the conversation so far. Those tokens bill at roughly one-thirtieth of the miss rate. Caching is on by default across the API and requires zero configuration: repeat a prefix, get the discount, automatically.
The output meter runs on everything the model writes — including, in thinking mode, the reasoning you never display. Peak-time Pro output at $3.96 per million is the single most expensive unit on the card.
How do you know which meter is spinning? The API tells you, in every response's usage object:
resp = client.chat.completions.create(...)
u = resp.usage
print(u.prompt_cache_hit_tokens, # cache-hit meter reading
u.prompt_cache_miss_tokens, # cache-miss meter reading
u.completion_tokens) # output meter readingLog those three fields for a week and you'll know your real hit rate before believing any estimate — including this article's. Two honesty notes from the docs: caching is best-effort with no guaranteed hit rate, and unused cache entries are cleared after hours to days. A one-time warm-up is not a permanent discount.
What a Real Bill Looks Like
Theory is cheap. I've been breaking my own monthly statements into these three lanes since the switch, and here's a real account that teaches the same lesson at scale: a Chinese developer's May 2026 usage report, published with platform data — a month of heavy agentic coding through a terminal assistant, on the pre-August flat rates.
The headline: 2.04 billion tokens, ¥227.27 — about $31. The split: deepseek-v4-pro burned ¥192.35 (84.6%) across 1.55 billion tokens and 13,809 requests; deepseek-v4-flash took ¥34.93 (15.4%) over 283 million tokens.
The cost anatomy is the part worth tattooing somewhere:
| Cost component | Pro share | Flash share |
|---|---|---|
| Cache-miss input | 74.4% | 57.1% |
| Output | 22.6% | 40.3% |
| Cache-hit input | 3.0% | 2.6% |
And the twist: the Pro workload's cache hit rate was 93.5%. Ninety-three percent of input tokens hit the cheap lane — and still, cache-miss input was three-quarters of the bill. That's not a contradiction; it's the mechanism. Hit tokens billed at 1/120th of miss price (the then-current ratio), so the 6.5% of tokens that missed carried more weight than everything else combined. Hit rate is not savings rate. The volume of tokens that miss decides your bill; the ratio is a vanity metric by comparison.
Under the current 1/30 ratio the arithmetic shifts a little, but the lesson holds: find what forces fresh prefixes into your requests — cold-started sessions, per-request randomized prompts, churning document sets — and you've found your bill.
Estimate Your Monthly Cost
Rate cards answer "what does a token cost." Budgets need "what does my month cost." Three worked profiles below use current off-peak pricing, no cache hits assumed (conservative — real bills usually land below these):
Light — personal scripts and experiments. 200K input + 20K output tokens a day, Flash: about $1.50–$2 a month. Even doubling it stays under a coffee budget.
Medium — a small app with real users. 2M input + 200K output daily, Flash: roughly $16–$18 a month. Add a 60% hit rate and the input lane drops to pocket change — under $8.
Heavy — agentic coding all day. A terminal agent is an input furnace: 30M input + 3M output tokens a day, mixed Flash/Pro at a 3:1 ratio, mostly cache hits after the first pass: call it $60–$120 a month depending on peak exposure. The real case above ran $31 on old rates; the same volume under the new card, well-cached and mostly off-peak, lands in the same neighborhood — the night-rate discount and the hit-lane discount do the absorbing.
The do-it-yourself version: sum a week of usage readings, multiply each lane by its rate at the hours you actually run, times 4.3. Ten minutes with a spreadsheet beats any web calculator — mine is nine rows and has outlived three pricing regimes — because it starts from your traffic shape, which no calculator knows.
Seven Ways to Pay Less
Ranked by leverage, not by effort:
1. Feed the cache a stable prefix. Keep system prompts byte-identical across requests; put volatile content (user question, timestamp) at the end of the prompt. The hit lane is 30× cheaper — no other lever multiplies like it.
2. Default to Flash; spend Pro like it's expensive. Pro costs 3× Flash per lane for tasks it often doesn't visibly outperform on. Route classification, extraction, summarization, and routine chat to Flash; reserve Pro for the reasoning-heavy work where quality pays. Our model guide maps which tasks justify which tier.
3. Move batch jobs off-peak. Nightly summarization, bulk classification, backfills — anything without a human waiting. Half price, same tokens. The electricity model, literally.
4. Cap max_tokens. Output is the priciest lane per unit, and uncapped generations occasionally wander. Most tasks finish well under 10K output tokens; set the ceiling and the ceiling enforces the budget.
5. Meter yourself. Log the three usage fields. Not to admire them — to divide: miss tokens ÷ total input. That one ratio tells you whether levers 1 and 3 are working.
6. Burn the grant first. New accounts carry a granted balance that spends down before your topped-up funds. It's not a fortune and its size is platform policy — check your balance page — but it's the closest thing to free tokens you'll get. (Key setup takes three minutes.)
7. Don't retry into the storm. A 429 means you're at your concurrency cap — 500 for Pro, 2,500 for Flash, per account. Hammering retries at peak rates burns the most expensive tokens while occupying the slots you need freed. Back off with jitter; better, schedule around peak entirely.
Notice what's absent: there is no batch-API discount tier to apply for, no reserved instances, no negotiation. The API's pricing surface is small enough to hold in your head — which is also why the levers are so few and so blunt.
Why Every Price You Find Is Different
Search "deepseek api pricing" today and you'll collect at least three contradictory rate cards, all presented with equal confidence. Here's the timeline that explains them:
| Date | What changed |
|---|---|
| Apr 24, 2026 | V4 launches: Flash $0.14/$0.28, Pro at a promotional $0.435/$0.87 |
| May 22, 2026 | Pro's promotional rates made permanent |
| Jul 24, 2026 | deepseek-chat / deepseek-reasoner aliases retired |
| Aug 16, 2026 | Peak/off-peak billing begins; the current card |
Now the trackers. The most careful English pricing page — dated, sourced, honestly noting "we will not invent a multiplier to fill the gap" — last verified its numbers on August 12, four days before the switch, when new rates genuinely weren't published yet. Another popular calculator was last updated August 15, one day early. A daily-updated tracker shows Flash at $0.00 — free, apparently — which is a bug, not a gift. The pages aren't lazy; the ground moved.
The meta-rule for pricing research of any kind: check the page's own date before its numbers. A pricing page without a "last verified" stamp is a rumor with a table layout. The only source that both updates and admits when it doesn't know is the official one — and even it reserves the right to change tomorrow. Budget with today's card, re-check the official page when the pricing feels off, and expect the card to keep moving: it moved twice in four months this year.
FAQ
Is the DeepSeek API free?Creating an account and key is free, and new accounts get a granted trial balance (amount set by platform policy — check your balance page). Beyond that, every token bills: input and output separately, by model and hour. There's no free tier in the subscription sense.
What's the cheapest possible combination?Flash, off-peak, cache hit: $0.007 per million tokens. That's the floor of the entire card — a dollar buys roughly 143 million hit tokens at that rate.
Why did prices go up in August 2026?The August 16 switch introduced peak/off-peak billing: off-peak roughly 50% above the old flat input rates (output about doubled), peak at 3–4.5×. The stated structure is demand-shaped pricing; the platform hasn't promised stability — prices moved twice between April and August.
Is there a batch API discount?No. DeepSeek lists no batch-processing tier. The equivalent discount is DIY: run bulk jobs off-peak and structure prompts for cache hits.
Is the cache discount guaranteed?No — caching is best-effort, with no promised hit rate, and unused entries clear after hours to days. Stable prefixes raise your hit rate; they don't promise it.
Is billing in US dollars?The official card is USD per million tokens. Third-party resellers and regional platforms may bill in other currencies at their own (usually worse) rates — the official API bills in dollars regardless of where you call it from.
Three moves to make this week: bookmark the official pricing page (it's the only card that updates with reality), log your usage fields for seven days (the meters, read), and push one batch job into the off-peak window (the half-price hour is real). Rates will change again — they've proven that. The three-lane mental model won't: miss tokens expensive, hit tokens nearly free, output tokens the priciest, and the clock deciding which price each one pays. For which model to point that budget at, the V4 guide carries the current table.