DeepSeek V4 Pro's API went live this week, and the cost structure is different enough to matter. The model runs in two modes - thinking and non-thinking - with different pricing and performance profiles. For agent workloads with high input-to-output ratios, V4 Pro is now the cheapest frontier option by a significant margin. Here's what that looks like in practice.
Thinking vs Non-Thinking Modes
V4 Pro offers two inference modes. Non-thinking mode is straightforward - you send a prompt, get a response, pay per token. Thinking mode adds explicit reasoning steps before generating the final output. The model works through the problem internally, shows its reasoning process, then delivers the answer. This takes longer and costs more per request, but produces more reliable outputs for complex tasks.
The practical difference shows up in inference speed. Non-thinking mode returns responses in 2-5 seconds for typical agent queries. Thinking mode takes 10-15 seconds, sometimes longer for multi-step reasoning. That latency matters for interactive applications but is acceptable for background agent tasks where correctness matters more than speed.
Cost Breakdown
The pricing structure favours workloads with large input contexts and relatively small outputs. V4 Pro charges $0.55 per million input tokens and $2.19 per million output tokens in non-thinking mode. Thinking mode doubles the output cost but keeps input pricing the same. For comparison, GPT-4 Turbo charges $10 per million input tokens and $30 per million output tokens.
This matters most for retrieval-augmented generation and agent systems that process large documents or codebases. If your typical request includes 50,000 tokens of context and generates 500 tokens of output, V4 Pro costs roughly $0.03 per request in non-thinking mode. The same request on GPT-4 Turbo costs $0.52. That's a 17x difference. At scale, that changes project economics.
Real-World Performance
The benchmarks tell one story. Production performance tells another. Developers testing V4 Pro report competitive quality on code generation, document analysis, and structured data extraction. The model handles long context reliably - the 1M token window isn't just a spec, it works. Retrieval accuracy stays consistent even with dense technical documents approaching the upper context limits.
The trade-off is latency variability. Non-thinking mode is fast but occasionally produces lower-quality outputs on edge cases. Thinking mode is slower but more consistent. For production systems, this means choosing the right mode based on task requirements. Background document processing can use thinking mode. Real-time user queries need non-thinking mode. The cost difference between the two modes is small enough that optimising for reliability makes sense.
Setting Up V4 Pro API
API setup is standard OpenAI-compatible interface. You swap the endpoint URL, use your DeepSeek API key, and the rest of your code stays the same. Most libraries that support OpenAI's API work with DeepSeek without modification. The model parameter is deepseek-chat for non-thinking mode or deepseek-reasoner for thinking mode.
One practical detail: rate limits on the free tier are tight. For testing, expect throttling after a few dozen requests. Production deployments need paid accounts with higher limits. The pricing documentation is clear about this, but it catches developers off guard if they're prototyping at scale.
When V4 Pro Makes Sense
V4 Pro is the right choice for specific workloads. If your input-to-output ratio is high - document analysis, codebase reasoning, long-form retrieval - the cost savings are real. If you need to keep data internal and want an open-weight model you can eventually self-host, V4 Pro's MIT license matters. If you're building agents that process large contexts repeatedly, the economics shift in DeepSeek's favour.
It's not the right choice everywhere. Interactive applications that need sub-second response times should stick with faster models. Tasks requiring multimodal capabilities won't work - V4 Pro is text-only. Workloads that generate long outputs will find the cost advantage shrinks quickly. And if you're already optimised around a different API, the switching cost might outweigh the savings.
The New Sweet Spot
V4 Pro changes the cost curve for agent workloads. The combination of long context, competitive performance, and aggressive pricing on input tokens creates a new sweet spot. Developers building systems that read more than they write now have a cheaper frontier option. The model is live, the API is stable, and the pricing is transparent. For agent architectures processing large contexts, the math just shifted.