DeepSeek V4.1 Flash 1017: What Changed, Benchmarks, Pricing, Search API and Local Setup

Updated 2026-10-26: This guide now covers the V4.1-Flash-1017 weight update, the new Search & Fetch API, the 15 October outage and the credits DeepSeek issued for it, Unsloth's 1017 GGUFs (which need an unmerged llama.cpp PR), and the DHS FASCSA order that affects US federal contractors. V4-Pro is still served at its own prices.

DeepSeek has shipped two V4.1-Flash checkpoints in five weeks. The first, on 10 September 2026, introduced a new architecture and cut prices. The second, DeepSeek-V4.1-Flash-1017, keeps the same architecture, the same API name and the same prices, and changes only the weights. DeepSeek calls it "a Pareto improvement in performance and cost": higher benchmark scores, faster task completion and shorter outputs. If your code calls deepseek-flash, you have been on 1017 since 17 October without changing anything.

This guide covers what changed in 1017 and by how much, the specs and prices, how to call the model and the new Search and Fetch endpoints, where V4-Pro stands, which benchmark numbers hold up under independent testing, and what running it locally takes now. All figures were checked against DeepSeek's docs, the Hugging Face model cards, Artificial Analysis, Vals AI and the relevant GitHub threads on 26 October 2026.

What changed in DeepSeek V4.1 Flash 1017?

The DeepSeek change log entry for 17 October is short: the Flash model was upgraded to DeepSeek-V4.1-Flash-1017, the web and app models were updated too, developers keep calling deepseek-flash, and "The API calling method and pricing remain unchanged." DeepSeek recommends DeepSeek Harness 0.2.1-rc.1 or later, and says the model was tuned for its own harness and for Tencent's CodeBuddy and WorkBuddy.

The vLLM recipe confirms the scope from the serving side: 1017 has the same architecture, config.json, tokenizer and prompt encoding as the September checkpoint. Only the weights changed. Anything you built against the September model, whether through the API or self-hosted, carries over.

Three things are actually different:

• Higher scores. DeepSeek reports gains on every benchmark it published for both checkpoints. The biggest are on hard agent tasks (details in the next section).
• Shorter outputs. DeepSeek's model card says 1017 "reduces task execution time and output length" without giving a figure. Artificial Analysis gives one: the 1017 (Max) checkpoint used 210M output tokens to run its Intelligence Index, against 250M for the September checkpoint. That is 16% fewer tokens ((250 − 210) / 250 = 0.16). With unchanged per-token prices, fewer tokens means a lower bill per task.
• New default routing. deepseek-flash always points to the latest V4.1 Flash. The retired deepseek-v4-flash and deepseek-v4-flash-vision-exp names are, according to the pricing page, "served by the DeepSeek-V4.1-Flash-1017 model and billed at the Flash price."

deepseek-flash vs the legacy aliases

All three Flash names reach the same weights today, but DeepSeek describes them differently. deepseek-flash is the forward-looking name that tracks the newest V4.1 Flash. The two legacy names are described in the September change log as "temporarily routed" to V4.1 Flash, so they could be switched off later. There is no API ID that pins the September weights, so if you need to reproduce September results, self-host the original deepseek-ai/DeepSeek-V4.1-Flash checkpoint. The practical rule is to use deepseek-flash in new code, replace the legacy names now, and re-run your evals whenever the change log announces a new Flash version.

DeepSeek V4.1 Flash 1017 benchmarks: 1017 vs September vs frontier

All numbers in this table are vendor-reported, taken from the 1017 model card. The comparison columns are DeepSeek's measurements of the other models, not those vendors' own published figures. Per the card, Terminal-Bench 4.0 was run in the Claude Code harness and DeepSWE v1.1 in the Mini-SWE-V2 harness.

On the text-only HLE subset, the card reports 44.0 for 1017 and 39.1 for September. The September NL2Repo figure here (65.4) matches DeepSeek's change log. The original September model card had listed 64.0.

What the table says, if you take DeepSeek's numbers at face value:

• vs September: the largest jumps are on Terminal-Bench 4.0 (+11.1) and ProgramBench (+8.8). Those are the long, multi-step agent tasks where the September model lagged the frontier most.
• vs GPT-5.6 Sol: 1017 leads on nine of eleven rows, including Terminal-Bench 4.0 (42.3 vs 39.9). It trails on HLE without tools (42.6 vs 44.5) and ZeroBench (51.0 vs 53.0).
• vs Opus 5: 1017 leads on DeepSWE, Automation-Bench, Agents' Last Exam and Apex Bench. Opus 5 stays well ahead on HLE (56.3 vs 42.6), Terminal-Bench 4.0 (51.8 vs 42.3), ProgramBench (37.0 vs 29.1) and NL2Repo (75.3 vs 68.2).
• vs Kimi K3: 1017 now roughly matches K3 on HLE (42.6 vs 43.5) and leads everywhere else in DeepSeek's table.

The 1017 card drops several benchmarks the September card reported, including GPQA Diamond, Terminal-Bench 2.1 and 3.0, and the V4-Pro column. You cannot compare 1017 directly with V4-Pro using DeepSeek's latest table.

What do independent leaderboards say?

Third-party results confirm that 1017 is better than the September checkpoint. They also show, again, that DeepSeek's own harness numbers run high.

• Artificial Analysis Intelligence Index v4.3.2: 1017 (Max) scores 45, up from 39 for the September checkpoint on the same index version. AA ranks it #2 of 121 models in its comparison set. Kimi K3 scores 44 on the same index version (unchanged from our September check).
• Cost and verbosity (AA): $0.26 per Index task for 1017, against $0.32 on AA's now-deprecated September page at our latest 26 October check. AA's September cost figure has changed between our captures, so treat the size of the drop as approximate; the direction is clear. 1017 used 210M output tokens for the full Index against a 140M median for comparable open-weight models. It is less verbose than before but still above the median.
• Speed (AA): about 167–169 output tokens per second with roughly 1.2s time to first token on DeepSeek's API (169.3 tok/s and 1.19s at our latest 26 October check; AA's figure moved by about 2 tok/s during the day). AA's September page currently reads 178.1 tok/s and 0.99s, measured as a median across providers. AA's speed figures drift week to week, so treat the two as roughly comparable rather than as a regression.
• Vals AI: on Vals' 1017 entry, Terminal-Bench 4.0 is 31.82% (±2.62) in Vals' neutral harness, about 10.5 points below DeepSeek's 42.3 in Claude Code. The Vals Index is 61.26% (rank 9 of 27) at $0.657 per test. The September entry scored 57.86% at $0.30 per test, but it was ranked against a different, larger model pool (rank 15 of 56), so don't read the two cost figures as a like-for-like change.

That Terminal-Bench gap fits a pattern. On the September release, DeepSeek reported 90.6 on Terminal-Bench 2.1, and Vals measured 74.53% across three full trials. In both cases we checked, DeepSeek's own-harness numbers ran 10–16 points above Vals' neutral runs. Use DeepSeek's numbers to measure the improvement from September to 1017, and use independent runs or your own evals to compare it with other vendors' models.

What is DeepSeek V4.1 Flash? Architecture and specs

V4.1-Flash was trained from scratch on a new architecture, according to its model card ("trained from scratch on a multimodal corpus comprising 45T tokens"). It is not a fine-tune of V4-Flash. The September model card describes a Causal Encoder-Decoder (CED) design: a 40-layer Transformer split into a 20-layer causal encoder and a 20-layer decoder. The decoder builds its global KV cache from the encoder's final hidden states, so the model activates only 8B parameters per token while reading input (prefill) and 16B while generating (decode). Agent workloads are mostly input (tool outputs, file contents, repeated context), so a cheap prefill cuts the cost of the tokens those workloads use most.

FP4 main-KV caching and Compressed Sparse Attention 2 shrink the global KV cache to 890 bytes per token, about a quarter of V4-Flash's. This is what made DeepSeek's very low cache-hit price possible. The model reads images natively, so the separate V4-Flash-Vision-Exp model was retired. All of this applies unchanged to 1017.

The parameter counts are easy to misread. DeepSeek's headline 552B is the backbone. Hugging Face's safetensors metadata for the 1017 repo lists about 763B, more than the 552B backbone plus the 196B Engram parameters (552B + 196B = 748B). DeepSeek does not itemise the remaining ~15B, but the Engram tables ship in the same checkpoint. The Engram tables are why local memory requirements are much larger than "Flash" suggests. For a deeper look at the earlier Flash generation, see our DeepSeek V4 Flash deep dive.

How much does DeepSeek V4.1 Flash cost?

As of October 2026, 1017 costs the same as the September checkpoint. Off-peak is exactly half of peak. Rates below are from the official pricing page.

Peak hours are 01:00–04:00 and 06:00–10:00 UTC, Monday to Friday, excluding Chinese public holidays. That is 35 of the week's 168 hours, so about 79% of the week bills at the off-peak rate. Our DeepSeek peak and off-peak timezone guide converts those windows into local time zones.

V4-Pro costs 4.4x more than Flash on uncached input ($1.32 / $0.30), 3.3x more on output ($3.96 / $1.20) and 7.3x more on cache hits ($0.044 / $0.006).

Worked example: what one agent task costs

Take a coding-agent task that sends 2M input tokens across its steps, 90% of them cache hits from a stable prefix, produces 50K output tokens, and makes 20 Search and 10 Fetch calls.

Two things follow. Cache hits are nearly free: 90% of the input costs less than a cent. And tool calls are not time-of-day discounted, so in a search-heavy loop off-peak they can be a quarter of the bill ($0.0225 of $0.0879, about 26%). The same task on V4-Pro at peak would cost 1.8M × $0.044/1M + 0.2M × $1.32/1M + 0.05M × $3.96/1M = $0.0792 + $0.264 + $0.198 = $0.5412 before tool calls, about 4.1x the Flash model subtotal. For a wider comparison, see our DeepSeek V4-Pro vs Flash breakdown.

How do you call DeepSeek V4.1 Flash from the API?

Set the model to deepseek-flash. The base URL is https://api.deepseek.com for the OpenAI format, or https://api.deepseek.com/anthropic for Anthropic-compatible tooling. Thinking mode is on by default. JSON output, tool calls, the Responses API and the Anthropic format are supported, and FIM completion works in non-thinking mode only.

from openai import OpenAI

client = OpenAI(api_key="<DeepSeek API Key>", base_url="https://api.deepseek.com")

response = client.chat.completions.create(
    model="deepseek-flash",
    messages=[{"role": "user", "content": "Refactor this function to be iterative."}],
    reasoning_effort="max",
    extra_body={"thinking": {"type": "enabled"}},
)

print(response.choices[0].message.reasoning_content)  # chain of thought
print(response.choices[0].message.content)            # final answer

A few thinking-mode behaviours catch people out. temperature, presence_penalty and frequency_penalty are ignored while thinking is on. If your conversation uses tools, pass back the reasoning_content of every previous turn in all later requests, including turns without a tool call. If you leave it out, the API returns a 400 error. Without tools, you don't need to send it back, and the API ignores it if you do. Because 1017 writes shorter outputs, re-check any max_tokens budgets or timeouts you tuned on the September model. Our DeepSeek V4 API developer guide covers client setup in full. Everything in it carries over once you change the model string.

DeepSeek Search and Fetch API

Alongside 1017, DeepSeek opened its in-house search engine as two standalone endpoints. They are standalone APIs billed per request, not tied to a model, so you can call them from your own agent code. DeepSeek Harness, Claude Code and Codex also hit them as server-side tools. Everything below is from the Search & Fetch guide.

Endpoints and parameters

Each search result includes title, url, snippet (short, for UI display), summary (longer, intended for models), content (empty unless need_content is true), site_name, site_icon and date (UTC RFC 3339 or null). It also has two quality signals:

• rerank_score from 0 to 3. DeepSeek treats 1.5 or higher as high quality.
• authority from 0 to 4, with −1 meaning unknown. 3 or higher indicates a highly authoritative source.

Filtering on these two fields before you put results into a prompt is the cheapest quality improvement available. Low-scoring results cost the same tokens and add noise.

Billing, limits and errors

• Only successes bill. A Search request is billed only when it returns HTTP 200 with a non-empty results array. A Fetch request is billed only when it returns page content. Failed requests, empty results and timeouts are free, and count does not change the price.
• Limits are per account, not per key, and separate from model concurrency limits. Going over returns HTTP 429.
• Retry rules: retry 408, 429 and 5xx after a wait. Top up on 402. Fetch returns 403 when a URL is blocked by security policy and 404 when it cannot get usable content. Don't retry those without changing the request.
• Dated note on the free window: server-side tool calls made through DeepSeek Harness, Claude Code or Codex are free until billing starts at 16:00 UTC on 31 October 2026 (00:00 Beijing time on 1 November). The docs describe the exemption only for those three clients.

curl and Python examples

curl https://api.deepseek.com/v1/tools/search \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "vLLM DeepSeek V4.1 Flash recipe", "count": 5}'

curl https://api.deepseek.com/v1/tools/fetch \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://api-docs.deepseek.com/guides/search/"}'

A minimal Python helper that keeps only high-quality results:

import os
import requests

def deepseek_search(query: str, count: int = 10) -> list[dict]:
    resp = requests.post(
        "https://api.deepseek.com/v1/tools/search",
        headers={"Authorization": f"Bearer {os.environ['DEEPSEEK_API_KEY']}"},
        json={"query": query, "count": count},
        timeout=30,
    )
    resp.raise_for_status()
    results = resp.json()["results"]
    # DeepSeek treats rerank_score >= 1.5 as high quality
    return [r for r in results if r["rerank_score"] >= 1.5]

for r in deepseek_search("DeepSeek V4.1 Flash 1017 release notes"):
    print(r["rerank_score"], r["authority"], r["url"])

Is DeepSeek V4-Pro deprecated?

No. As of 26 October 2026, deepseek-v4-pro still serves DeepSeek-V4-Pro-0813 at $1.32 input and $3.96 output per million tokens at peak. Here is what happened:

1. 10 September. The V4.1-Flash launch announcement said all deepseek-v4-pro requests would route to V4.1-Flash from 14 September "until V4.1-Pro launches."
2. Before 14 September. DeepSeek reversed that. The change log says it will "continue providing API services for DeepSeek V4 Pro after September 14, 2026, with the billing method remaining unchanged," with further notice if anything changes.
3. 17 October. The 1017 release left V4-Pro alone. The pricing page still lists it as a separate model at its own rates, with no vision. DeepSeek has not announced a date for V4.1-Pro.

That leaves V4-Pro users paying about 4x more for a model that DeepSeek's September benchmarks already ranked below V4.1-Flash on most agent tasks. Pro's remaining advantage on DeepSeek's September base-model table was factual recall and long context (SimpleQA-Verified 55.2 vs 42.3, LongBench-V2 51.5 vs 45.2). DeepSeek has not published equivalent 1017 numbers. Our V4-Pro 0813 guide covers that checkpoint in detail.

Should you migrate from V4-Pro to V4.1-Flash?

For coding agents, tool use and input-heavy workloads, yes, after testing. A practical sequence:

• Record a Pro baseline on your own eval set while deepseek-v4-pro still serves the real model. "Until further notice" is not a commitment.
• Run the same set on deepseek-flash at reasoning_effort="max" and again at high, and compare cost per task, not cost per token.
• Check knowledge-heavy Q&A specifically, where Pro led in September.
• Pin deepseek-flash, not a legacy alias, and subscribe to the change log. The October checkpoint swap shows that the same model name can serve new weights overnight.

Reliability and compliance notes

The 15 October outage and credits

On 15 October 2026, DeepSeek's API and chat services went down for close to five hours. According to ToolNavs' timeline, the outage ran from 08:11 to 13:04 Beijing time (00:11–05:04 UTC), about 4 hours 53 minutes. CGTN confirms the 13:04 restoration and the affected components: the V4 Pro API, the V4.1 Flash API and the chat service. In a "Service Restoration and Compensation Notice", DeepSeek said it would refund each account's actual API spend from 8 to 14 October as credit. The credit is applied automatically and used before your topped-up balance. DeepSeek did not disclose a root cause. It said it was reviewing single points of dependency.

When we checked on 26 October, DeepSeek's status page showed 99.47% availability for the V4.1 Flash API over July to October. If DeepSeek sits on a critical path, put a fallback provider or a self-hosted replica behind it. The MIT weights make that possible.

US federal contractors: the DHS FASCSA order

A DHS order under the Federal Acquisition Supply Chain Security Act (FASCSA), issued by the Secretary of Homeland Security, dated 24 July 2026 and published in the Federal Register on 20 October 2026, requires federal civilian executive agencies to remove DeepSeek products and services from their systems, including third-party products "developed using DeepSeek implementations." Contractors covered by FAR 52.204-30 may not provide or use covered products in performing a federal contract without a waiver. They must report covered products to the contracting officer within 3 business days of identifying them. According to The Hacker News, the order does not restrict private companies or the public, and it does not define "DeepSeek implementations". That leaves it unclear whether self-hosted open weights are covered. If you sell to US federal agencies, get a legal read before you ship anything built on DeepSeek, self-hosted or not.

Can you run DeepSeek V4.1 Flash 1017 locally?

Yes, with serious hardware and some unmerged code. "Flash" refers to the active parameter count. Memory requirements depend on the total, which is large.

Unsloth GGUFs and llama.cpp PR #30817

Unsloth publishes 1017 GGUFs that keep the Engram n-gram table on SSD through mmap, so only the rest of the model has to fit in RAM plus VRAM:

Unsloth's rule of thumb is 128–145 GB of RAM plus VRAM (or unified memory) for 1-bit, 256–290 GB for 3-bit and 315 GB for 8-bit, with the Engram table on SSD. Unsloth notes that runtime and context can require more. The Engram rows are read from SSD on demand, so a fast NVMe drive helps.

The catch: upstream llama.cpp does not support these files yet. They need ggml-org/llama.cpp#30817 ("model : add DeepSeek-V4.1-Flash (deepseek41)"), a draft PR opened on 19 October by Unsloth's Daniel Han. It adds compressed sparse attention, the Engram embedding, a dedicated KV cache, vision support and DSML tool-call parsing. Reviewers have asked for parts to be split out before it merges. A related issue (#30944) reports single-token output corruption when a cached prompt prefix is reused with Engram n-gram history. Expect rough edges. Unsloth's documented build:

git clone https://github.com/ggml-org/llama.cpp
git -C llama.cpp fetch origin pull/30817/head:deepseek41
git -C llama.cpp checkout deepseek41
cmake llama.cpp -B llama.cpp/build -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON   # -DGGML_CUDA=OFF for CPU/Metal
cmake --build llama.cpp/build --config Release -j --clean-first \
  --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp

hf download unsloth/DeepSeek-V4.1-Flash-1017-GGUF \
  --local-dir unsloth/DeepSeek-V4.1-Flash-1017-GGUF --include "*UD-Q2_K_XL*"

Unsloth's run example uses --temp 1.0 --top-p 1.0 and passes reasoning effort as an integer through --chat-template-kwargs '{"reasoning_effort":75}'. The integer range is 1–100. Per Unsloth, low = 50, medium = 62, high = 75 (the default) and max = 100. Use {"enable_thinking":false} to turn thinking off.

On throughput: Unsloth's page publishes no tokens-per-second figures. Its "up to 3x faster" claim is its own, with no test setup shown. The only M3 Ultra throughput figures we found come from one community report, which we could not reproduce, so we don't quote them here.

Apple Silicon via DwarfStar. The other Mac route is antirez's DwarfStar (ds4, ds4.1flash branch). Its GGUF repo README documents a Q2 build (340.6 GiB file, 151.8 GiB of it main weights) that runs "on a single 128 GB Mac" with SSD streaming, and a Q4 build (483.0 GiB) whose fully resident target is a 512 GB Mac. Those builds are of the September checkpoint. The repo added files named for 1017 on 19 October, but the README does not yet document a 1017 build, so treat 1017 on DwarfStar as unconfirmed. DwarfStar files only work with DwarfStar, not with llama.cpp.

vLLM

The vLLM recipe now defaults to the 1017 checkpoint and requires vLLM 0.31.0 or later. The architecture first shipped in 0.30.0, and 0.31.0 adds KV-offload and ROCm fixes. The launch-day deepseekv41-flash-0909 image is no longer needed. Only the model ID changes between checkpoints.

Footprint: the official FP8 + MXFP4 checkpoint is about 476 GiB (about 511 GB) on disk, and the recipe lists a 614 GB VRAM minimum (checkpoint size plus a 1.2x headroom factor). Its verified and measured configurations include GB200 NVL4 at TP4, H200 at TP4 with Engram CPU offload, and MI355X, all run on the September checkpoint. The same config.json applies to 1017.

The recipe does not publish one complete command. The one below is illustrative, assembled from flags the recipe documents. --kv-cache-dtype fp8 and --reasoning-parser deepseek_v41 appear in its Blackwell (B200, B300, GB200, GB300) configurations, and --language-model-only is its text-only option. Generate the exact command for your hardware with the recipe's builder.

vllm serve deepseek-ai/DeepSeek-V4.1-Flash-1017 \
  --tensor-parallel-size 4 \
  --language-model-only \
  --tokenizer-mode deepseek_v41 \
  --reasoning-parser deepseek_v41 \
  --kv-cache-dtype fp8 \
  --max-model-len 1048576

On H200 the recipe uses TP4 with --engram-config '{"cpu_offload":true}'. DSpark speculative decoding goes through --speculative-config with five speculative tokens. The recipe says its "verified" badges and measured numbers come from the September (0909) launch checkpoint and that the 1017 weights "have not been separately re-run."

SGLang

NVIDIA's NVFP4 checkpoint card documents SGLang on the lmsysorg/sglang:dev-cu13-dsv41 image across four GB300s, with --reasoning-parser deepseek-v41 and --tool-call-parser deepseekv41. That NVFP4 build is of the September weights, and its 14 October revision moved the Engram tables to MXFP4, which SGLang does not support yet. The card says to pin --revision 3431dde3247c13b5957f682b1e3c6fcae2566079 for the FP8-Engram version. We did not find a documented NVFP4 build of 1017.

Ollama

The Ollama library lists only cloud tags, deepseek-v4.1-flash:cloud and deepseek-v4.1-flash:1017-cloud. Both send your prompts to Ollama's servers. Neither runs on your machine.

If you want a local DeepSeek that runs on standard tools and modest hardware, V4-Flash is still the practical choice. See our V4-Flash local setup guide and the DeepSeek V4 VRAM and GPU requirements guide.

How does V4.1-Flash 1017 compare with V4-Pro, Qwen 3.8 and Kimi K3?

All figures below are from each model's Artificial Analysis page at our 26 October 2026 check, on Intelligence Index v4.3.2. Prices are the list prices AA shows (DeepSeek's at peak), as of October 2026.

vs V4-Pro 0813: 1017 scores 9 points higher on AA's index, costs about 2.6x less per Index task ($0.67 / $0.26) and streams about 1.7x faster. Pro's remaining edge in DeepSeek's September tables was factual recall and long-context reading. Unless your workload is mainly knowledge-heavy Q&A, Flash is the better default.

vs Qwen 3.8: Qwen3.8 Max (0902) ties 1017 at 45 on AA's index but costs about 21x more per Index task ($5.41 / $0.26) and runs at about a quarter of the speed. Qwen3.8-Flash-Next is the real price competitor: cheaper per token than DeepSeek's peak rates ($0.15 / $0.47 vs $0.30 / $1.20; at DeepSeek's off-peak rates input ties and Qwen is still cheaper on output), and close on cost per task ($0.37 vs $0.26), but 5 points lower on the index. DeepSeek publishes no head-to-head numbers against it, so test both on your own tasks. Our Qwen 3.8 lineup guide explains which Qwen variant to use.

vs Kimi K3: on DeepSeek's own table, 1017 roughly ties K3 on HLE without tools (42.6 vs 43.5) and leads it on every agent and coding benchmark, most sharply on Terminal-Bench 4.0 (42.3 vs 12.6). On AA's index, 1017's 45 is level with or slightly ahead of K3's 44 (unchanged at our 26 October check). Cost is where the gap is largest: on the same AA basis, K3 costs $2.00 per Index task against $0.26 for 1017, about 7.7x more. Note that Moonshot has since released Kimi K3.1 Pro (AA lists it from 23 October and marks K3 as deprecated), while DeepSeek's 1017 table still compares against K3. Our Kimi K3 complete guide has the full K3 picture.

For the wider cost picture against closed frontier models, see our DeepSeek V4 Flash vs Claude Opus 5 cost breakdown. V4.1-Flash is cheaper again than the V4-Flash prices in that analysis.

Who should use DeepSeek V4.1 Flash 1017?

• Teams running high-volume agent loops: the cheap cache hits, fast prefill and now shorter outputs all lower cost per task.
• Agent builders who need web grounding: Search and Fetch put retrieval on the same bill and account, with quality scores you can filter on.
• Anyone on deepseek-v4-flash: you are already on 1017 through the alias. Switch the string to deepseek-flash and re-baseline.
• V4-Pro users: run the comparison now, while you control when you switch.
• Federal contractors: check the FASCSA order before adopting it.
• Hobbyist self-hosters: the Unsloth 1-bit build brings the floor down to about 122 GB of RAM plus VRAM, but on draft llama.cpp code. Wait for the PR to merge unless you are comfortable debugging.

FAQ

What is DeepSeek V4.1 Flash 1017?

It is a weight update to DeepSeek-V4.1-Flash, released on 17 October 2026 under the MIT licence. It has the same architecture, tokenizer and API name (deepseek-flash) as the September release, with higher benchmark scores and shorter outputs.

Did DeepSeek V4.1 Flash pricing change with 1017?

No. As of October 2026 it is still $0.006 cached input, $0.30 uncached input and $1.20 output per million tokens at peak, and half that off-peak ($0.003, $0.15, $0.60). Because outputs are shorter, cost per task is lower: AA measures $0.26 per Index task for 1017, against $0.32 for the September checkpoint at our latest 26 October check.

How much does the DeepSeek Search API cost?

$0.75 per 1,000 successful requests for Search and $0.75 per 1,000 for Fetch, as of October 2026. Failed, empty and timed-out requests aren't billed. Limits are 100 QPS for Search and 25 QPS for Fetch per account.

Is DeepSeek V4-Pro still available?

Yes. The planned 14 September retirement was reversed, and deepseek-v4-pro still serves V4-Pro-0813 at $1.32 input and $3.96 output per million tokens at peak. DeepSeek has not given a date for V4.1-Pro.

Can I run DeepSeek V4.1 Flash 1017 with llama.cpp or Ollama?

With llama.cpp, only by building the unmerged draft PR #30817 and using Unsloth's 1017 GGUFs, which start at 233 GB (about 122 GB RAM plus VRAM, with the Engram table on SSD). Ollama offers cloud tags only. vLLM 0.31.0 or later serves 1017 on multi-GPU servers.

Are DeepSeek's benchmark numbers reliable?

They are useful for tracking the change from September to 1017, but they run high compared with neutral harnesses. DeepSeek reports 42.3 on Terminal-Bench 4.0 in Claude Code, and Vals AI measured 31.82%. Use independent results or your own evals when comparing vendors.

Sources

• DeepSeek: DeepSeek-V4.1-Flash-1017 release (17 Oct 2026)
• DeepSeek API change log
• DeepSeek API: Search & Fetch guide
• DeepSeek API: Models & Pricing
• DeepSeek: DeepSeek-V4.1-Flash release (10 Sept 2026)
• DeepSeek API: Thinking Mode
• Hugging Face: deepseek-ai/DeepSeek-V4.1-Flash-1017 model card
• Hugging Face: deepseek-ai/DeepSeek-V4.1-Flash (September) model card
• Artificial Analysis: DeepSeek V4.1 Flash 1017
• Artificial Analysis: DeepSeek V4.1 Flash (September, deprecated)
• Artificial Analysis: DeepSeek V4 Pro 0813
• Artificial Analysis: Qwen3.8 Max (0902)
• Artificial Analysis: Qwen3.8-Flash-Next
• Artificial Analysis: Kimi K3
• Vals AI: DeepSeek V4.1 Flash 1017
• Vals AI: DeepSeek V4.1 Flash (September)
• Unsloth: DeepSeek-V4.1-Flash-1017 GGUF guide
• Hugging Face: antirez/deepseek-v4.1-flash-gguf (DwarfStar)
• llama.cpp PR #30817: add DeepSeek-V4.1-Flash (deepseek41)
• vLLM Recipes: DeepSeek-V4.1-Flash
• NVIDIA: DeepSeek-V4.1-Flash-NVFP4
• Ollama library: deepseek-v4.1-flash
• DeepSeek status page
• CGTN: DeepSeek offers compensation after restoring from service outage
• ToolNavs: DeepSeek outage timeline and refund
• The Hacker News: US orders DeepSeek removed from federal systems

If your team is building agents on DeepSeek or other open-weight models and needs people who have shipped evaluation, serving and migration work before, Codersera can help you hire vetted remote AI developers.