DeepSeek alias for V4 Flash thinking mode — 1M context, open chain-of-thought reasoning (legacy alias, slated for deprecation).
DeepSeek Reasoner is a text-only reasoning model from DeepSeek, optimized for tasks that require deep logical deduction and extended context understanding. It is accessible through OrcaRouter's…
DeepSeek Reasoner is strongest in tasks that benefit from extended reasoning and large context windows. These include proving mathematical theorems, solving complex word problems, generating and debugging code across multiple files, and answering questions that require synthesizing information from many parts of a document. It can also handle multi-turn conversations where each turn references a large shared context without losing track. Because of its high output limit, it is useful for generating structured reports or long-form explanations. The model's text-only nature restricts it from tasks that involve image understanding, but within text domains, it performs deep analytical work reliably.
DeepSeek Reasoner's pricing is $0.44 input / $0.87 output per 1M tokens, which is higher than many smaller or faster models. You should choose this model when your task requires the full 1M-token context window or the deep reasoning capability. For short prompts (a few thousand tokens) that don't demand step-by-step logic, a cheaper model like a smaller instruction-tuned LLM would be more cost-effective. Similarly, if your application needs low latency for real-time responses, a lighter model may be preferable. However, if you are analyzing a large document or solving a complex problem that requires logical chaining, the investment in DeepSeek Reasoner can lead to higher accuracy and less manual validation time.
The primary strengths of DeepSeek Reasoner are its enormous context window, high output token limit, and focus on logical reasoning. It can maintain coherence across hundreds of pages and produce long, well-structured outputs. The model supports text input only but likely understands multiple languages, though this is not explicitly confirmed. Its reasoning capability means it can explain its thought process, which aids in debugging and verification. Additionally, because OrcaRouter passes through the provider's rate with zero markup, there are no hidden costs. For users who need to scale deep analytical tasks, this model offers a strong combination of capacity and reasoning fidelity.
Specific benchmark scores for DeepSeek Reasoner are not provided in the available facts. However, the model is part of DeepSeek's family of reasoning-focused models, which have previously demonstrated strong performance on mathematics (e.g., GSM8K, MATH) and coding (e.g., HumanEval) benchmarks in public evaluations. Users are encouraged to test the model on their own datasets to validate performance for their specific use case. Given its large context window, the model is particularly suited for tasks that evaluate long-range dependency understanding. Without official numbers, objective comparisons should be made through direct experimentation on the OrcaRouter API.
Despite its strengths, DeepSeek Reasoner has limitations. First, it accepts text input only—no images, audio, or video. Second, the large context size can lead to higher latency, especially when inputs approach 1 million tokens; first-token time may be significantly longer than for smaller models. Third, while the model is strong at reasoning, it may not match the creative fluency of some general-purpose models for tasks like poetry or open-ended storytelling. Fourth, because it is a specialized reasoning model, it may over-analyze simple requests, using more tokens than necessary. Finally, pricing, while competitive for its class, is still higher than lightweight alternatives, making it uneconomical for trivial queries.
DeepSeek Reasoner offers a context window of 1,048,576 tokens and a maximum output of 384,000 tokens. This makes it one of the few models capable of handling documents longer than many full-length novels in a single prompt. The context window includes both input and existing conversation history; the model uses the full window to generate responses. The output limit of 384,000 tokens allows for very long generated content, such as entire codebases or comprehensive reports. Users should note that using the full context may increase latency and cost proportionally. These specifications are confirmed in the model's facts and are directly supported when calling the model via OrcaRouter's OpenAI-compatible API.
On OrcaRouter, pricing for DeepSeek Reasoner is based solely on the number of tokens consumed, billed at the provider's rate with zero markup. Input tokens are charged at $0.44 per 1M tokens, and output tokens at $0.87 per 1M tokens. There are no additional platform fees, subscription charges, or hidden costs. Charges are calculated per API call based on the total tokens processed. OrcaRouter bills users directly, and the cost reflects the raw provider rate. This transparent pricing model allows developers to scale usage predictably without worrying about profit margins added by the gateway.
The cost per token can be derived from the per-million rates: input tokens cost $0.00000044 per token, and output tokens cost $0.00000087 per token. In practice, a typical request of 10,000 input tokens and 1,000 output tokens would cost approximately $0.0044 + $0.00087 = $0.00527. Because the context window can be as large as 1,048,576 input tokens, a full-context request would cost around $0.46 for input alone. The output limit of 384,000 tokens would cost up to $0.334 if fully utilized. These costs scale linearly, so users should monitor token usage, especially when leveraging the maximum context and output capacities.
OrcaRouter explicitly states that DeepSeek Reasoner is priced at the provider's rate with zero markup. This means there are no additional fees beyond the per-token cost listed. There are no monthly minimums, setup fees, or charges for API access. The only costs incurred are for tokens consumed. Users can verify charges by comparing the billed amount against token usage logs. OrcaRouter's pricing transparency ensures that what you see is what you pay, with no unexpected surcharges for high-volume usage or special features.
The available facts do not mention any caching mechanisms or volume discounts for DeepSeek Reasoner on OrcaRouter. It is possible that OrcaRouter may offer standard caching for frequent prompts, but this is not confirmed. Similarly, no discount tiers are described. The pricing is strictly per-token at the provider rate. Users should assume no built-in caching or discounts unless explicitly communicated by OrcaRouter. For high-volume usage, you may contact OrcaRouter support to inquire about any custom arrangements, but as of the provided data, the pricing model is straightforward pay-as-you-go.
To call DeepSeek Reasoner through OrcaRouter, use the OpenAI-compatible endpoint at base_url https://api.orcarouter.ai/v1. Set the model name to "deepseek/deepseek-reasoner". All standard OpenAI chat completion parameters are supported, including messages, max_tokens, temperature, top_p, and stop sequences. For example, a request would look like: curl https://api.orcarouter.ai/v1/chat/completions -H "Authorization: Bearer YOUR_API_KEY" -d '{"model":"deepseek/deepseek-reasoner","messages":[{"role":"user","content":"Solve this math problem..."}],"max_tokens":10000}'. The API returns completions in the same format as OpenAI's chat endpoint, making integration trivial for existing applications.
Beyond standard chat parameters, DeepSeek Reasoner supports the usual OpenAI-compatible configuration options: temperature (default 1, range 0-2), top_p (default 1), frequency_penalty, presence_penalty, stop, and max_tokens (up to 384,000). Because it is a reasoning model, temperature settings affect the randomness of the reasoning chain; lower temperatures produce more deterministic outputs. There is no special reasoning-specific parameter exposed in the API—the reasoning behavior is intrinsic to the model. Users can also use streaming via the stream parameter to receive tokens incrementally. All parameters must be passed in the JSON body of the POST request to the chat completions endpoint.
Migrating to OrcaRouter is straightforward because the API is fully compatible with OpenAI's chat completion format. Replace your existing base URL with https://api.orcarouter.ai/v1 and update the model name to "deepseek/deepseek-reasoner". Generate an API key from OrcaRouter's dashboard and include it in the Authorization header. Adjust your code to use the new base URL and model identifier. The rest of your logic, including message formatting, parameter names, and response parsing, remains unchanged. This compatibility allows you to switch providers with minimal code changes, often just a few lines in the client configuration. Test with a small payload to confirm connectivity and pricing before scaling.
Compared to OpenAI's GPT-4 series, DeepSeek Reasoner offers a significantly larger context window (1M tokens vs. 8K-128K for GPT-4 Turbo) and higher output limit (384K vs. 4K-32K). Its pricing per token is lower ($0.44/$0.87 vs. GPT-4 Turbo's roughly $10/$30 per 1M tokens), making it more cost-effective for long-context tasks. However, GPT-4 Turbo supports multimodal input (images, audio) and may have broader world knowledge. DeepSeek Reasoner focuses specifically on reasoning and may produce more detailed chain-of-thought responses. For tasks that don't require extremely long context or deep reasoning, GPT-4 Turbo's broader capabilities might be preferable.
Anthropic's Claude 2 and Claude 3 Opus have context windows of 100K-200K tokens, which is smaller than DeepSeek Reasoner's 1M tokens. Claude models also support some multimodal inputs in newer versions. DeepSeek Reasoner's pricing is substantially lower (approximately one-tenth the cost of Claude 3 Opus for input tokens). Claude models emphasize safety and helpfulness, while DeepSeek Reasoner is optimized for reasoning depth. If your application requires processing very long documents at lower cost, DeepSeek Reasoner has an edge. For tasks needing safety guardrails and multimodal support, Claude may be more appropriate. Both are accessible via OrcaRouter's API.
Choose DeepSeek Reasoner when your workload demands a context window larger than 200K tokens, or when you need to generate outputs exceeding 32K tokens. It is ideal for systematic reasoning tasks where showing the intermediary logical steps is valuable. The cost advantage is most pronounced for high-volume, long-context applications, as the per-token price is significantly lower than premium models from OpenAI or Anthropic. However, if your tasks are short, require multimodal input, or benefit from larger training datasets, alternatives may be better. Evaluate your token usage patterns and reasoning requirements to determine if DeepSeek Reasoner's strengths align with your priorities.
OpenAI-compatible — keep the SDK you already use
https://api.orcarouter.ai/v1import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.orcarouter.ai/v1",
api_key=os.environ["ORCAROUTER_API_KEY"],
)
response = client.chat.completions.create(
model="deepseek/deepseek-reasoner",
messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)max_tokensresponse_formatstream| Input / 1M tokens · Off-peak | $0.242 |
|---|---|
| Output / 1M tokens · Off-peak | $0.726 |
| Cache read / 1M · Off-peak | $0.0077 |
| Peak hours | 01:00–04:00, 06:00–10:00 ×2 (UTC) |
| Input / 1M tokens · ×2 | $0.484 |
| Output / 1M tokens · ×2 | $1.452 |
| Cache read / 1M · ×2 | $0.015 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
What developers are saying this week
GET /api/public/models/deepseek/deepseek-reasonerOpen @misc{orcarouter_deepseek_reasoner,
title = {deepseek/deepseek-reasoner API},
author = {deepseek},
year = {n.d.},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/deepseek/deepseek-reasoner}
}deepseek. (n.d.). deepseek/deepseek-reasoner API. OrcaRouter. https://www.orcarouter.ai/models/deepseek/deepseek-reasoner