What is DeepSeek R1?

Most chat models produce an answer in one pass: they read your message and start generating the reply. A reasoning model adds a stage before that. R1 first writes a private "thinking" passage - restating the problem, planning an approach, trying it, checking the result - and only then writes the answer you see. In the DeepSeek app this thinking is shown in a collapsible panel, so you can audit how it got there.

R1 was trained with reinforcement learning that rewarded correct final answers on verifiable problems (maths, code, logic). Rather than being shown how to reason, the model learned on its own that spending more tokens planning, verifying and backtracking improves its hit rate - which is why its reasoning reads like someone talking themselves through a puzzle. DeepSeek released R1's weights openly, along with smaller distilled versions, which made it one of the most widely used and studied reasoning models available.

Type

Reasoning / "thinking" model

Plans and verifies before answering; shows the chain of thought.

In the app

Powers DeepThink

Toggle DeepThink in the chat box to switch from V4.1 Flash to R1.

Licence

Open weights

Full model and distilled variants published for download and self-hosting.

How R1's reasoning works

Here's the loop, simplified. Every R1 answer goes through some version of it, and on hard problems it may cycle several times.

  1. Understand. R1 restates the question in its own words and lists the constraints - a surprising number of errors in ordinary models come from skipping this.
  2. Plan. It picks a strategy ("work backwards", "set up an equation", "enumerate the cases") and sometimes notes alternatives.
  3. Work. It executes the steps explicitly, writing intermediate results down rather than holding them in its head.
  4. Verify. It checks the result against the constraints, re-does arithmetic, or tests edge cases. If something fails, it says so - "wait, that's wrong" - and returns to step 2.
  5. Answer. Only now does it write the reply you'd normally see, usually short and confident because the work is already done.
Why it matters: the visible chain of thought is more than a nice touch. You can spot where an answer went wrong, correct a false assumption with one follow-up message, and learn the method rather than just the result.

A worked example: watch R1 solve a problem

Here's a classic word problem that one-pass models often get wrong because the obvious first answer is a trap. The thinking panel is lightly trimmed for length; the structure is exactly what R1 produces.

Prompt (DeepThink on)

A bat and a ball cost Rs 1,100 together. The bat costs Rs 1,000 more than the ball. How much does the ball cost? Then: if I buy 3 bats and 5 balls, what do I pay?

🧠 Thinking · 11 s
  1. understandTwo items, total 1,100. Bat = ball + 1,000. Need the ball's price, then a second total for 3 bats + 5 balls.
  2. planLet ball = b. Then bat = b + 1,000. So b + (b + 1,000) = 1,100.
  3. work2b + 1,000 = 1,100 → 2b = 100 → b = 50. Ball = Rs 50, bat = Rs 1,050.
  4. verifyCheck: 50 + 1,050 = 1,100 ✓. Difference 1,050 − 50 = 1,000 ✓. The tempting answer "ball = 100" would give a bat of 1,100 and total 1,200 - wrong.
  5. workSecond part: 3 × 1,050 = 3,150. 5 × 50 = 250. Total 3,400.
  6. verifyRe-add: 3,150 + 250 = 3,400 ✓. Units are rupees throughout. Nothing else asked.
Final answer

The ball costs Rs 50 (and the bat Rs 1,050). Three bats and five balls come to Rs 3,400.

Why not Rs 100? Because then the bat would be Rs 1,100 and the pair Rs 1,200, not 1,100.

What to notice

  • The verify step explicitly tests the intuitive wrong answer - this is the behaviour that makes R1 reliable on trick questions.
  • Intermediate values are written down, so a slip in arithmetic would be visible and easy to point out.
  • The final answer is short. All the length lives in the thinking, which you can collapse.

Try it yourself: open the chat, switch on DeepThink and paste the prompt. Then ask "what if the bat cost Rs 900 more?" and watch it reuse the same plan. Full walkthrough of the toggle in How to use DeepThink.

When to use R1 - and when not to

Reach for R1 when…

  • The problem has steps that depend on each other: maths, logic, scheduling, unit conversions
  • You want to audit the reasoning, not just get an answer
  • You're debugging and need the model to reason about state, not pattern-match
  • The question is a known trap (riddles, probability, "gotcha" word problems)
  • You're planning with trade-offs: budgets, itineraries, project timelines
  • Research questions, combined with the Search toggle for sources

Stick with Flash when…

  • You want a rewrite, translation, summary or quick fact
  • Speed matters - R1 can take 10–60 s on hard problems
  • You're generating lots of short outputs (R1's thinking tokens add cost)
  • The task is creative or conversational rather than analytical
  • You just need a first draft to react to
Rule of thumb: if you'd want a careful person to "show their working", use R1. If you'd be happy with a quick, confident reply, use V4.1 Flash.

R1 vs V4.1 Flash vs V4 Pro

R1V4.1 FlashV4 Pro
StyleThinks first, shows reasoning, then answersAnswers directly, fastAnswers directly, highest polish
StrengthMaths, logic, planning, debugging, trick questionsEveryday tasks at volume and low costLong, nuanced writing and analysis
SpeedSlow (seconds to a minute)FastestModerate
Cost (API)Moderate - reasoning tokens are billed as outputLowestHighest
Shows its work✓ full chain of thought--
Open weights✓ plus distilled sizes--
In the chat appDeepThink toggleDefaultModel picker where offered

How to access DeepSeek R1

Four routes, from zero-setup to full control. Pick the one that matches how much you want to manage yourself.

Route 1

Chat app - free, no setup

Open chat.deepseek.com or the mobile app, sign in, and tap DeepThink under the message box. Every message in that conversation now goes to R1 and the thinking panel appears above each answer. Add Search for research questions. Works on web, iOS and Android.

Route 2

API - call R1 by name

From the API platform, create a key and send a normal chat-completion request with the reasoner model name. The response includes the chain of thought in a separate reasoning_content field and the final answer in content, so you can log, display or discard the thinking as you like. The API is OpenAI-compatible - most SDKs work with a base-URL change.

# Python · pip install openai
from openai import OpenAI
client = OpenAI(api_key="YOUR_KEY", base_url="https://api.deepseek.com")
r = client.chat.completions.create(
    model="deepseek-reasoner",
    messages=[{"role": "user", "content": "A bat and ball cost 1100…"}],
)
print(r.choices[0].message.reasoning_content)  # the thinking
print(r.choices[0].message.content)            # the answer
  • Reasoning tokens are billed as output - see API pricing
  • Don't pass reasoning_content back in the next turn; send only content
  • Step-by-step setup: API guide
Route 3

Harness Desktop - R1 inside your files

Harness Desktop is DeepSeek's open-source desktop agent. Choose R1 as the model for a session and it will reason over your actual code or documents - ideal for tracking down a subtle bug across files, or planning a large edit before making it. Switch back to Flash for routine edits to keep sessions snappy.

Route 4

Self-host the open weights

R1's weights are published under a permissive licence. The full model needs a multi-GPU server, but DeepSeek also released distilled versions - the same reasoning style trained into much smaller models - that run on a single workstation GPU or even a laptop with quantisation. Serve them with any popular open-source inference tool and call them through the same OpenAI-style API.

  • Complete privacy and no rate limits
  • Fine-tune on your own problems
  • Expect weaker results from the smallest distills; test before you rely on them
  • Licence, sizes and download locations: open weights - self-hosting

Prompting tips for R1

R1 behaves a little differently from ordinary chat models. Here's what to do, why it helps, and what it looks like in practice:

Do thisWhy it helpsExample
State the whole problem in one messageR1 builds its plan from the first message. Adding details later forces it to re-plan and wastes thinking tokens."Three suppliers, budgets A/B/C, delivery must be before the 20th, prefer local. Which one?"
Skip "think step by step"It already reasons before answering. The instruction is redundant and can make the reply over-long.Just ask the question. Add "give the final answer on one line" if you want it short.
Describe what "done" looks likeAfter a long think, a clear target keeps the final answer crisp and in the format you need."Answer as a single number in rupees." · "Return a 3-row table."
Correct the reasoning, not the answerPointing at the faulty step lets R1 redo only that part instead of starting from scratch."In step 2 you assumed VAT is included - it isn't. Redo from there."
Keep system prompts shortLong role instructions compete with the reasoning for attention."You are a careful tax assistant. Show currency on every figure." - that's enough.
Pair with Search for factsR1 reasons well but doesn't know recent events; Search supplies the inputs it reasons over.DeepThink + Search on: "Compare this month's fixed-deposit rates at the three biggest banks."
Ask it to check your workVerification is R1's strongest habit - use it on your own solutions."Here's my answer. Verify each step independently and flag any that's wrong."
Maths / logicSolve: [problem]. Constraints: [list]. Give the final answer on its own line.
DebuggingHere's the code and the failing test. Reason about what state causes the failure, then propose the smallest fix.
DecisionsI'm choosing between [A] and [B] for [goal]. Weigh [criteria], note where you're uncertain, then recommend one.
Checking workHere's my solution to [problem]. Verify each step independently and tell me if any step is wrong.

Limits and cost

R1 is powerful but not free of trade-offs. Here's each limit in plain terms and the simplest way around it:

LimitWhat it means for youWhat to do
Slower repliesHard prompts can take 10–60 seconds while R1 writes out its reasoning.Use it for problems worth the wait; in the API, stream responses so users see progress.
Higher cost per requestReasoning tokens are billed as output. A question that costs a fraction of a cent on Flash can cost several times that on R1.Route only hard cases to R1; keep everyday traffic on V4.1 Flash. See pricing.
Still makes mistakesVisible reasoning makes errors easier to find, not impossible.Read the thinking panel for anything important; verify figures independently.
Over-thinks simple asks"What's the capital of France?" gets a paragraph of deliberation.Turn DeepThink off for quick facts, rewrites and translations.
Knowledge cut-offWithout Search it doesn't know recent events, prices or releases.Switch on Search, or use search - fetch in the API.
Image input varies by routeWhether you can attach images depends on how you access R1.Check the API guide; the chat app supports uploads where the model allows.
Busy at peak times"Server busy" is more common with DeepThink right after a release.Wait a minute and retry, or use the API, which has separate capacity. See troubleshooting.
Bottom line: R1 costs time and tokens in exchange for accuracy on hard problems. Use it deliberately, and let Flash handle the rest.

DeepSeek R1 - frequently asked questions

Is DeepSeek R1 free?

Yes in the chat app via DeepThink, within normal usage limits. The API charges per token; self-hosting the open weights is free apart from your hardware.

Is R1 the same thing as DeepThink?

DeepThink is the toggle in the app; R1 is the model it switches to. In the API you request R1 directly as the reasoner model.

Can I see DeepSeek R1's reasoning?

Yes. The app shows it in a collapsible panel above each answer; the API returns it in a separate reasoning_content field.

Is R1 better than V4 Pro?

Different jobs. R1 wins on problems that need step-by-step reasoning; V4 Pro wins on long, nuanced writing and analysis. See all models compared.

How does R1 compare to ChatGPT's reasoning models?

Comparable on maths and coding benchmarks, far cheaper via API, open-weight, and it shows the full chain of thought rather than a summary. Details in DeepSeek vs ChatGPT.

Can I run R1 on my laptop?

The distilled versions, yes - a 7B or 8B distill runs on a modern laptop with quantisation; 32B needs a good desktop GPU. The full model needs a multi-GPU server.

Does R1 work with web search?

Yes. Turn on both DeepThink and Search in the app, or use the search - fetch tools in the API to feed it current sources.

Why is R1 slow?

Because it writes out its reasoning before answering, which can be hundreds or thousands of tokens. That's the trade for accuracy on hard problems; use Flash when speed matters.

Still curious? Ask us - we add good questions to this page.