EN ▾
Get API key
https://api.deepseekapipricing.com/v1

DeepSeek R1 API Pricing and a Cheaper Chat Alternative

Deepseek r1 api pricing looks like any other rate card, but a reasoning model writes long hidden-style thinking before it answers, and that thinking is normally billed as output. The cost per request can be many times what the visible answer suggests.

Updated

A short straight track beside a long spiral staircase to the same goal, showing direct answers versus costly thinking
A coin feeding light into a transparent server beside a faded row of seven dots, symbolising a short free trial

Key points

  1. Reasoning models spend extra output tokens on thinking, so cost per answer rises even at a fair rate card.
  2. Estimate with: cost = input x input rate + (thinking + answer) x output rate, per 1M tokens.
  3. Many tasks, such as rewriting, extraction and drafting, do not need a reasoning model.
  4. This API is an independent chat endpoint (model uncensored) at $0.15 input and $0.50 output per 1M, not DeepSeek's product.

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 tokensTotal outputOutput cost at $0.50 per 1MVersus a direct answer
0 (direct chat)300$0.000151x
1,0001,300$0.000654.3x
5,0005,300$0.0026517.7x
10,00010,300$0.0051534.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_tokens on 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-USD header 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.

01

Questions and answers

What does DeepSeek R1 API cost per million tokens?

Check DeepSeek's own pricing page for the current numbers, since they change. This site does not quote them. What stays constant is that thinking tokens are usually billed as output.

Is this API the same as DeepSeek R1?

No. It is an independent endpoint serving one open-weight model with ID uncensored. It is not DeepSeek's API and does not route to it.

Is a reasoning model always better?

No. For rewriting, extraction, drafting and roleplay a plain chat model is usually enough, and it avoids the extra thinking cost and delay.

How do I measure thinking tokens?

Read the usage object returned with each response and compare completion tokens with the length of the visible answer. Average over fifty real prompts.

Your key is one form away

Create an account, copy the key, change the base URL. That is the whole setup.

Get API key