skip to content

In DeepSeek's API, what do the deepseek-chat and deepseek-reasoner names select?

level: juniorimportance: must knowfreq 72%

answer

  1. two names, not a long catalogue
  2. one direct, one deliberates first
  3. V3 lineage versus R1 lineage
  4. the name floats to newer generations
  5. weights on Hugging Face are the real pin

basics

~10 s

deepseek-chat selects DeepSeek's general-purpose V3 chat line; deepseek-reasoner selects the R1-style reasoning line that thinks before answering. Both are moving aliases pointing at whatever generation is current, not frozen model versions.

solid answer

~50 s

DeepSeek keeps its API catalogue deliberately tiny: you put either `deepseek-chat` or `deepseek-reasoner` in the `model` field. `deepseek-chat` is the general-purpose conversational line descended from the DeepSeek-V3 series — it answers directly and is the default for chat, extraction, coding help and tool-driven work. `deepseek-reasoner` is the reasoning line descended from DeepSeek-R1: it spends output tokens on an internal chain of thought before committing, which pays off on maths, proofs, multi-step planning and hard debugging. The operational catch is that these are aliases, not immutable IDs. When DeepSeek ships a newer generation, the same alias starts resolving to it, so behaviour can shift without any code change on your side. The durable pin is the open weights published on Hugging Face — repositories such as `deepseek-ai/DeepSeek-V3` and `deepseek-ai/DeepSeek-R1` — served yourself at a fixed revision.

go deeper

for a junior

Know the two names and what each is for: deepseek-chat answers directly, deepseek-reasoner thinks first. Being able to name them and pick one for a simple task is what a screening question is after.

for a middle

Explain that the names are aliases over a family whose weights are also published, and that the alias can move to a newer generation. Be ready to justify routing a specific task to one line or the other.

for a senior

Show that you treat a floating alias as a production risk: you log what you called, you keep a regression eval, and you know the open weights are the only real version pin available.

for a principal

Own the tradeoff between free upgrades and behavioural stability — when a team should accept alias drift for velocity, and when a workload's stability requirement justifies paying for self-hosted, revision-pinned serving.

## The two names DeepSeek's hosted API does not present a long catalogue of dated model IDs the way some vendors do. It presents two working names: - **`deepseek-chat`** — the general-purpose line, descended from the DeepSeek-V3 series. It answers directly: you send messages, you get an assistant message back. Use it for ordinary conversation, summarisation, extraction, classification, code writing, and anything where you want the answer without a deliberation phase. - **`deepseek-reasoner`** — the reasoning line, descended from DeepSeek-R1. Before producing the user-visible answer it generates a chain of thought, and that thinking is itself generated text. It is the choice for problems where the model genuinely has to work something out: competition-style maths, formal or semi-formal proofs, multi-constraint planning, tricky root-cause debugging. Both lines come from the same open-weight programme. DeepSeek publishes the underlying weights, so the hosted names and the downloadable checkpoints are two views of one family rather than two unrelated products. ## Alias, not a version pin The single most important property of these names for anyone running production traffic is that they are **aliases**. `deepseek-chat` means "the current general chat model", not "the exact weights that shipped on some date". When DeepSeek releases a new generation of the V3 line, the alias moves. Nothing in your code changes; the model behind it does. That is convenient — you get improvements for free, without a migration — and it is a hazard, because prompt behaviour, output formatting, refusal boundaries and even token counts can move underneath a system you have already tuned. Treat the alias as a floating dependency, the same way you would treat a `latest` container tag. ## What the names are not - They are **not** model architectures. Sparse-expert structure, parameter counts and attention design belong to the checkpoint, not to the name you type. - They are **not** the Hugging Face repository names. `deepseek-ai/DeepSeek-R1` is a weight repository; `deepseek-reasoner` is an API alias. Sending the repository name as the `model` value is a common first-day mistake and simply fails. - They are **not** tiers of one model in the way a vendor's small/medium/large ladder is. Choosing between them is choosing a *behaviour* — deliberate versus direct — not a size on a price ladder. ## Choosing between them in practice Start with `deepseek-chat`. It is faster and it does not spend output tokens on deliberation. Move a specific call path to `deepseek-reasoner` only when you can show, on your own evaluation set, that the extra thinking actually improves the result for that path. "Use the smart one everywhere" is a real anti-pattern: it inflates latency and output-token spend on tasks such as JSON reformatting or short classification where deliberation buys nothing. Because the two names accept the same request shape, switching a call path is usually a one-line change, which makes A/B evaluation on your own data cheap. Take advantage of that instead of arguing about it in design review. ## Pinning If you need behaviour to be stable — a regulated workload, a benchmark you must reproduce, a contract that promises consistent output — the hosted alias cannot give you that guarantee. The escape hatch is specific to DeepSeek's open-weight strategy: download a named revision of the weight repository and serve it yourself, or use a host that lets you address one exact checkpoint. You then own the upgrade decision, at the cost of owning the serving stack. ## Version note As of mid-2026, `deepseek-chat` and `deepseek-reasoner` are the two primary names on DeepSeek's own API. Because the aliases float, quote the *behaviour* of each line in an interview rather than reciting a point-version number, which will be stale within months.

  • If both names accept the same request body, why not just send everything to the reasoning line?
    Because deliberation is generated text: the reasoning line produces extra tokens before the answer, so you pay in latency and output-token spend on every call. On short extraction, formatting or classification work that buys nothing measurable. Route by task, backed by an evaluation set, and keep the general chat line as the default.
  • How would you find out which generation an alias is currently resolving to?
    You cannot rely on the name itself — it is deliberately opaque. Practically you track it: log responses and any model identifier the API echoes back, run a small fixed probe set on a schedule, and alert on distribution shifts in output length, format or eval score. Treat a silent shift as a change event, not a mystery.
  • Someone sends deepseek-ai/DeepSeek-R1 as the model value. What happens and why?
    The call fails — that string is a Hugging Face weight-repository path, not an API model name. The repository is what you download to self-host; the API expects deepseek-reasoner. Mixing the two namespaces is the usual symptom of copying a self-hosting example into hosted-API code.

saying these in an interview costs you the question

  • Thinks deepseek-chat and deepseek-reasoner are different companies' models
  • Assumes the alias pins one immutable set of weights forever
  • Sends the Hugging Face repo path as the API model name
  • Calls the reasoning line a bigger version of the chat line
  • Routes all traffic to the reasoning line by default

context