# DeepSeek API Pricing 2026: Models, Cache, Output
By Desmond Achebe · 2026-10-21 · Source: https://www.activepieces.com/blog/deepseek-api-pricing-2026-models-cache-output
---
**There are no monthly plans for DeepSeek's API**.
You pay per million tokens used, at separate rates for cached input, uncached input and output, and the rates differ by model and by time of day, which is worth remembering if you wire the API into an automation tool like [Activepieces](https://www.activepieces.com) and want to estimate what a workflow will cost.
Your bill is those three rates multiplied by your own traffic, so a quoted rate tells you little until you know your mix.
## DeepSeek API pricing today, plan by plan
### DeepSeek V4 model pricing comparison table
To see what moves a bill, set the two current models side by side on the dimensions in the table below.
Treat those cells as questions to settle before you budget, because DeepSeek has revised the page's prices during 2026.
| | deepseek-flash (V4.1-Flash-1017) | V4-Pro-0813 |
|---|---|---|
| Context | not published | not published |
| Max output | not published | not published |
| Input per 1M, cache hit, off-peak | not published | not published |
| Input per 1M, cache hit, peak | not published | not published |
| Input per 1M, cache miss, off-peak | not published | not published |
| Input per 1M, cache miss, peak | not published | not published |
| Output per 1M, off-peak | not published | not published |
| Output per 1M, peak | not published | not published |
| Rate limits | not published | not published |
_Prices and plan limits checked against [docs.claude.com](https://docs.claude.com/en/docs/about-claude/models/overview) and [claude.com](https://claude.com/pricing) and [openai.com](https://openai.com/chatgpt/pricing) and [gemini.google](https://gemini.google/subscriptions) on October 20, 2026._
Read the table in two passes. First compare the cache-hit and cache-miss rows, since DeepSeek bills a repeated prompt prefix at the lower rate. Then compare off-peak and peak, because DeepSeek prices a batch job that can wait differently from one that can't.
Choosing between the two starts with images: deepseek-flash is the fast, cheap option and accepts images, while V4-Pro is the higher-capability model and takes text only. If your workload sends screenshots or scanned pages, that settles the choice before price does.
If it's text only, the question becomes whether Pro's extra capability saves you retries, since a failed run costs the same as a successful one.
### DeepSeek peak and off-peak API rates
DeepSeek charges one rate during its peak window and a lower rate outside it. I could not confirm the hours or the time zone of either window from the pricing page, so I won't print any. Read them there before you schedule anything.
The same goes for the size of the discount. Off-peak rates are half of peak across the board, and the one off-peak figure used below is a $0.003 cache hit.
A batch job gets the lower rate only if it runs inside the off-peak window, so a job that drifts past the boundary bills at peak.
The $0.30 miss and $0.006 hit in the sections below are peak rates. The $3.96 output rate for V4-Pro is the one figure I can't label as peak or off-peak, so check which window it belongs to.
### Free credits, top-ups and how billing works
You add funds first, and each request draws them down; billing is prepaid usage. I have no confirmed figure for any free credit, so don't budget around one.
Top up in amounts you can afford to lose to a runaway loop.
Wire the balance into a check that tells you when it drops, whether that's a script or a flow in [Activepieces](https://www.activepieces.com), which allows unlimited flows on every plan including free, that pings you.
## What DeepSeek costs at realistic monthly usage
At 100M tokens a month, the input side of a V4.1-Flash bill runs from about $4 to $24 depending on workload, and **cache-hit share explains most of the gap**.
The formula is input tokens × cache-miss rate, plus cached tokens × cache-hit rate, plus output tokens × output rate.
Priced at peak rates, the input terms in the table below show how far the workload mix alone moves the bill. I've left out the V4-Pro column because I have no confirmed rate for it here.
| Workload | Tokens a month | Input/output split | Cache-hit share | V4.1-Flash input bill |
|---|---|---|---|---|
| Support bot | 1M | 80/20 | 70% | $0.08 |
| Support bot | 10M | 80/20 | 70% | $0.75 |
| Support bot | 100M | 80/20 | 70% | $7.54 |
| Document summariser | 1M | 90/10 | 10% | $0.24 |
| Document summariser | 10M | 90/10 | 10% | $2.44 |
| Document summariser | 100M | 90/10 | 10% | $24.35 |
| Coding assistant | 1M | 60/40 | 80% | $0.04 |
| Coding assistant | 10M | 60/40 | 80% | $0.39 |
| Coding assistant | 100M | 60/40 | 80% | $3.89 |
Because the bills scale in a straight line with volume, the spread comes from the mix, and the output charge sits on top of every figure.
At peak, a cache miss costs $0.30 per 1M tokens, according to the [DeepSeek API Docs](https://api-docs.deepseek.com/quick_start/pricing/). A hit costs $0.006.
**That's a 50-fold gap**, so a bot that resends the same system prompt on every ticket pays the low rate on most of its input. At 70% hits, 100M tokens cost $7.54 on the input side.
### DeepSeek cost for a document summariser
Because each document is new, the cache catches little of it. Sovyron's data shows that at 10% hits, this workload **costs three times what the support bot does** at the same volume, even though its output share is smaller.
Moving the same summariser to 90% hits, for example by sharing one long instruction block, would cut its input bill by about 87%.
In a coding assistant, repeated repository context caches well, so the input line stays small at $3.89 for 100M tokens. The output share is the largest of the three, at 40%, so output is where this bill grows.
Off-peak hits drop to $0.003, which halves an already tiny line.
Take your monthly tokens and multiply by your input share. Split that into hit and miss tokens, and price each at its rate.
Then add output tokens times the output rate from the pricing page. If your cache-hit share is a guess, run the sum at two values, because the answer swings most on that one input.
## Hidden DeepSeek API costs and limits people hit
Beyond the cache-hit share, which moves your bill most, four other items outside the list price can also change what you pay or when your jobs stop, and DeepSeek's docs leave some of them vague.
- A cache miss costs the full input price, so every uncached token carries the headline rate.
- **DeepSeek bills reasoning tokens as output**, so a model that thinks at length costs more than its visible answer suggests.
- The concurrency cap for deepseek-flash is 2,500, so a burst of parallel jobs hits a ceiling before your budget does.
- Output caps limit how long a response can run, so a long generation may be cut off mid-answer, and you still pay for what was produced.
- Zero-balance behaviour isn't clearly documented, so assume requests fail once credit runs out and test it.
### Reasoning tokens and long outputs
Because the docs bill reasoning tokens as output, a short visible answer can hide a long, paid thought. Price a reasoning call by its total generated tokens, not by the text you read.
Per request, the output cap bounds the worst case, but the docs are unclear on whether truncated reasoning still bills in full. Assume it does until a test call shows otherwise.
### DeepSeek cache misses and prompt design
If you want to know your effective input rate, look at cache status, not model choice: a miss sits far above a hit.
**Place stable material (system prompt, instructions, reference documents) at the start of every request and variable content at the end.** Reordering or editing the opening text can turn hits into misses.
If you want to know your effective input rate, look at cache status, not model choice: a miss sits far above a hit.
The docs don't say how long a cached prefix survives, so measure your own hit share on real traffic rather than assuming it.
### Rate limits, errors and server busy responses
Treat the 2,500 concurrency figure for deepseek-flash as a ceiling on simultaneous requests, not a promise of throughput. At peak times the service may return busy or error responses instead of queuing you.
Build in retries with backoff and count retried calls in your cost model, since a failed attempt that consumed tokens may still bill. Whether that happens isn't stated clearly in the docs.
### Model renames and deprecations
Do not count on a model name staying put. The current models are deepseek-flash and deepseek-v4-pro, and the changelog is where retirements are announced.
A pinned name that's retired will start returning errors, and a silent alias change can alter your price and output length without any code change on your side.
Check the changelog before each billing cycle, and log the model name on every call so you can see when behaviour shifts.
## DeepSeek versus the closest API alternatives on price
Logging the model name on every call also lets you price each call against rivals. On output tokens DeepSeek V4-Pro, at [$3.96 per 1M](https://api-docs.deepseek.com/quick_start/pricing/), is the cheapest flagship compared here, which gives you a cost floor to measure every alternative against.
### Price comparison table with check dates
Read the table as a ratio, with output prices per 1M tokens as charted by [Sovyron](https://sovyron.com/): GPT-6 Astra at $50 costs about 12.6 times V4-Pro, so a 1,000-token reply is $0.05 against roughly $0.004.
At $20, [Claude](https://claude.com/pricing) Opus 5.5 is about 5 times V4-Pro, so model selection determines whether a million output tokens costs you $4 or $20.
[Gemini](https://gemini.google/subscriptions) 4 Argon at $10 is about 2.5 times. Qwen3.8 Max at $6 is only about 1.5 times, so the gap there is small enough that other line items can erase it.
| Model | Output per 1M tokens | Multiple of V4-Pro |
|---|---|---|
| DeepSeek V4-Pro | $3.96 | 1.0x |
| Qwen3.8 Max | $6 | 1.5x |
| Gemini 4 Argon | $10 | 2.5x |
| Claude Opus 5.5 | $20 | 5.1x |
| GPT-6 Astra | $50 | 12.6x |
Because prices move, write the date you read each vendor's page beside each figure.
Output only: that is all the table covers. Input prices, cache discounts, context windows and rate limits aren't in it, so take them from each vendor's own page before you trust a monthly total.
### Where cheaper per token is not cheaper overall
If a cheaper model writes twice as long or spends more reasoning tokens, a 2.5x price advantage shrinks toward nothing, because a low output rate multiplies by whatever the model actually emits.
Against Qwen3.8 Max, a 1.5x edge disappears if V4-Pro needs 50% more output to do the same job, so **efficiency, not per-token price alone, predicts actual savings**.
You pay for rate limits too, and that is the second leak. A cheap model that throttles you at peak forces retries or a queue, and you pay for both in latency and engineering time.
On the other side of the bill, cache hits cut just as hard. A support bot that resends the same long system prompt benefits far more from a deep cache discount than from a lower headline rate, so compare cached-input pricing before you compare output.
### Steps to estimate your DeepSeek API cost
1. Pull 100 real requests and count average input tokens, output tokens and reasoning tokens per call, because your actual traffic patterns will differ from what spreadsheets assume.
2. Multiply those by each model's per-1M rates from its own page, and note the date you read it.
3. Rerun the sums with your actual cache-hit share, not the vendor's best case.
4. Find the rate limit for your expected peak requests per minute, and drop any tier you can't read without a sales call.
5. Set a spending alert at 120% of your calculated monthly figure before you route live traffic, so you catch runaway spend before it spirals.
## Run this in Activepieces
A platform that resells you DeepSeek has already picked your model and set the rate, so you can't price your own cache-hit share against it.
Activepieces runs on your own provider key, so the DeepSeek spend lands on your DeepSeek balance at the rate on DeepSeek's page, and the Bring-Your-Own-Key tiers on the pricing page are the place to compare that against a reseller's markup.
Reaching it from Claude, ChatGPT, Cursor or any MCP client keeps the strategy yours, and MoneyGram, Moneypenny, Alan and FundingSocieties run Activepieces in production.
A daily balance check is the cheapest control to add before comparing vendors, and this flow shows the balance falling toward your floor while you can still act:
1. Start with a Schedule trigger that runs once a day.
2. Send an HTTP request to the balance endpoint in DeepSeek's API docs, authenticated with your API key. DeepSeek has no dedicated step here, so this one is a plain request.
3. Continue only if the returned balance is below the threshold you set from your own workload estimate.
4. Send a message through Slack or Gmail, so the warning lands where you already look.
5. Optionally, append a row to Google Sheets with the date and balance, which shows your burn rate over time.
If the balance falls faster than your cache-hit assumptions predicted, the log shows it before the invoice does.
Activepieces Cloud's free plan costs $0 with no card needed and allows unlimited flows, so this flow costs nothing to build.
## Frequently asked questions
These answers reflect DeepSeek's documentation as read on 2026-10-21.
### Is the DeepSeek API free to use?
No. The API is billed per token against a balance you top up. I can't confirm a standing free tier, and any promotional credit on a new account is a one-off.
### Does DeepSeek charge a monthly subscription for the API?
No. The API is pay-as-you-go, so you pay for the tokens you send and receive and nothing for sitting idle.
That makes a quiet month cheap, but it also means nothing caps a busy month except your balance and your own alert.
### Is the DeepSeek chat app priced the same as the API?
No, they are separate products with separate billing. The consumer chat app is free to use as of this date, while the API meters every token.
### What happens to my requests when I hit a rate limit?
You get an error response, usually a 429, and the request does no work. DeepSeek's docs describe limits that adjust with server load rather than a fixed published quota, so you can't plan against one number.
Build in retries with backoff and a ceiling on attempts. Without a ceiling, a retry loop can turn a busy period into duplicate spend. If a request fails midway, check how it was billed before you resend it.
### Do DeepSeek's prices change, and where do I see the latest?
Yes. DeepSeek has adjusted prices and model offerings before, and the pricing page in its API docs is the source to trust. Treat any figure in a blog post, this one included, as stale until you've matched it to that page.
Re-price your workload whenever the page or its model list changes, and again whenever you switch between deepseek-flash and deepseek-v4-pro.
## Related reading
- [DeepSeek API Pricing 2026: Cost per 1M Tokens](https://www.activepieces.com/blog/deepseek-api-pricing-2026-cost-per-1m-tokens)
- [DeepSeek Search and Fetch API: Pricing and Reliability](https://www.activepieces.com/blog/deepseek-search-and-fetch-api-pricing-and-reliability)
- [DeepSeek V4.1 Flash API: Pricing, Specs & Features (2026)](https://www.activepieces.com/blog/deepseek-v4-1-flash-api-pricing-docs-2026)
## References
- [Sovyron](https://sovyron.com/)
- [Sovyron, OpenAI, DeepSeek](https://api-docs.deepseek.com/quick_start/pricing/)