Yes, DeepSeek's API is genuinely cheap at list price—its published rates undercut most major providers, especially on input tokens and cache hits. But "cheap" depends on your workload shape: the headline numbers assume a high cache-hit rate and a modest output-to-input ratio. If your prompts are always novel and your outputs long, your real bill lands closer to mid-tier pricing than the marketing suggests.
What DeepSeek API Pricing Actually Charges For
DeepSeek bills by token—the atomic unit of text a model reads or writes. A rough English rule of thumb is that one token is about three-quarters of a word, so 1,000 tokens is roughly 700–750 words. Every API call has two billable sides. Input tokens are everything you send: system prompt, conversation history, retrieved documents, user message. Output tokens are everything the model generates. They're priced separately, and output is always the more expensive side—typically several times the input rate—because generation is the compute-heavy part.
The third billable category is the one people miss: cache hits. DeepSeek automatically caches repeated prompt prefixes on its servers. If the beginning of your request matches something recently processed, those tokens are billed at a steep discount instead of the full input rate. Tokens that miss the cache are billed as cache misses at the standard input price. There's no extra fee to enable caching and no storage charge mentioned in the standard pricing—it's applied automatically—but you only benefit when your prompts actually repeat a prefix.
One structural detail matters for budgeting: DeepSeek's list prices are quoted per million tokens, and the gap between cache-miss input, cache-hit input, and output is large. So two users sending the same total token volume can pay very different amounts depending on prompt reuse and output length. That's why the "is it cheap" question can't be answered from the rate card alone. You need your own mix of hit/miss input and output tokens.
Input, Output, and Cache Hit Pricing Compared
Rather than quote exact figures that change with model versions, promos, and off-peak discounts, it's more reliable to reason in ratios—and to check the current official pricing page before you commit. As a working estimate, DeepSeek's cache-miss input price sits in the low single-digit dollars per million tokens, cache-hit input is roughly an order of magnitude cheaper than that (often cited around a tenth of the miss price), and output runs several times the miss-input price. Treat these as order-of-magnitude relationships, not exact rates.
The practical comparison to other LLM APIs is directional. Against frontier-tier models from the largest providers, DeepSeek's input pricing is well below—often by a factor of several—and output pricing is also lower, though the gap narrows because everyone charges more for generation. Against budget and small-model tiers from other vendors, the advantage is smaller and sometimes disappears. The honest framing: DeepSeek is among the cheapest options for input-heavy work, competitive-to-cheap for balanced work, and merely reasonable for output-heavy work.
Here's the arithmetic that captures all three categories in one place:
bill = (miss_input_tokens / 1e6) * P_miss
+ (hit_input_tokens / 1e6) * P_hit
+ (output_tokens / 1e6) * P_out
Where P_miss, P_hit, and P_out are the per-million prices from the current rate card. The key insight from this formula is that your cache hit rate—the share of input tokens served from cache—acts as a multiplier on your entire input cost. Moving from 0% to 80% hits doesn't shave a little off the bill; it can cut the input portion by roughly the discount ratio times the hit share. That single variable often matters more than which model tier you pick, which is why the next section digs into it.
Why KV-Cache Hits Change Your Real Bill
Most people compare LLM APIs by looking at the input and output token rates and stopping there. That works fine for one-off requests. It falls apart the moment you build anything with a repeated prefix: a long system prompt, a fixed set of instructions, a document you keep asking questions about, or a multi-turn chat where every new turn re-sends the whole conversation so far.
A token is the unit models read and bill on — roughly a word fragment. A KV cache (key-value cache) is the model's saved internal state for tokens it has already processed. When the start of your new request matches the start of a recent request, the provider can reuse that saved state instead of recomputing it. A cache hit means part of your prompt was served from that saved state; a cache miss means it had to be processed fresh. DeepSeek prices cache hits at a steep discount versus normal input tokens, which is the whole reason its headline input rate looks so low.
The catch: the discount only applies to the shared prefix. The moment your prompt diverges from what was cached, everything after the divergence is billed at the full input rate. So your real bill depends less on your prompt's length than on how much of it stays identical across calls.
Worked example, using illustrative rates (treat these as assumptions, not quoted prices): input at $0.30 per million tokens, cache-hit input at $0.03 per million, output at $1.20 per million.
Scenario A - stable 2,000-token system prompt, 500 output tokens, 10,000 calls:
cache hits: 2,000 x 10,000 = 20,000,000 tokens -> 20 x $0.03 = $0.60
output: 500 x 10,000 = 5,000,000 tokens -> 5 x $1.20 = $6.00
total: $6.60
Scenario B - same prompt but it changes every call (all cache misses):
input: 2,000 x 10,000 = 20,000,000 tokens -> 20 x $0.30 = $6.00
output: $6.00
total: $12.00
Same workload, double the cost, purely from cache behavior. Note that output dominates even in the good case — caching helps, but it doesn't rescue a workload that generates a lot of text.
Running the Numbers With the LLM API Cost Calculator
A calculator is just arithmetic you don't want to redo by hand. The formula:
monthly_cost =
(cached_input_tokens / 1e6) * cache_hit_rate +
(uncached_input_tokens / 1e6) * input_rate +
(output_tokens / 1e6) * output_rate
Before you trust any estimate, run this checklist:
- Separate input into cached and uncached portions — don't apply the discount to the whole prompt.
- Estimate your cache hit ratio honestly. Stable system prompts hit often; dynamic ones rarely do.
- Count output tokens per call, not per session, and remember they're usually the priciest line.
- Include retries and failed calls — they bill too.
- Model peak vs. average volume; a cheap average can hide expensive bursty usage.
- Re-run the numbers when your prompt structure changes, since that's what moves the hit ratio.
Keep the calculator as a small script with your rates as variables. Rates change, and a hardcoded total goes stale silently.
Frequently Asked Questions
Is DeepSeek really cheaper than other LLM APIs?
Often yes, but not in every scenario. DeepSeek's listed per-token rates are low relative to most mainstream models, and its cache-hit discount pushes effective input cost down further when you reuse context. The claim only holds, though, when you compare equivalent model tiers and account for output length: a cheap input price does little for you if your workload is output-heavy. Treat "cheaper" as a per-workload conclusion, not a universal fact.
What is a cache hit and why does it lower DeepSeek costs?
A cache hit means the model's key-value cache (KV-cache — the stored intermediate attention states for tokens it has already processed) already contains the prefix of your request, so that part isn't recomputed. DeepSeek bills cached input tokens at a discounted rate versus uncached input tokens precisely because that work is skipped. Savings show up when you send a stable, long prefix — a system prompt, instructions, or a document — repeatedly across calls.
Do output tokens cost more than input tokens on DeepSeek?
Yes, output tokens are priced higher than input tokens, which is typical across LLM APIs because generation is the expensive direction. Cached input is the cheapest tier, uncached input sits in the middle, and output is the most expensive. So a request that reads a large cached context and writes a short answer costs far less than one that writes a long response, even if both consume a similar total token count.
How do I estimate my monthly DeepSeek API bill?
Break usage into three buckets — cached input tokens, uncached input tokens, and output tokens — multiply each by its per-token rate, then multiply by monthly call volume. As a formula:
monthly_cost = (cached_in * cached_rate
+ uncached_in * input_rate
+ out * output_rate) * calls_per_month
Get the real token counts from actual request logs rather than guessing; the cache-hit ratio in particular is easy to overestimate. Run the numbers on a sample week and scale up — that's an estimate, not a guarantee.
When does DeepSeek stop being the cheap option?
It stops being cheap when your workload is output-dominated, when your prompts share little reusable prefix so cache hits stay rare, or when you need a higher-tier model whose rates are closer to competitors. Long, unique contexts sent once per call get the least benefit from the cache discount. In those cases the headline low price is misleading, and a competing API — or a smaller model — may cost less overall.