Search results for DeepSeek API pricing disagree with each other right now, and the disagreement is not cosmetic. DeepSeek changed two things in the past month: on August 16, 2026 it moved to peak and off-peak billing with off-peak at half the peak rate, and on September 10, 2026 it shipped DeepSeek-V4.1-Flash, retired the previous Flash generation, and cut API prices again (DeepSeek API changelog). Pages updated in between quote numbers that were correct when they were written and are not on the rate card today.
So this guide does one thing: it sets the current card down with a capture date on every figure, then adds what most pricing posts leave out — how to find out whether the caching discount you were promised actually landed on your bill. Every number below was read from first-party pages on September 15, 2026, not from a planning document. We run Modellix, an API gateway that carries DeepSeek models, so we have a commercial interest in the gateway rows further down; where our listed figure and DeepSeek’s differ, both are printed.
DeepSeek API pricing as of September 15, 2026
DeepSeek’s own pricing page now lists two model rows — deepseek-flash (DeepSeek-V4.1-Flash) and deepseek-v4-pro (DeepSeek-V4-Pro-0813) — and each row carries two prices, because billing is split by time of day. All figures are USD per 1 million tokens, captured September 15, 2026:
| Rate (per 1M tokens) | deepseek-flash (V4.1-Flash) |
deepseek-v4-pro |
|---|---|---|
| Input, cache hit — off-peak | $0.003 | $0.022 |
| Input, cache hit — peak | $0.006 | $0.044 |
| Input, cache miss — off-peak | $0.15 | $0.66 |
| Input, cache miss — peak | $0.30 | $1.32 |
| Output — off-peak | $0.60 | $1.98 |
| Output — peak | $1.20 | $3.96 |
DeepSeek’s published rate card on September 15, 2026: three dimensions, each with an off-peak and a peak figure, plus the footnotes that define the window and the retired model names. Captured from api-docs.deepseek.com.
Two footnotes on that page matter more than they look. The first defines the window verbatim: “Off-peak rates are half of the peak rates. Peak hours are 01:00 - 04:00 and 06:00 - 10:00 UTC, Monday through Friday (all other hours are off-peak).” The second says the legacy names deepseek-v4-flash and deepseek-v4-flash-vision-exp are “still accepted, but the corresponding models have been retired, their requests are served by the DeepSeek-V4.1-Flash model and billed at the Flash price.” Both rows share a 1M-token context window and 384K max output; only the Flash row accepts image input. Those are DeepSeek’s own specifications, quoted from the same page.
Now the other card. On the Modellix LLM price page, also captured September 15, 2026, the catalog carries four DeepSeek rows, not two, and lists one rate per row with the official list price struck through beside it:
| Model ID | Context | Input (list → billed) | Output (list → billed) | Cached read (list → billed) |
|---|---|---|---|---|
deepseek/deepseek-v4-flash |
1.05M | $0.44 → $0.396 | $1.32 → $1.19 | $0.014 → $0.0126 |
deepseek/deepseek-v4-flash-vision |
1.05M | $0.44 → $0.44 | $1.32 → $1.32 | $0.014 → $0.014 |
deepseek/deepseek-v4-pro |
1.05M | $1.33 → $1.20 | $3.96 → $3.56 | $0.044 → $0.0396 |
deepseek/deepseek-v4.1-flash |
1M | $0.30 → $0.30 | $1.20 → $1.20 | $0.006 → $0.006 |
Those billed figures are the page’s own rendering, including its rounding: the discounted output prices above are exactly 90% of the listed rate ($1.188 and $3.564 before the page rounds them for display), and the cache-read figures carry four decimals because that is how the page prints them.
A fourth column on that page lists cached writes, and for all four DeepSeek rows it reads exactly $0. The page’s own documentation does not say whether that means cache writes are not charged or not supported — so neither will we; that column is the one figure on the table we cannot explain, and it should be verified with the provider before it is planned around. The Discount column is the second thing to read carefully: deepseek-v4-flash and deepseek-v4-pro show 10% OFF, while deepseek-v4-flash-vision and deepseek-v4.1-flash show a literal —, which means the billed figure equals the list figure. Two rows have a discount, two do not. On the rows that do not, the gateway price is the vendor price.
Where the two cards agree, and the one cent where they do not
Line the tables up and the reconciliation is exact on the newest row. Modellix’s deepseek/deepseek-v4.1-flash figures — $0.30 input, $1.20 output, $0.006 cached read — match DeepSeek’s peak numbers for deepseek-flash to the cent: $0.30 cache-miss input, $1.20 output, $0.006 cache-hit input. On deepseek/deepseek-v4-pro the output ($3.96) and cache-read ($0.044) figures also match DeepSeek’s peak row exactly, while the listed input figure is one cent higher — $1.33 against DeepSeek’s published $1.32.
The two older rows have no counterpart on DeepSeek’s card at all, because the pricing page no longer lists them: deepseek-v4-flash and its vision variant were retired on September 10 and now route to V4.1-Flash upstream, while the gateway catalog keeps a separate row and a separate rate for each name. Which upstream model the gateway’s older-name row is served by is not stated on either page, and a request log can answer it — the log names the model that actually served each call, which is the last section of this guide. Whether to move production from the older Flash name to V4.1-Flash is a separate decision about model choice, not about pricing, and this guide does not make it.
There is also a one-line note worth having while reading either table: the gateway page lists the stable alias ~deepseek/deepseek-flash-latest, and as of September 15, 2026 it routes to deepseek/deepseek-v4.1-flash — so a client calling the alias is billed at that row’s rate, not the older Flash row’s.
Why the DeepSeek pricing you read elsewhere does not match
Three separate changes explain almost every stale number in circulation, and all three are dated on DeepSeek’s own changelog:
- April 24, 2026 — the V4 generation arrives, and DeepSeek announces that the two legacy names
deepseek-chatanddeepseek-reasonerwill be discontinued in three months. That deadline passed on July 24, 2026. - August 13, 2026, effective 16:00 UTC on August 16 — “we will adopt peak/off-peak pricing, with off-peak prices set at half of the peak-hour prices.” This is the change that broke the flat-rate arithmetic most guides were built on.
- September 10, 2026 — DeepSeek-V4.1-Flash ships,
deepseek-flashbecomes the current name, V4 Flash and V4 Flash Vision Exp retire, and the changelog states plainly: “API prices have been reduced accordingly.”
The practical consequence is visible across one SERP. A guide dated July 2026 still lists Flash at $0.14 per million input tokens and $0.28 output, and states that off-peak discounts are gone. A cost guide whose page footer reads “Last updated: September 04, 2026” lists the same $0.14/$0.28 pair, and gives the off-peak window as 16:30–00:30 UTC. A calculator page dated September 5, 2026 puts Flash at $0.22 off-peak and $0.44 peak. Compare any of those with the table above: the current Flash off-peak input rate is $0.15, and the current peak is $0.30. None of the three is lying about what its source said; all three are describing a rate card that has since been replaced.
If you are pricing a project today, the rule is the boring one: read the vendor page, note the date you read it, and treat every other number — including ours — as a claim to check. That is why both tables above carry a capture date rather than a “current as of” adjective.
Cache hits, cache misses, and the column DeepSeek does not price
On DeepSeek, the cache is not an optional feature you configure; it is applied automatically, and it is priced as a separate input lane. The gap between the two lanes is the largest single lever on a DeepSeek bill, and it is worth stating as a ratio rather than a percentage: on deepseek-flash, a cache hit bills at $0.006 per million input tokens at peak against $0.30 for a cache miss — 50× cheaper — and the same 50× ratio holds off-peak ($0.003 against $0.15). On deepseek-v4-pro the two lanes are $0.044 and $1.32 at peak.
Take a request that sends 100,000 input tokens of which 90,000 hit the cache, and generates 10,000 output tokens. At Flash peak rates that bills $0.00054 for the cached tokens, $0.003 for the uncached ones and $0.012 for the output — $0.01554. The same request with nothing cached is $0.03 plus $0.012, or $0.042. The caching behaviour alone cut 63% off that request. Run the identical workload inside DeepSeek’s off-peak window and it costs $0.00777 — exactly half again, because off-peak halves every dimension at once.
So your effective DeepSeek API cost is not the number printed on the rate card. It is a function of how much of your input repeats: the same model, the same output tokens, and the same month can bill at more than twice the rate depending on prompt structure and time of day. Prompt-prefix stability is the lever (stable system prompts and tool schemas first, variable content last), and scheduling is the second lever.
There is one piece of the cache picture even DeepSeek’s own card does not price. DeepSeek’s table has cache-hit and cache-miss input and output — no line for writing to the cache. The gateway table has a cached-write column, and as noted above it reads $0 for every DeepSeek row while the documentation stays silent on whether cache writes are supported. If your cost model needs that cell filled in, get it from the provider rather than from either table.
The off-peak window, next to a single-rate table
Because DeepSeek prices the same tokens by the clock, the “which number is the price” question has two answers, and the gateway table above gives only one of them. Set the two side by side and the picture is specific rather than rhetorical: the gateway’s listed figures for deepseek/deepseek-v4.1-flash sit exactly on DeepSeek’s peak tier, and the gateway price page carries a single rate per model with no mention of peak windows anywhere in its text (we searched it; “off-peak” does not appear).
We are not going to dress that up, and we are not going to imply otherwise anywhere in this guide. What it means concretely:
- The figure in the gateway table is the figure to budget against on that platform, and for two of the four rows it is 10% below the vendor’s peak rate.
- DeepSeek’s own card prices the same tokens at half during its off-peak window, which covers every hour that is not Monday-to-Friday 01:00–04:00 or 06:00–10:00 UTC. If a workload is schedulable into those hours, that is a vendor-side lever worth understanding.
- Whether off-peak scheduling is passed through on any gateway is not stated on its price page, so do not assume it either way — ask before you plan a budget around it.
This is not a claim that Modellix is cheaper for DeepSeek, because for two of the four rows it is not: the billing is identical to the vendor’s peak rate, and the Discount column says so. What the comparison buys you is a number you can hold still. A single fixed rate per model is easy to model against; the vendor’s clock-dependent card is not.
The same four rows next to 29 other models
A single-model pricing page can only tell you what that model costs. It cannot tell you whether the number is high, and that is the question most teams are actually asking when they search for DeepSeek API pricing. The gateway catalog shows all 30 text models in one table on one key, captured September 15, 2026, which makes a few comparisons mechanical:
- The lowest priced cached read in the catalog is DeepSeek’s. At $0.006 per million,
deepseek/deepseek-v4.1-flashis the lowest cached-input rate of any paid row in the 30-model table — the next lowest isdeepseek/deepseek-v4-flashat $0.0126, and the highest paid rows on their lowest tiers are $0.90 (openai/gpt-6-astra, ≤272K tier) and $0.50 (xai/grok-4.6). Two rows are priced at $0 across all four dimensions (modellix-ai/free-llm,zai/glm-4.7-flash) and are excluded from that comparison. - DeepSeek is not the cheapest input rate, and the same table shows why.
zai/glm-5.3-flashbills at $0.135 input and $0.45 output (from $0.15 / $0.50 listed), andqwen/qwen3.8-flashat $0.16 and $0.47. On input alone, DeepSeek’s Flash row at $0.30 sits behind both. At the other end,anthropic/claude-fable-5.1— whose cache-write rate the vendor does not publish, as our Claude Fable 5.1 price guide documents — andopenai/gpt-6-astraboth list $9.00 input and $45.00 output on their lowest tiers, about 30× DeepSeek Flash on input and roughly 37× on output. - Switching between them is a string, not a migration. All 30 rows answer to the same key at the same host, so comparing two models on your own traffic is a change to the
modelfield rather than a new account and a new invoice — in DeepSeek Harness that string goes in its custom model configuration, which is a question about setup rather than about cost. That is the property to exploit before you commit: run the same prompt set through two rows, then read the logs.
The same table filtered to one provider on September 15, 2026: four DeepSeek rows, struck-through list prices beside billed prices, and the Discount column that reads 10% OFF on two rows and — on the other two. Captured from modellix.ai/llm.
Read the three bullets as billing structure only. They compare rate cards — not output quality, not latency, not fit, and not which model you should choose. The tier table for models that split their input pricing is a separate subject, and the GPT-5.6 generation is the clearest example; if a model you are weighing charges by input-context tier while DeepSeek’s rows are all flat-rate, that difference is the one our GPT-5.6 pricing guide walks through. The method used above — put the vendor’s card next to the gateway’s row and reconcile them line by line — is the same one our GPT-6 Astra pricing breakdown applies to a tiered model, where the tier boundary does far more work than DeepSeek’s flat per-token rate.
Check Today's DeepSeek Rates on Modellix
Log in to see the live DeepSeek rows, compare them against 29 other models on one key, and trace cached tokens and cost per request in your own traffic.
LoginVerify what caching actually saved
Every guide above tells you caching is the lever. None of them tells you how to find out whether your caching did anything, which is the only version of the question that affects a bill. The gateway speaks the OpenAI-compatible protocol at https://llm.modellix.ai/v1 — what “OpenAI compatible” does and does not mean is covered in its own guide — and every request to it is logged with its token buckets and its cost, so the check is arithmetic rather than faith: GET /v1/logs returns, per request, prompt_tokens, completion_tokens, cached_tokens, cost, the model as { provider, model_name }, plus status, duration and throughput fields.
1 | curl -sS "https://llm.modellix.ai/v1/logs?start_time=1757894400&end_time=1757980800&page_size=100" \ |
start_time and end_time are required UNIX seconds and the window may span at most 30 days; page_size defaults to 10 and caps at 100; an optional mdlx_user_id filters by the end-user ID you sent as X-Mdlx-User-Id on inference. Two details change how you read the output. First, the cost field is documented as “Billed amount in sub-pennies (1 = USD $0.0001)… divide by 10000 for dollars”, so a request logged at cost: 777 billed $0.0777. Second, cached_tokens is the number that decides whether the caching rate above ever applied to you: divide it by prompt_tokens and you have your real hit rate, which is the number to compare against the 90%-cached example earlier.
That gives you a three-step audit for a DeepSeek workload. Pull a week of logs, compute the cached share of prompt_tokens across requests, and reprice those same requests at cache-miss rates — the difference is what prefix caching actually saved you. Then check which model_name served each request, which is how you confirm a row you thought you were calling is the row that answered. If the traffic comes through DeepSeek Harness, the same token buckets surface in its own usage view — token usage in DeepSeek Harness is where that side of the reconciliation starts. Documentation for the endpoint’s field list and query parameters is on the same page as the OpenAPI reference; note that the retention period for logs is not published, so export anything you need for a long-run cost model rather than assuming it will still be there in six months.
DeepSeek Rate Cards and Request Logs
Read the LLM gateway guide and the /v1/logs reference for model IDs, cached-token fields, the cost unit, and query parameters in the Modellix documentation.
View DocsFrequently Asked Questions
How much does the DeepSeek API cost?
On DeepSeek’s own card, captured September 15, 2026: deepseek-flash (V4.1-Flash) bills $0.30 per million input tokens on a cache miss and $1.20 per million output tokens at peak, halving to $0.15 and $0.60 off-peak, with cache hits at $0.006 and $0.003. deepseek-v4-pro bills $1.32 and $3.96 at peak, $0.66 and $1.98 off-peak, with cache hits at $0.044 and $0.022. On the Modellix gateway the deepseek/deepseek-v4.1-flash row is $0.30 / $1.20 / $0.006, and the two older Flash rows carry 10% discounts on their listed rates.
Is the DeepSeek API fully free?
No. The hosted API is pay-per-token, and DeepSeek’s pricing page describes deductions from a topped-up or granted balance without publishing a signup allowance. On the Modellix side there is no signup credit either — the $1 registration credit ended on August 19, 2026, and trial credit is now by request. Two rows in the gateway catalog are priced at $0 across all four dimensions, but those are specific model rows, not an account-level free tier.
How is the DeepSeek API so cheap?
Two structural choices, and neither is a discount. Cache hits bill about 50× below cache misses, so workloads whose prompts repeat a long stable prefix pay close to nothing for the repeated part. And the rate card splits by clock: every hour outside Monday-to-Friday 01:00–04:00 and 06:00–10:00 UTC bills at half the peak rate. A workload that is both cache-heavy and schedulable is where the low effective rates come from.
How much does the DeepSeek R1 API cost?
There is no R1 row to price. deepseek-reasoner — the alias R1-class reasoning was served under — was discontinued on July 24, 2026, along with deepseek-chat, and today’s card carries only deepseek-flash and deepseek-v4-pro. Any page quoting an R1 per-token rate is quoting a model that is no longer listed.
Is DeepSeek cheaper than OpenAI or Claude?
On this table’s lowest tiers, yes on input and output — DeepSeek Flash at $0.30/$1.20 peak against $9.00/$45.00 for openai/gpt-6-astra and anthropic/claude-fable-5.1. But that is a rate-card comparison and nothing more, and the cached-read lane can invert an individual decision: openai/gpt-6-astra prices cached reads at $0.90 per million against DeepSeek Flash’s $0.006, a 150× spread in the opposite direction on cache-heavy workloads. Pick the comparison that matches how your traffic is shaped.
How do I check which DeepSeek row my requests actually billed at?
From the request log. GET /v1/logs returns each request’s prompt_tokens, cached_tokens and cost, and model.model_name names the model that served it — which is how you confirm a legacy model name or a stable alias resolved to the row you expected. Divide cost by 10,000 for dollars.
What does the $0 in the Cached Write column mean?
Only what it says: the column shows $0 for DeepSeek rows. The documentation does not state whether cache writes are unsupported or simply not charged, so do not treat the $0 as a confirmed rate. DeepSeek’s own card has no cache-write line to cross-check against — it prices cache hits and cache misses and nothing else on the input side.
Pricing, model availability and rate cards change without notice. Every figure in this guide was captured on September 15, 2026 from DeepSeek’s Models & Pricing page, the DeepSeek API changelog, the Modellix LLM price page, and the Modellix Get LLM logs reference; a full 28-model snapshot of the same catalog as it stood on September 3, 2026 is available in our cross-vendor LLM API pricing comparison, and the catalog has grown since. DeepSeek rate cards have moved twice in the past month, so verify current figures against the live sources before committing spend. Modellix is an API aggregator with a commercial interest in the gateway rows above and is not affiliated with DeepSeek; for two of the four DeepSeek rows its billed price equals the vendor’s peak rate. Calling a model through DeepSeek Harness and setting the model string is covered in its own guide.
