Why the rate card understates the bill
A reasoning model such as R1 works through a problem step by step before giving the final answer. Those steps are tokens, and providers generally bill them at the output rate. So a request that returns a 300-token answer may generate thousands of tokens in total.
To keep this article accurate, no DeepSeek rates are printed here. Their prices change, and a stale number is worse than none. Take the current input and output rates from DeepSeek's own pricing page and use the formulas below. Also check how that page describes thinking tokens and whether the API returns them in the response.
cost per request = (input / 1M) x input rate + ((thinking + answer) / 1M) x output rate
The unknown in that formula is thinking. It varies with the question: easy prompts may use a few hundred tokens, hard ones several thousand. Measure it on your own prompts instead of guessing.
The multiplier effect, with numbers
Use our own rate, $0.50 per 1M output tokens, as a neutral example so the arithmetic is checkable. Say a request has a 300-token answer.
| Thinking tokens | Total output | Output cost at $0.50 per 1M | Versus a direct answer |
|---|---|---|---|
| 0 (direct chat) | 300 | $0.00015 | 1x |
| 1,000 | 1,300 | $0.00065 | 4.3x |
| 5,000 | 5,300 | $0.00265 | 17.7x |
| 10,000 | 10,300 | $0.00515 | 34.3x |
The ratio does not depend on the rate card. At any provider, 5,000 thinking tokens plus a 300-token answer is about 17.7 times the output of a 300-token direct answer. Scale it to a month: 100,000 requests with 5,000 thinking tokens each is 530M output tokens. At $0.50 per 1M that would be $265, against $15 for the same 100,000 direct answers (30M tokens).
Tasks that need reasoning, and tasks that do not
Reasoning models earn their cost on problems with several dependent steps. Everyday text work mostly lacks that structure.
Often worth a reasoning model
- Multi-step maths and logic puzzles
- Debugging a tricky piece of code where the cause is not obvious
- Planning tasks with constraints that interact
Usually fine with a plain chat model
- Rewriting, tone changes and translation-style edits
- Extraction into JSON from a page of text
- Classification and tagging
- Drafting emails, product copy and descriptions
- Roleplay, fiction and companion characters, where speed and voice matter more than deliberate step-by-step logic
Chat-style tasks also benefit from lower latency, since there is no thinking phase before the first visible token. If your users watch a streamed reply appear, that matters.
What this API offers instead
This site is an independent, OpenAI-compatible API. It is not DeepSeek's official API and not a reseller of it. It runs one open-weight model from an independent provider, tuned to answer without content refusals for lawful adult use, with model ID uncensored. No benchmarks are published here, so do not assume it matches a dedicated reasoning model on hard problems. Test it on your own tasks.
The rates are $0.15 per 1M input tokens and $0.50 per 1M output tokens, prepaid, with no subscription. Failed or refused requests are not charged, and credit never expires. Context is 100,000 tokens, prompt plus completion. It supports streaming, tool calling and JSON mode. See the pricing page for top-ups and bonuses.
Worked example for the 100,000-request month above, with direct chat answers: input 1,000 tokens each is 100M tokens x $0.15 = $15, output 300 tokens each is 30M x $0.50 = $15, total $30.
Try cheap first, escalate when needed
A sensible setup is to send most traffic to a low-cost chat model and escalate only the prompts that fail a check. The code below tries this API first and falls back to a second client only when a validation fails. Fill in the second provider's base URL and model name from its documentation.
import json, os
from openai import OpenAI
cheap = OpenAI(api_key=os.environ["API_KEY"],
base_url="https://api.deepseekapipricing.com/v1")
# second client: copy base URL and model name from that provider's docs
strong = OpenAI(api_key=os.environ["OTHER_KEY"], base_url=os.environ["OTHER_BASE_URL"])
def answer(question):
r = cheap.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[{"role": "system", "content": "Reply as JSON with keys answer and confidence (0-1)."},
{"role": "user", "content": question}],
)
try:
data = json.loads(r.choices[0].message.content)
if float(data.get("confidence", 0)) >= 0.7:
return data["answer"]
except (ValueError, TypeError):
pass
r2 = strong.chat.completions.create(
model=os.environ["OTHER_MODEL"],
messages=[{"role": "user", "content": question}],
)
return r2.choices[0].message.content
Self-reported confidence is a weak signal, so use a better test when you have one: a schema check, a unit test, or a length rule. The point is to pay for thinking tokens only where they change the result.
Guardrails against surprise bills
Whatever model you pick, put limits in place before you run a large batch.
- Cap output. Set
max_tokenson every call in a loop. On a reasoning model, check how the cap interacts with thinking, because a cap that is too low can cut the answer off after you have already paid for the thinking. - Test on 50 first. Multiply the measured cost by the full count before launching the other 99,950.
- Watch the balance. The
X-Balance-USDheader on this API shows remaining credit after each call, so a script can stop itself below a threshold. - Log usage. Store prompt and completion token counts per request. One outlier prompt that triggers very long output is easy to find if you log, and nearly impossible if you do not.
Next steps
To measure cost on your own data, claim the $0.50 trial credit from the API key page. It needs no card, lasts 7 days and covers over 1,500 chat turns of 800 input and 400 output tokens ($0.00032 each). Running your own prompts through it answers the quality question faster than any rate comparison.
Related reading on this site: the DeepSeek V4 API page, the guide to using LangChain with a compatible endpoint, and the API docs for request details.

