DeepSeek Models: V4 Pro, V4.1 Flash, Prices and Licence

DeepSeek's current models are V4 Pro (0813) and V4.1 Flash (1017), both released as open weights under the MIT licence. Both give a 1M-token context and up to 384K output on the API. Off-peak prices are $0.15 and $0.60 per million tokens for Flash and $0.66 and $1.98 for Pro, doubled during weekday peak hours. Checked 31 October 2026.

The lineup

Facts come from the two Hugging Face cards, their config files and DeepSeek's API documentation, read on 31 October 2026.

Both repositories store the main weights in FP8 with the expert weights in FP4, which is why a 1.65T-parameter model comes to well under 2 TB. The Hugging Face API lists the sizes shown above, which are the download you would plan storage for.

What changed from earlier V4

The Pro card says 0813 is the official release of V4-Pro and supersedes the preview, with much better agentic ability, "especially pronounced in production environments". It keeps the preview's structure and attaches a DSpark speculative decoding module. The Flash card calls 1017 a minor update to V4.1-Flash that improves reasoning, coding, agent tasks and vision while shortening output, which DeepSeek says lets users finish tasks faster and cheaper. The API also retired its older flash names: deepseek-v4-flash and deepseek-v4-flash-vision-exp still work but requests are served by the 1017 model at the Flash price.

Names carry dates. Pin them. DeepSeek moves a model in place and the same API name can point at a new version within weeks, as it did for flash.

API prices

From DeepSeek's pricing page, per million tokens in US dollars. The page says off-peak rates are half of peak.

Peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC on weekdays, excluding Chinese public holidays. Weekends and Chinese public holidays are off-peak in full. If you run batch agent jobs from Europe or the Americas, scheduling them outside those two windows halves the bill.

The page also lists a Search API and a Fetch API at $0.75 per 1,000 successful requests each. When you reach them through DeepSeek Harness, Claude Code or Codex, the server-side calls are free for now, and billing starts at 00:00 Beijing time on 1 November 2026. That date is tomorrow relative to this check, so assume search and fetch will cost money from then.

A worked example

Take an agent run that reads 3 million input tokens (cache misses) and writes 300,000 output tokens. Off-peak that costs $0.45 plus $0.18 on Flash ($0.63) and $1.98 plus $0.59 on Pro ($2.57). At peak, each doubles. The same run on Claude Sonnet 5.5 at $2 and $10 would be $6 plus $3 ($9). Cache hits cut the input side sharply: Flash charges $0.003 per million on a hit. A coding agent re-sends a growing prompt prefix every turn, so hit rates tend to be high, but we have no measured hit rate for any agent to quote.

This arithmetic compares list prices only. It says nothing about how often each model finishes the task. Our DeepSeek vs Claude page takes that question further, and LLM API prices lists the other vendors.

API features and compatibility

DeepSeek's API supports two request formats, which is why existing tools work.

• OpenAI format at https://api.deepseek.com.
• Anthropic format at https://api.deepseek.com/anthropic.

Both models support JSON output, tool calls, the Responses API, the Anthropic API format and chat prefix completion (beta). Fill-in-the-middle completion is in beta and works in non-thinking mode only. The Pro model does not support vision on the API, while Flash does.

Thinking can be switched per request, and the docs link a thinking-mode guide for how. Reasoning effort has three settings: low, high and max. For high and max, DeepSeek recommends allowing up to 384K output tokens, and recommends temperature 1.0 with topp 0.95 for agent use and 1.0 otherwise. The Flash card recommends maxtokens of at least 256K.

Published scores

All below are vendor-reported on DeepSeek's cards. They are not independent results.

V4-Pro-0813

Notes from the card: code-agent tasks ran with the minimal mode of DeepSeek Harness at max effort, with temperature 1.0 and top_p 0.95. The card also lists two internal test sets, DSBench-FullStack and DSBench-Hard, which nobody outside DeepSeek can run.

V4.1-Flash-1017

Terminal-Bench 4.0 ran in the Claude Code harness and DeepSWE v1.1 in Mini-SWE-V2. Read the table honestly: DeepSeek reports its small model ahead of the others on four of five rows, behind Opus 5 on three of them. We have not reproduced it. The jump between Pro Preview and Pro 0813 on DeepSWE, from 12.8 to 62.7, shows how much harness and post-training changes can move a score.

Running the weights

DeepSeek's cards document two serving engines.

• vLLM. The Pro card's example runs on a single node of four GB300 GPUs with data parallel size 4, expert parallelism, an FP8 key-value cache and the DSpark speculative decoding flag. A vLLM recipe page lists other hardware.
• SGLang. The Pro example uses tensor parallel 4 on GB300 with MXFP4 expert kernels and the same speculative decoding method. A cookbook lists other setups.

Neither example is a small-machine setup. With 893 GB of weight files for Pro and 510 GB for Flash, you are in multi-GPU server territory. The model repositories do not use a standard Jinja chat template. DeepSeek ships an encoding folder with Python scripts that turn OpenAI-style messages into model input, and for production a Rust toolkit called deepseek-recipe that handles Messages, Chat Completions and Responses API requests. If your serving engine does not know this format yet, you will see broken prompts.

For a smaller box, DeepSeek's cards do not give a recipe. Look at Qwen3.8-27B or gpt-oss instead.

Trying it from a Claude Code or OpenAI-style client

Because DeepSeek speaks both formats, the first test takes minutes. For an Anthropic-format tool, point the base URL at the Anthropic path and use your DeepSeek key; for an OpenAI-format tool, use the plain base URL. The model names are deepseek-flash and deepseek-v4-pro.

export ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic"
export ANTHROPIC_AUTH_TOKEN="<your DeepSeek API key>"

Variable names differ between tools, so treat those two lines as a pattern and confirm them in the agent integration page for your tool. Then run one real task, not a hello-world, and watch three things: whether tool calls parse, whether long sessions stay coherent, and what the billing page shows afterwards.

Scheduling around peak pricing

Peak pricing is the most unusual feature of DeepSeek's page, so plan for it. A few practical points follow from the stated rules.

• The windows are fixed in UTC: 01:00 to 04:00 and 06:00 to 10:00, weekdays only. The hour from 04:00 to 06:00 UTC is off-peak even on a weekday.
• For a team in India, 06:00 to 10:00 UTC is roughly late morning to mid afternoon, so ordinary working hours are peak. For a team on US Pacific time, the same window is the middle of the night. Your own time zone decides whether the discount helps interactive work or only batch jobs.
• Weekends are off-peak all day, which suits long unattended agent runs.
• Because the price changes by the clock, a cost estimate based on one run at one hour will mislead you. Log the hour with each run.

The rule on Chinese public holidays being fully off-peak is stated on the page; the list of dates is not, so check it against the official calendar rather than assuming.

Reading the technical reports

DeepSeek links a technical report from each card. The Pro card points to arXiv 2606.19348, titled "DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence". The Flash card's citation is titled "DeepSeek-V4.1-Flash: Pushing the Limits of KV Cache Compression". Both titles tell you what the lab optimised: very long context at low serving cost. That matches the pricing, where a cache hit on Flash costs two percent of a miss. We did not summarise the reports and make no claims about their methods beyond their titles.

How the family has moved

The cards give a compact history of how fast this line moves. The Pro table shows four DeepSeek columns: V4-Pro-0813, V4-Flash-0731, the V4-Pro Preview and the V4-Flash Preview. Within one table you can see preview models scoring far below the release on the same tests, for example Terminal Bench 2.1 at 61.8 for the Flash preview and 82.7 for Flash-0731. Two months later came Flash 1017 and its newer test suite. For a buyer, that cadence means two things: do not pin a purchase decision to a six-month-old benchmark, and keep your evaluation set ready to re-run every time the version string changes.

Where DeepSeek is served

• DeepSeek's own API, as above.
• Mistral's platform lists DeepSeek V4.1 Flash 1017 as a third-party open-weight model with text and image input and a 1M context.
• Inference platforms. Hugging Face Inference, AWS Bedrock and others may carry DeepSeek models, but we did not confirm V4 availability.
• Your own GPUs via Runpod, Modal or Lambda.

DeepSeek's API sends your prompts to DeepSeek. Its retention, training and server location terms were not on the pages we read. If that matters to you, the MIT weights are the way around it.

Which coding agents can use DeepSeek

DeepSeek's documentation has an Agent Integrations section. It lists DeepSeek Harness (a developer preview aimed at people building agent harnesses), Claude Code, Codex, OpenCode, OpenClaw, Hermes, Reasonix, WorkBuddy and CodeBuddy, and Qoder. The first-call page also mentions GitHub Copilot among tools that can use DeepSeek as a backend with no code. See our pages on Claude Code, OpenCode and OpenClaw. Whether every feature of each tool works with a non-native model is a separate question.

Who should pick DeepSeek

Limits and gotchas

• Peak pricing. A weekday morning run in UTC is billed double.
• Concurrency caps. 2,500 for Flash and 500 for Pro. A large parallel agent fleet can hit them.
• Format dependence. Self-hosters must use DeepSeek's encoding scripts or a serving engine that has them built in.
• No hosted vision on Pro. If your agent reads screenshots, use Flash.
• Fast version drift. Names change and models update in place.

Our take

DeepSeek is the strongest argument for open weights on price. The MIT licence is clean, the API list prices are among the lowest we have documented on this site, and the Anthropic-format endpoint means Claude Code users can try it by changing the base URL and key. The caveats are all about data: where prompts go, and how long they stay. For a side-by-side with other open models see best open source LLM for coding, and for the licence picture see open source LLM.

Product names are used descriptively. We are not affiliated with DeepSeek.