DeepSeek V4.1 Flash-1017: same price, search fees

On October 17, DeepSeek swapped the model behind deepseek-flash on its API for a new version, DeepSeek-V4.1-Flash-1017. The model name didn’t change, the price didn’t change, and the score went up on all 11 benchmarks DeepSeek lists.

A second thing happened the same day, and it may matter more to you directly. DeepSeek opened its own web search and page fetch as standalone APIs at $0.75 per 1,000 successful requests. DeepSeek also emailed its API users: if you use DeepSeek through DeepSeek Harness, Claude Code or Codex, the searches and page fetches those tools run on the server side have already been hitting these two APIs. They’re free for now; per-request billing starts at 00:00 Beijing time on November 1.

This piece looks at both together. It draws on DeepSeek’s announcement, pricing page, Search & Fetch guide, changelog, Claude Code integration page and the model card on Hugging Face, all of which I opened and checked on October 19; the search price comparison also uses the Claude Platform pricing page. Every score here is DeepSeek’s own. I did not run any benchmarks myself.

Which model got replaced?

Figure 1: DeepSeek’s October 17 announcement (source: DeepSeek API Docs)

The naming is a little tangled, so let’s sort it out. DeepSeek released V4.1-Flash on September 10. That announcement called it the smallest model in a new architecture family: a 552B-parameter MoE with 8B active parameters on the input side and 16B on the output side, plus native image understanding. V4.1-Flash-1017 is a minor revision of it; the Hugging Face model card’s own words are “a minor update to DeepSeek-V4.1-Flash”.

For API users, the most important line is in the changelog: the calling method and pricing are unchanged, and deepseek-flash now gets you the new version. The website and app switched too. The old model names deepseek-v4-flash and deepseek-v4-flash-vision-exp still work, but the pricing page’s footnote is explicit that requests to them are now served by 1017 and billed at the Flash price.

So you’re already on the new model without changing anything. That’s good news, and also the thing to watch: if your product is sensitive to output format, this upgrade happened silently, and it’s worth running your own regression tests.

The weights went up on Hugging Face and ModelScope at the same time, and the model card lists the license as MIT. There’s one number I can’t reconcile. The size Hugging Face displays automatically is “763B params”, which doesn’t match the 552B in the September announcement. The former is the platform’s count from the weight files and may include the vision module or other components, but the model card doesn’t explain it, and I’m not sure where the gap comes from.

The model card also gives recommended sampling settings: temperature 1.0, top_p 1.0, and max tokens of 256K or more. This release also ships without a Jinja chat template and provides a Python reference implementation instead, which matters if you host it yourself.

How much did the scores go up?

Figure 2: DeepSeek’s official score table (source: DeepSeek API Docs)

The official table has six columns. I subtracted the September version from 1017 row by row and put the result in the table below.

Figure 3: The two versions, benchmark by benchmark (data: DeepSeek announcement, Hugging Face model card)

All 11 went up. The biggest gain is Terminal-Bench 4.0, from 31.2 to 42.3, an extra 11.1 points. Next come ProgramBench at +8.8 and Apex Bench v1.1 at +7.5. The smallest is ZeroBench-main, up just 2 points. Overall the progress clusters in agent tasks like operating a terminal and writing complete projects from scratch, which fits the second section of the announcement, about building complete projects from nothing.

Against Claude Opus 5 in the same table, 1017 wins 4: DeepSWE v1.1 (77.0 vs 74.0), Automation-Bench (60.5 vs 50.3), Agents’ Last Exam (35.4 vs 28.6) and Apex Bench (72.1 vs 65.8). It still trails on the other 7, by 13.7 points on HLE and 9.5 on Terminal-Bench 4.0.

A few things to know before reading the table:

• These are all DeepSeek’s own numbers. The table’s footnote says Terminal-Bench 4.0 was run with the Claude Code agent harness, DeepSWE with Mini-SWE-V2, and ZeroBench-main was scored as Pass@5, meaning one correct answer in five tries counts as a pass. A different harness could give different scores.
• The HLE cell has two numbers. In 42.6/44.0, the starred 44.0 covers only the text-only subset.
• The comparison is with Opus 5, not Opus 5.5, which is what Anthropic sells now. Anthropic’s current flagship is Opus 5.5, and this site has a breakdown of how its pricing works out. It isn’t in the table, so treat any “beats Claude” framing with caution.

Benchmark scores are only a reference point to begin with. Independent evaluations will give a better read.

How much does “shorter output” actually save?

The announcement says the new version finishes tasks faster and writes shorter output, but the text gives no numbers. The numbers are in a chart attached to the announcement.

Figure 4: Cost per task against solve rate (source: DeepSeek API Docs)

The horizontal axis is the average cost per DeepSWE task on a log scale; the vertical axis is the share solved on the first try. Reading positions off the chart: 1017 at max reasoning effort lands at roughly $0.2 per task with 77.0%; the September version at the same effort is around $0.5 with about 74%. If I’m reading it right, the cost per task fell by more than half on the same price list. That’s what the announcement means by improving performance and cost together.

The chart’s footnote says the other models’ points come from the public DeepSWE v1.1 leaderboard as of September 22, with OpenAI’s models taken from OpenAI’s own chart. Reading positions the same way, Claude Opus 5 runs from about $1.7 per task at low effort to about $12 at max, and Claude Fable 5 from about $4 to $22. Neither goes above 74%.

To be clear, I estimated these numbers from positions on the chart; they aren’t official values. And cost per task depends on the per-million-token price, which is far lower for DeepSeek to begin with, so what the chart really compares is the combined effect of price list and output length.

The price didn’t change: output is still $0.60 per million tokens

Figure 5: The two models and their prices on the pricing page, with the feature rows in between omitted (source: DeepSeek API Docs)

I opened the pricing page to check. The deepseek-flash column already reads DeepSeek-V4.1-Flash-1017, and the prices are the same as in September. Per million tokens off-peak: $0.003 for cache-hit input, $0.15 for cache-miss input, $0.60 for output. Peak hours double everything, to $0.006, $0.30 and $1.20.

Peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC, Monday through Friday, excluding Chinese public holidays. In Taiwan time that’s 9 a.m. to noon and 2 p.m. to 6 p.m. on weekdays. Everything else, including all weekend, is off-peak. This site covered how the scheme came about when V4.1 Flash first launched.

The other column is deepseek-v4-pro, version DeepSeek-V4-Pro-0813. The September 10 announcement originally said V4-Pro would be phased out, with requests routed to Flash from September 14. The changelog later added that, in response to user demand, the V4 Pro API would continue after September 14 with unchanged billing. So it’s still there. Its off-peak output price is $1.98 per million, 3.3 times Flash, and its concurrency limit is 500 against Flash’s 2,500.

Put those two numbers together, add that the September announcement already said multiple parties’ tests had V4.1-Flash ahead of V4-Pro on performance, cost and speed, and my view is that there’s little reason to pick V4-Pro for a new project unless you have a specific one. This becomes very practical once we get to Claude Code.

Search and Fetch APIs: $0.75 per 1,000

Figure 6: Search and Fetch prices (source: DeepSeek API Docs)

The announcement says both APIs run on DeepSeek’s own search engine, which handles hundreds of millions of requests a day worldwide. I read the Search & Fetch guide and pulled out the rules you’ll actually run into:

• Two endpoints. Search is POST /v1/tools/search and Fetch is POST /v1/tools/fetch, using the same key as the model API.
• One search returns up to 50 results at the same price. count defaults to 10 and can be 1 to 50; the guide says it doesn’t affect the per-request price. Each result has a short snippet for UI display (about 100 to 200 characters) and a longer summary meant for models (about 600 to 800).
• Search operators are supported. site:, lang:, after:, before:, exact phrases and excluded terms all work.
• Fetch returns Markdown. Give it a URL and it returns the title and the content converted to Markdown. URLs can be up to 8,192 characters.
• Only successful requests are billed. A request counts only if it returns HTTP 200 with an actual result: a non-empty result list for Search, page content for Fetch. Failures, empty results and timeouts are free.
• The rate limits are tight. Search and Fetch are each limited to 5 requests per second per account, however many keys you have. Fetch also has a per-domain limit. Going over returns a 429.
• A low balance blocks requests outright. Among the error codes in the guide, 402 means insufficient balance. Charges come out of your topped-up balance or granted balance, and when you have both, the granted balance goes first.

The 5-per-second rule strikes me as more important than the price. If your agent tool spins up several subagents that look things up at the same time, it can hit that ceiling easily. I haven’t tested this, but going by the rules, heavily parallel search workflows will need their own queueing or retries.

Using Claude Code with DeepSeek? A new charge starts in November

DeepSeek offers an Anthropic-format endpoint, so plenty of people point Claude Code at DeepSeek to save money. The official integration page is just a few environment variables: set ANTHROPIC_BASE_URL to https://api.deepseek.com/anthropic, put your DeepSeek key in ANTHROPIC_AUTH_TOKEN, and point the models at deepseek-flash.

The same page covers search. When Claude Code decides it needs the web, it calls the Web Search tool, and DeepSeek’s API runs the search. The page is blunt about it: summarizing the search results generates extra model token costs, and the search requests themselves are also billed under the Search API. The “currently free” in the email refers to that second part.

On when billing starts, the pricing page says 00:00 Beijing time on November 1, and the announcement says 16:00 UTC on October 31. They’re the same moment. Taiwan is in the same time zone as Beijing, so for readers here it’s midnight going into November 1.

How much extra will it cost? Start with one call. A successful search or fetch costs $0.00075. On the Flash price list, that equals 5,000 off-peak cache-miss input tokens, or 1,250 output tokens. On its own that’s cheap, but it’s charged per call, and the search summaries then get billed again as input tokens.

Here’s a hypothetical example; I picked the numbers, and it isn’t anyone’s bill. One session that runs 40 searches and fetches 60 pages makes 100 requests, or $0.075. One person running five such sessions per working day for 22 days a month comes to $8.25, before the model’s own tokens. That’s not much for an individual. If a team shares one account for automation, it’s worth checking usage first.

There’s one more thing, involving Opus, where DeepSeek’s Claude Code page contradicts itself. The environment variable example sets ANTHROPIC_DEFAULT_OPUS_MODEL to deepseek-flash[1m], but the mapping table further down the same page says requests whose model name starts with claude-opus map to deepseek-v4-pro and are billed at the V4 Pro price. My reading: if you don’t set the Opus slot as in the example, the Opus requests Claude Code sends will land on V4-Pro, whose output price is 3.3 times Flash’s. After setup, check the usage page on the DeepSeek platform to confirm the model you’re being charged for is the one you think.

Is that price cheap?

Figure 7: Search and fetch pricing at both companies (data: DeepSeek pricing page, Claude Platform pricing page)

The Claude API is the most direct comparison, since many people already switch between the two. The Claude Platform pricing page says the web search tool costs $10 per 1,000 searches, plus the cost of the search results as input tokens, and searches that error aren’t billed. The web fetch tool carries no extra charge; you pay only for the tokens the fetched content takes up.

So for search alone, DeepSeek is much cheaper: $0.75 against $10, about a thirteenth. Fetch is the other way around. Claude doesn’t charge separately for it, while DeepSeek bills per call. If your workflow is mostly reading docs and GitHub pages rather than searching, DeepSeek’s charge here is a new cost.

I didn’t check the pricing pages of the dedicated search API vendors one by one. Startup Fortune’s report cited a comparison published on launch day putting the price per 1,000 calls at roughly $5 for Brave, $4 to $7 for Exa, $1 to $5 for Perplexity and $8 to $16 for Tavily. That comparison didn’t name its source, and the report itself calls it a rough guide, which is all I can pass it on as here.

The same report raised another point: DeepSeek’s privacy policy says personal data is collected, processed and stored in the People’s Republic of China, and the Search & Fetch guide says nothing about retention or processing region. Your search queries and the URLs you fetch all go to DeepSeek. I didn’t read the privacy policy myself; this is the report’s account. If your project has data residency requirements, this matters more than the price.

My take, and what would change it

On the model, there’s not much to hesitate over. Same price, same calling method, all 11 of DeepSeek’s own benchmarks up, and going by the chart, cost per task down by more than half. If you use deepseek-flash, you already have it. All that’s left is running your own tests to make sure the shorter output hasn’t broken a format you rely on.

The search APIs depend on who you are. Developers calling the API directly get a cheap search source with clear rules, and billing only successful requests is friendly to users. But for people running Claude Code or Codex on DeepSeek, it’s a new line on the bill from November 1, and many of them don’t know their tools have been calling this API in the background. I think emailing users and leaving two weeks of runway was the responsible move. The email is just very short and easy to skip as marketing.

My concrete advice comes down to three things: before the end of October, look at how often your tools trigger search and fetch; make sure the Opus slot in Claude Code isn’t falling through to V4-Pro; and if you need lots of parallel searches, deal with the 5-per-second limit first.

What would change my mind? If independent evaluations show 1017’s gains don’t hold up under other harnesses, the “free upgrade” needs a discount. If DeepSeek raises the search price later, or relaxes the 5-per-second limit enough to support many agents in parallel, the role of these two APIs changes with it. Conversely, if bills after November show typical users paying only a few cents more a month, this whole thing is simply good news.