DeepSeek Open-Sourced Its API Engine. Claude and OpenAI Should Worry About the Price

In four days, from October 17 to October 20, DeepSeek put out three releases. First there was DeepSeek-V4.1-Flash-1017, an updated model with open weights, and the same announcement opened up DeepSeek's Search and Fetch APIs to every user. Then on October 20, DeepSeek open-sourced DeepInfer, the inference framework its own production service runs on. So the obvious question is, is this actually a threat to Claude and OpenAI, or another benchmark chart we will forget in a month?

I think the short answer is yes, but probably for a different reason than the headlines give. In DeepSeek's own benchmark table, Claude is actually still ahead on most of the rows. The part I think Anthropic and OpenAI should worry about is how cheap DeepSeek has made it to switch, and how little work that switch takes. Even at DeepSeek's peak-hour price, Opus 5.5 charges at least 13 times as much per token as DeepSeek's API, and DeepSeek has published a guide for running Claude Code itself on its model.

So let's first go through what DeepSeek actually released, and then I will come back to why I think the price is the real problem.

What DeepSeek actually released

The model: DeepSeek-V4.1-Flash-1017

The first release is the model. In its release note, DeepSeek describes V4.1-Flash-1017 as a small update to V4.1-Flash that does better on benchmarks, gets through tasks faster and writes shorter outputs. It is already live on DeepSeek's website, in the app and through the API.

DeepSeek also put the weights on Hugging Face, under the MIT license. Basically that means anyone can download the model, change it and build commercial products with it. According to the model card, it has 763 billion parameters and a 1 million token context window, and it can read images along with text.

DeepSeek says the model was trained with reinforcement learning using self-feedback, to get better at building a whole project on its own from start to end. The release page shows a few demos, for example a racing game you can play in the browser, a Portal 2 recreation in the Godot engine and a 3D model of the Forbidden City. But DeepSeek picked these demos itself, so I would see them as the model on a good day, and I wouldn't treat them as proof of anything.

The engine: DeepInfer

The second release is DeepInfer, and personally I find this one more interesting. To see why, it helps to know what an inference framework (also called a serving engine) does. After training, what you have is the model weights, and the weights are basically a huge file of numbers that can't answer anything by itself.

The inference framework is the software that loads those numbers onto GPUs, takes requests from thousands of users at the same time, groups them into batches and streams the tokens back, and it tries to do all of that as quickly and cheaply as it can. So if the weights are a recipe, the inference framework is the restaurant kitchen where that recipe gets cooked for millions of people every day.

Much of what makes serving cheap happens in that kitchen, and The Next Web, citing Bloomberg, points out that AI companies normally keep these techniques to themselves.

DeepSeek says DeepInfer runs its large-scale production services, and the code is under Apache 2.0. It bundles kernel libraries that DeepSeek open-sourced earlier, such as FlashMLA, DeepGEMM and DeepEP, along with ways to spread one model over many chips and a speculative decoding method DeepSeek calls DSpark.

Speculative decoding sounds complicated, but the idea is pretty simple. A draft step quickly guesses the next few tokens (up to five by default in DeepInfer), and then the main model checks all of those guesses in one pass. So whenever the guesses are right, you get several tokens for about the cost of one step.

DeepInfer can also make the output follow a JSON schema or a regex, which is what people mean by structured outputs, and it supports deterministic sampling and batch-invariant inference, though those last two only work on NVIDIA for now.

But this is not the full kitchen. The README itself says a complete inference service needs three more pieces that this release doesn't include. One is a KV cache system, which is basically where the model keeps what it has already read so it doesn't have to read it again. Another is prefill and decode disaggregation, where reading your prompt and writing the tokens happen on separate machines. And the last is load balancing across replicas.

It also supports only one model, V4.1-Flash, at the moment, and just two kinds of hardware: NVIDIA's SM100 GPUs (the Blackwell generation) and Huawei's Ascend 950 chips. So older NVIDIA cards such as Hopper aren't supported.

Search and Fetch for agents

The third release is smaller, but I think it says a lot about where DeepSeek is going. Its Search and Fetch APIs are now available to everyone. With Search you send a query and get back structured results from DeepSeek's own search engine, and with Fetch you send a URL and get the page back as Markdown.

That is exactly what an agent or a RAG app (an app that looks things up first and then answers) needs to read the live web. Each API costs $0.75 for every 1,000 successful requests, and failed requests, empty results and timeouts aren't billed.

One detail in the docs tells you a lot, I think. Calls that come through server-side tools in DeepSeek Harness (its own framework for coding agents), Claude Code or Codex are free until billing kicks in on October 31 at 16:00 UTC. Claude Code is Anthropic's coding agent and Codex is OpenAI's, so DeepSeek's own pricing notes name both competitors' tools, and I'll come back to why that matters.

Does it actually beat Claude and GPT?

Here the headlines and the actual table don't really say the same thing. DeepSeek's model card has a table of 11 benchmarks that puts V4.1-Flash-1017 next to two closed models, Anthropic's Claude Opus 5 and OpenAI's GPT-5.6 Sol. Against GPT-5.6 Sol, DeepSeek looks really strong, with a higher score on 9 of the 11. Against Opus 5 it is mostly the other way, because DeepSeek leads on only 4 and Opus 5 leads on the other 7.

For example, DeepSeek wins on DeepSWE v1.1, a software engineering benchmark, with 77.0 to Opus 5's 74.0, and on Automation-Bench it is 60.5 to 50.3. But Opus 5 is clearly ahead on others, with 51.8 to 42.3 on Terminal-Bench 4.0, 75.3 to 68.2 on NL2Repo-Bench, and 56.3 to 42.6 on Humanity's Last Exam without tools.

There is one more detail in that table. DeepSeek ran Terminal-Bench with the Claude Code harness, so its score was measured inside Anthropic's own tool.

Two caveats really matter here. First, DeepSeek produced these numbers itself, and I couldn't find anyone who has verified them independently so far. Second, the table compares against Opus 5, which is no longer Anthropic's newest model. Claude Opus 5.5 came out on September 22, close to a month before DeepSeek's release, and Anthropic says it is about 40% cheaper to run than Opus 5 on typical workloads, but it isn't anywhere in DeepSeek's comparison.

So I wouldn't take this table as proof that DeepSeek beats Claude. What I take from it is that an open-weight model has caught up enough with the closed models, at least for coding and agent tasks, that for plenty of everyday work you might not notice the gap.

The price gap is the part that hurts

And this is where things get serious for Anthropic and OpenAI. DeepSeek's pricing page lists deepseek-flash, which V4.1-Flash-1017 now serves, at $0.30 per million input tokens and $1.20 per million output tokens during peak hours. Off-peak you pay half, so $0.15 and $0.60, and at peak, cached input is close to free at $0.006 per million.

Anthropic's Claude pricing page lists Opus 5.5 at $4 per million input tokens and $20 per million output tokens, and Sonnet 5.5, its cheaper model for everyday work, at $2 and $10. So even against DeepSeek's peak price, Opus 5.5 charges more than 13 times as much for input and more than 16 times as much for output, and off-peak that difference doubles.

Let's try a quick example. Say an agent run takes in 2 million tokens and produces 200,000, and we leave caching out. With Opus 5.5 you would pay $8 for input and $4 for output, so $12, and with deepseek-flash at peak the same run comes to 84 cents ($0.60 plus $0.24). Even Sonnet 5.5 would charge $6, which is still about 7 times what DeepSeek charges.

Keep in mind that I made this example up from per-token prices. What you really pay for a finished task depends on how many tokens each model burns through, and how many times it makes a mistake and needs another attempt.

In fairness to Anthropic, its small model Claude Haiku 5.5 is priced at $0.10 for input and $0.50 for output on prompts of up to 100,000 tokens, and per token that is actually cheaper than deepseek-flash. So DeepSeek isn't selling the cheapest tokens around. What it does is claim scores close to Opus 5 on several coding and agent benchmarks, at a price a lot closer to Haiku's than to Opus's.

Still, a low price alone wouldn't be enough, because changing models usually means a lot of work, like updating code, moving to different tools and getting used to a new workflow. DeepSeek has cut most of that work out. Its API has an Anthropic-compatible endpoint, so code you wrote for the Anthropic SDK can talk to DeepSeek once you swap the base URL and the API key.

Model names that start with claude-sonnet or claude-haiku get mapped to deepseek-flash, and anything starting with claude-opus goes to deepseek-v4-pro, DeepSeek's bigger model.

DeepSeek's coding agents guide then spells out which environment variables to set if you want Claude Code to run on deepseek-flash. So put all of it together. DeepSeek's Terminal-Bench score was measured in the Claude Code harness, its docs explain how to point Claude Code at its model, and for now, search calls from Claude Code and Codex cost nothing. What DeepSeek is telling developers, I think, is basically this: carry on with the tools you already like, and only swap the model underneath for one that costs far less.

Why DeepInfer matters for open source

For the open source community, I think DeepInfer might end up being a bigger deal than the model. Getting the weights is one thing, but with 763 billion parameters, the hard part is serving the model to lots of users quickly and cheaply, and that knowledge usually never leaves the company. Now DeepSeek is showing how it does this for its own API, and SiliconANGLE reports that its future models will get their inference code in this same repository.

There's a nice loop in how this happened, too. The README says DeepInfer was first built mostly on vLLM, a popular open source inference engine, and also borrowed ideas from SGLang and NVIDIA's TensorRT-LLM. So DeepSeek started from open source work, made it better for its own production, and has now handed it back.

And people in open source are already reacting. The Next Web reports that the vLLM project thanked DeepSeek and said it would use ideas from DeepInfer to improve its own V4.1-Flash support. Companies that host DeepSeek models can now run them with the same techniques DeepSeek relies on.

DeepInfer also supports Huawei's Ascend 950 chips alongside NVIDIA, so teams that can't easily get NVIDIA hardware now have a serious starting point that already exists as code.

Where the threat is weaker than it looks

This brings up a fair question. If DeepSeek is so cheap, why would anyone keep paying for Claude? There are real reasons, and I think it is easy to get carried away if you leave them out.

First, running the model yourself isn't realistic for most people. It has 763 billion parameters, and when DeepSeek tested DeepInfer's performance, it used 4 GPUs for prefill and 64 for decode, all of them SM100 chips. You would also have to add the missing pieces yourself, like the KV cache system and load balancing. So for a small team, what open really gives you is code you can read and learn from, and to actually use the model you will still be calling an API, from DeepSeek or from a provider that hosts it.

Then there is trust. A day before DeepInfer came out, the US Department of Homeland Security told federal civilian agencies to stop buying DeepSeek products and remove them from their systems, including other companies' products built on DeepSeek's technology. DHS said it was worried that the Chinese government could get access to DeepSeek's infrastructure and collect personal information.

This isn't a ban on private use. But if your customers include the US government, or your company has strict rules about where data can go, convincing your team to send its prompts to DeepSeek's API won't be easy. Open weights could help, because you can run the model somewhere you control, but the reporting doesn't make clear whether a copy you host yourself would count under the order. And hosting it yourself takes you right back to the hardware problem.

Finally, there are the benchmarks. DeepSeek ran them itself, the Opus it compares against is already one version behind, and on some reasoning tests Claude's lead is still large. So until independent results show up, I think the fair read is that DeepSeek comes close on coding and agent work but is clearly behind on some other things.

So, is DeepSeek a threat to Claude and OpenAI?

Going back to the question we started with, I'd say the answer depends on which part of their business you look at. For really hard work, where you want the strongest model and mistakes are expensive, I don't see this release changing much by itself. Claude still comes out ahead on most of DeepSeek's own comparison, and anyone paying for the very best model is paying for that small bit of extra quality at the top.

But I think a lot of everyday AI work looks very different. Most of it is agents opening files, running searches, writing boilerplate and repeating the same sort of task thousands of times, and for work like that the price makes a big difference.

That is the work DeepSeek is going after. It has a cheap Flash model trained for coding and agent tasks, a search API built for agents, an API that plugs into the tools developers already use, and the serving code that lets other hosting companies run it cheaply as well.

So where I think this really hurts Anthropic and OpenAI is their pricing power and lock-in. If moving from Claude to DeepSeek only means setting a few environment variables, then for any work where DeepSeek is good enough, they can't ask for a much higher price. They will have to keep showing that the extra quality is worth paying many times more for.

So if your product runs on Claude or GPT right now, I wouldn't switch everything over because of one benchmark table. I would pick a handful of tasks from your actual work, try them on deepseek-flash, and compare what each finished task costs and how good the result is with what you get now. The price per token alone won't tell you that. If the results are close for your kind of work, the threat is already real for you, and it will show up on your bill. If they aren't, you'll at least learn what the extra money gets you.

Prices, benchmark scores and release details come from the DeepSeek and Anthropic pages and the news reports linked in this article. Prices can change, so check the pricing pages before you budget anything.