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.
Reasoning / "thinking" model
Plans and verifies before answering; shows the chain of thought.
Powers DeepThink
Toggle DeepThink in the chat box to switch from V4.1 Flash to R1.
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.
- 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.
- Plan. It picks a strategy ("work backwards", "set up an equation", "enumerate the cases") and sometimes notes alternatives.
- Work. It executes the steps explicitly, writing intermediate results down rather than holding them in its head.
- 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.
- Answer. Only now does it write the reply you'd normally see, usually short and confident because the work is already done.
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.
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?
- understandTwo items, total 1,100. Bat = ball + 1,000. Need the ball's price, then a second total for 3 bats + 5 balls.
- planLet ball = b. Then bat = b + 1,000. So b + (b + 1,000) = 1,100.
- work2b + 1,000 = 1,100 → 2b = 100 → b = 50. Ball = Rs 50, bat = Rs 1,050.
- 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.
- workSecond part: 3 × 1,050 = 3,150. 5 × 50 = 250. Total 3,400.
- verifyRe-add: 3,150 + 250 = 3,400 ✓. Units are rupees throughout. Nothing else asked.
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
R1 vs V4.1 Flash vs V4 Pro
| R1 | V4.1 Flash | V4 Pro | |
|---|---|---|---|
| Style | Thinks first, shows reasoning, then answers | Answers directly, fast | Answers directly, highest polish |
| Strength | Maths, logic, planning, debugging, trick questions | Everyday tasks at volume and low cost | Long, nuanced writing and analysis |
| Speed | Slow (seconds to a minute) | Fastest | Moderate |
| Cost (API) | Moderate - reasoning tokens are billed as output | Lowest | Highest |
| Shows its work | ✓ full chain of thought | - | - |
| Open weights | ✓ plus distilled sizes | - | - |
| In the chat app | DeepThink toggle | Default | Model 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.
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.
- Free with the standard usage limits
- Thinking panel is collapsible; tap to read it
- Guide: How to use DeepSeek · Login help
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_contentback in the next turn; send onlycontent - Step-by-step setup: API guide
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.
- Free, public preview on macOS, Windows and Linux
- Best with Coding mode; also useful for spreadsheet logic
- Setup: Harness guide
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 this | Why it helps | Example |
|---|---|---|
| State the whole problem in one message | R1 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 like | After 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 answer | Pointing 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 short | Long 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 facts | R1 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 work | Verification 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." |
Solve: [problem]. Constraints: [list]. Give the final answer on its own line.Here's the code and the failing test. Reason about what state causes the failure, then propose the smallest fix.I'm choosing between [A] and [B] for [goal]. Weigh [criteria], note where you're uncertain, then recommend one.Here'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:
| Limit | What it means for you | What to do |
|---|---|---|
| Slower replies | Hard 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 request | Reasoning 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 mistakes | Visible 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-off | Without Search it doesn't know recent events, prices or releases. | Switch on Search, or use search - fetch in the API. |
| Image input varies by route | Whether 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. |
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.