Updated July 31, 2026.
DeepSeek has released the official version DeepSeek V4 Flash 0731: its API is already running in public beta, and the weights have been published under the MIT license. The main practical advantage of the release is the choice of deployment method. The model can be deployed on your own infrastructure without sending requests to an external provider. If you don't have a powerful server of your own, the official API is very cheap: $0.14 per 1 million input tokens without cache and $0.28 per 1 million output tokens.
But the word “local” needs a caveat. This is a large MoE model, not an LLM for an ordinary laptop with 16–32 GB of memory. The official production example uses four NVIDIA GB300 accelerators. Experimental quantization makes it possible to run V4 Flash on machines with roughly 128 GB of shared memory, but at the cost of speed, context length, and possible quality loss.
In short: DeepSeek V4 Flash is an open agentic model with a 1 million token context, a low-cost API, and real self-hosting potential. For a quick pilot, the API is more economical; for a private environment and steady high load, use a local server or GPU cluster.
Contents
- What DeepSeek actually released
- DeepSeek V4 Flash specs
- Why local deployment matters
- How to deploy DeepSeek V4 Flash locally
- What hardware you'll need
- How much the DeepSeek V4 Flash API costs
- Local or API
- What changed in quality
- FAQ
- Bottom line
What DeepSeek actually released
On July 31, DeepSeek updated the release log and announced the official DeepSeek‑V4‑Flash API in public beta. The request still uses the old name deepseek-v4-flash, but it now points to version DeepSeek‑V4‑Flash‑0731.
This is not a new architecture compared with the April preview version. According to the developer, the model size and structure stayed the same, and the main gains came during additional training. The update applies to the Flash API and the new weights; V4 Pro and the models in the app and web interface did not change.
At the same time, DeepSeek published the V4 Flash 0731 weights under the MIT license. That makes the release interesting not only for cloud users: the model may be downloaded, run, and adapted under a permissive license.
DeepSeek V4 Flash specs
| Specification | DeepSeek V4 Flash 0731 |
|---|---|
| Type | text MoE model for reasoning and agents |
| Context | up to 1 million tokens |
| Maximum response | up to 384,000 tokens |
| Reasoning effort modes | low, high, max |
| API | OpenAI Chat Completions, Responses API, Anthropic-compatible interface |
| Tools | tool calls, JSON output, FIM |
| Weights license | MIT |
| API version | DeepSeek-V4-Flash-0731, public beta |
The original V4 Flash family is listed at 284 billion total and 13 billion active parameters. MoE, or mixture of experts, activates only part of the network for each token. That reduces compute, but it does not remove the need to keep a large volume of weights in memory.
A 1 million token context is useful for analyzing repositories, large sets of documentation, and long agent sessions. In practice, the maximum context sharply increases memory requirements. For a pilot, it's better to start with 32,000–64,000 tokens and raise the limit only after measuring quality and cost.
Why local deployment matters
Open weights change more than just the price. A local DeepSeek V4 Flash deployment can be kept inside the corporate boundary, pinned to a specific model version, and placed behind your own API gateway.
Self-hosting is useful when you need to:
- keep source code, documents, and customer requests out of an external API;
- work in an isolated network;
- control updates and answer reproducibility;
- connect internal logging, filters, and access controls;
- handle sustained high load without paying for every token;
- fine-tune or adapt the model to your own workflows.
That said, a local model does not automatically make the system secure. The server still needs authentication, tool isolation, secret protection, action logs, and confirmation for risky operations. This is especially important for coding agents that are given a terminal, repositories, and access to production.
How to deploy DeepSeek V4 Flash locally
This release has two practical deployment paths.
Official production path: vLLM
In the model card, DeepSeek provides a vLLM configuration with expert parallelism and the DSpark speculative decoding module. The server is launched with the command vllm serve deepseek-ai/DeepSeek-V4-Flash-0731; in the official recipe, it is paired with the parameters --trust-remote-code, FP8 for the KV cache, four data-parallel processes, expert parallelism, and DSpark with seven speculative tokens.
After startup, the application connects to a local OpenAI-compatible endpoint. For a corporate deployment, you should add authentication, TLS, request limits, and metrics collection.
The official example is designed for a single node with 4×NVIDIA GB300. This is a benchmark for fast full inference, not the minimum requirement for any deployment.
Home and lab path: GGUF
For llama.cpp, Ollama, and LM Studio, the community publishes quantized GGUF builds. They compress weights down to two or three bits and let you use CPU, GPU, or Apple Silicon shared memory. For example, an experimental implementation by antirez is designed for Macs with 128 GB of RAM.
Here it’s important to distinguish capability from production readiness. Quantization and support for the new architecture are changing quickly, some builds require a separate llama.cpp fork, and results may differ from the official API. Before deployment, you need to test Russian language support, tool calls, code, long context, and the stability of multi-step tasks on the specific quantized build you choose.
What hardware will you need
| Scenario | Realistic configuration | Trade-off |
|---|---|---|
| Official fast inference | GPU server, in the example from DeepSeek — 4×GB300 | high hardware cost |
| Local server with a quantized model | about 128 GB or more of total RAM/VRAM | lower speed and possible quality loss |
| Typical PC with 16–64 GB | full V4 Flash is practically not suitable | better to use a smaller model or the API |
| Pilot without infrastructure | official DeepSeek API | data is processed by an external service |
Active 13 billion parameters do not mean the model needs as much memory as a regular 13B LLM. Only a small part of the experts is activated, but many more weights still need to be stored. So the honest meaning of “can run locally” is your own powerful server, a workstation with 128+ GB of shared memory, or a cluster, not just any laptop.
How much does the DeepSeek V4 Flash API cost
According to DeepSeek’s official pricing table as of July 31, 2026, the rates are listed per 1 million tokens:
| Operation | Price |
|---|---|
| Input, cache hit | $0.0028 |
| Input, cache miss | $0.14 |
| Output | $0.28 |
That is truly very cheap. A request with 100,000 new input tokens and a 10,000-token response would cost about $0.0168: $0.014 for input and $0.0028 for output. With a full input cache hit, the same calculation would drop to about $0.00308.
This calculation shows token price, not the full cost of a business task. Repeated runs, long reasoning content, data storage, and human review also have a cost. To control spending, it helps to cap response length, reuse the same prefix for caching, and separate simple and complex tasks by reasoning_effort.
DeepSeek has announced a future peak/off-peak pricing mode. During peak hours — 09:00–12:00 and 14:00–18:00 Beijing time — all line items will cost twice as much. At the time of publication, the activation date for this rule had not yet been announced, so the price should be checked again before a large-scale rollout.
For more on choosing a provider and hidden costs, read our comparison of cheap LLM APIs.
Local deployment or API
| Criterion | Local deployment | Official API |
|---|---|---|
| Getting started | you need weights, hardware, and setup | you need an API key and a few lines of code |
| Privacy | data stays within your own environment | data goes to the provider |
| Pilot cost | high | very low |
| Cost of a large stable workload | may be more cost-effective after TCO analysis | grows with token usage |
| Updates | controlled by your team | controlled by DeepSeek |
| Scaling | your team’s responsibility | handled by the provider |
A practical strategy is to start with the API, collect 100–500 real tasks, and measure quality, token volume, and latency. After that, you can calculate the TCO of your own server: GPU rental or depreciation, electricity, engineering work, redundancy, and monitoring. Local deployment is justified not by the slogan “no token fees,” but by privacy, control, or proven savings at a stable volume.
What changed in quality
DeepSeek says agent capabilities improved significantly after additional training. In the developer’s published results, V4 Flash 0731 scored 82.7 on Terminal Bench 2.1 versus 61.8 for the preview version and 72.1 for V4 Pro Preview. On Toolathlon-Verified, the score rose from 49.7 to 70.3.
These are the provider’s own data. For some coding tasks, maximum reasoning effort and the not-yet-published DeepSeek Harness were used, and two DSBench sets are internal. So the numbers show the direction of improvement, but they do not prove an advantage on your repositories.
Before migrating, test the model on a fixed task set:
- fixing a bug in a real repository;
- calling multiple tools with the correct arguments;
- working with Russian-language documents;
- recovering after a tool error;
- compliance with rights limits and JSON format;
- the cost of a successfully completed task, including retries.
FAQ
Can DeepSeek V4 Flash be run locally?
Yes. The official DeepSeek V4 Flash 0731 weights are published under MIT, and DeepSeek provides instructions for vLLM. But the full version requires a powerful GPU server; experimental quantizations typically assume roughly 128 GB of total memory and may lag behind the API in speed or quality.
How much memory does DeepSeek V4 Flash need?
The official production example uses four GB300s. For an experimental home setup, 2-bit GGUF is often associated with around 128 GB of RAM or unified memory. The exact amount depends on the quantization, context length, and how memory is split between RAM and VRAM.
How much does the DeepSeek V4 Flash API cost?
As of July 31, 2026, it's $0.14 per 1 million new input tokens, $0.0028 per 1 million cached input tokens, and $0.28 per 1 million output tokens. DeepSeek plans a dual-rate peak pricing model, but has not yet announced when it will take effect.
Is DeepSeek V4 Flash open source?
More precisely, it should be called an open-weight model. The repository and V4 Flash 0731 weights are available under MIT, but open weights do not mean the full training dataset and all production infrastructure are published.
Is DeepSeek V4 Flash suitable for coding agents?
The model was specifically improved for agentic workflows, and it supports tool calls and the Responses API. DeepSeek's results on coding benchmarks have improved, but before production use you should test it on your own repositories, permissions, and tools.
Bottom line
DeepSeek V4 Flash 0731 is notable for a rare combination: open weights for local deployment and API pricing at fractions of a dollar per million tokens. This makes it possible to launch a pilot without buying GPUs first, and then move the model into your own environment if privacy, version control, or workload size justify the infrastructure.
The smartest next step is to take 100 real tasks and test them through the API. If the quality is good enough, calculate the monthly token budget and compare it with the total cost of a local server. At the current API price, self-hosting is more often chosen for data control than for immediate cost savings.