DeepSeek V4 Flash Complete Guide: 0731 GA Benchmarks, Pricing, OpenRouter, Local Hardware, Architecture & Comparisons

By AiCybr Editorial · Published August 5, 2026

Important update: DeepSeek released V4 Flash 0731 on July 31, 2026 as the official General Availability (GA) version, superseding the April 24 preview. The deepseek-v4-flash API endpoint now routes to the 0731 build automatically. The 0731 release retains the same 284B/13B architecture but delivers substantially improved agentic performance through re-post-training, including a Terminal-Bench 2.1 score of 82.7, Toolathlon of 70.3, and an Artificial Analysis Intelligence Index score of 50 (up from 40). The model also now natively supports the Responses API and Codex integration.

Navigate This Guide

• DeepSeek V4 Flash at a glance
• Benchmark results
• Comparison with open and proprietary models
• Pricing and whether OpenRouter is cheaper
• Where the model is available
• Local deployment and hardware requirements
• Architecture and one-million-token context
• Best use cases
• Limitations and risks
• Frequently asked questions
• Final verdict

DeepSeek V4 Flash at a Glance

The Practical Summary

DeepSeek V4 Flash is not intended to be the most capable model at any cost. It is designed to deliver a strong portion of frontier coding and reasoning performance with:

• A much smaller active compute footprint than V4 Pro
• Very low API pricing
• Fast hosted generation
• A one-million-token context window
• Permissively licensed downloadable weights
• Serious support for agent and coding workflows

Its strongest argument is capability per dollar, not absolute benchmark leadership.

Benchmark Results

Benchmark comparisons require care. DeepSeek publishes several tables, but not all models are evaluated through the same external agent harness. Results can move when the prompt, reasoning budget, tool interface, time limit, context-management policy or agent software changes.

This guide separates:

• DeepSeek-reported results from its official model card
• Independent Artificial Analysis results
• Current competitor results from each vendor’s own documentation

Scores from different benchmark versions—especially Terminal-Bench 2.0 and 2.1—are not treated as interchangeable.

Performance Across DeepSeek V4 Flash Modes

DeepSeek’s official model card reports the following results under its own evaluation setup:

Source: DeepSeek V4 Flash official model card.

What the Mode Comparison Shows

Max reasoning materially changes the model. Compared with non-thinking mode, Flash Max improves:

• GPQA Diamond by 16.9 points
• HLE by 26.7 points
• LiveCodeBench by 36.4 points
• SWE-bench Verified by 5.3 points
• BrowseComp from no reported non-thinking score to 73.2
• MRCR 1M by 41.2 points

However, Max is not always better. MMLU-Pro is fractionally higher in High mode than Max, which illustrates an important point: more reasoning tokens do not guarantee a better result on every task.

V4 Pro remains stronger overall. Flash Max approaches Pro Max on coding and mathematical benchmarks, but the larger model retains clearer advantages in:

• Knowledge-heavy questions
• Long-context retrieval
• BrowseComp
• Terminal agents
• Complex tool use
• Difficult software engineering

Flash is therefore the value model; Pro is the higher-ceiling model.

Independent Artificial Analysis Results

Artificial Analysis provides a useful independent counterweight to DeepSeek’s own numbers.

As of the August 5 snapshot:

The 0731 GA release increased the Intelligence Index from 40 to 50, placing Flash just one point behind GPT-5.6 Luna (max) and GLM-5.2 (max), both at 51. This is a remarkable position for a model at $0.28/M output.

Artificial Analysis also classifies Flash Max as unusually verbose. Its evaluation consumed roughly 230 million output tokens, compared with a median near 100 million among comparable models in that test set.

How to Interpret the Independent Score

An Intelligence Index of 50 places Flash Max (0731) among the strongest open-weight reasoning models and competitive with several premium proprietary models.

The more important finding is economic:

DeepSeek V4 Flash delivers a substantial level of reasoning and coding capability at a first-party output price of only $0.28 per million tokens.

The low price allows developers to use:

• More parallel attempts
• Multiple reviewing agents
• Larger test sets
• Longer tool loops
• Independent verification passes

That can make a cheaper model operationally competitive even when its single-attempt success rate is below a premium proprietary model.

Speed Needs Context

Artificial Analysis reports output throughput after generation begins. It is not the same as full end-to-end response time.

A reasoning request includes:

1. Queue and scheduling delay
2. Prompt prefill
3. Internal reasoning
4. First visible answer token
5. Answer generation

A model can produce tokens quickly once it starts answering while still taking time to complete internal reasoning. For interactive applications, measure the time to the first visible answer and total task completion time—not output tokens per second alone.

Comparison With Open and Proprietary Models

DeepSeek’s Original Model Card Comparison (April 2026)

DeepSeek’s official model card compares V4 Pro Max with several frontier models that were current at launch time (April 2026). Some of these models (Claude Opus 4.6, GPT-5.4, GLM-5.1, Kimi K2.6) have since been superseded by newer versions — see the August 2026 cross-model comparison below for current rankings. This table is preserved for reference as it provides the only same-harness comparison with Flash.

Main Takeaways (Pre-0731 Comparison)

• Coding: Flash Max is excellent on LiveCodeBench, narrowly behind Gemini 3.1 Pro and V4 Pro while exceeding the listed Claude Opus 4.6 and Kimi K2.6 results.
• Repository repair: Flash is competitive but does not lead SWE-bench Verified or Pro.
• Terminal agents: Its original Terminal-Bench 2.0 score of 56.9 was clearly below competitors. See the 0731 agentic update below for the dramatically improved picture.
• Knowledge and science: Flash trails the larger proprietary models on GPQA and HLE.
• Web research: BrowseComp is one of the clearer gaps between Flash and V4 Pro.
• Tool use: Flash’s original Toolathlon of 47.8 was uncompetitive. The 0731 update pushed this to 70.3—see below.

August 2026 Cross-Model Comparison (Current Frontier)

The following table compiles benchmark scores from official model cards, vendor reports, and independent evaluations for models current as of August 2026. Scores come from different harnesses and evaluation setups, so treat cross-vendor comparisons as approximate. Blank cells indicate no authoritative score is available.

Sources: DeepSeek 0731 release notes, Alibaba Qwen 3.8 Max model card, Z.ai GLM-5.2 launch evaluation, Moonshot Kimi K3 model card, Anthropic Fable 5 and Opus 5 system cards, Google Gemini 3.1 Pro technical report, and Artificial Analysis.

Key Insights From the Updated Landscape

• Terminal-Bench 2.1 leader: GPT-5.6 Sol (~88.8) and Kimi K3 (88.3) lead, with Qwen 3.8 Max (86.6) close behind. Flash 0731 (82.7) and GLM-5.2 (81.0) are competitive — remarkable for open-weight models at a fraction of the cost.
• SWE-bench Verified leader: Claude Opus 5 (96.0) and Kimi K3 (93.4) dominate repository-scale engineering.
• SWE-bench Pro leader: Claude Fable 5 (80.3) leads, with GPT-5.6 Sol (~78.1) close.
• Cost vs. capability: Flash 0731 achieves 82.7 on Terminal-Bench 2.1 at $0.28/M output — roughly 89× cheaper than GPT-5.6 Sol and 178× cheaper than Fable 5. For budget-conscious agent deployments, no other model offers this ratio.
• Toolathlon standout: Flash 0731’s 70.3 is the highest reported score in this table, exceeding even V4 Pro (51.8). This makes it the tool-use champion among models with published Toolathlon results.

0731 GA Agentic Benchmark Results

The July 31 GA release delivered massive improvements on agentic benchmarks through re-post-training alone (no architecture changes). DeepSeek reports the following results using the DeepSeek Harness in minimal mode at max reasoning effort:

Source: DeepSeek V4 Flash 0731 release notes.

The 82.7 Terminal-Bench 2.1 score places Flash 0731 competitively with GLM-5.2 (81.0), above Gemini 3.1 Pro (74.0) and MiniMax M3 (65.0), and below Qwen 3.8 Max (86.6) and GPT-5.6 Sol (~88.8). The Toolathlon jump from 47.8 to 70.3 is particularly striking—it exceeds V4 Pro’s reported 51.8.

These are vendor-reported results from DeepSeek’s own harness. Independent confirmation is still developing, but the Artificial Analysis Intelligence Index increase from 40 to 50 provides partial independent corroboration.

Pricing and Is OpenRouter Cheaper?

Official DeepSeek API Pricing

The cached-input rate is 98% below the normal input price.

The API currently provides:

• A one-million-token context window
• Up to 384K output tokens
• JSON output
• Tool calls
• Thinking and non-thinking modes
• Chat prefix completion
• Fill-in-the-Middle completion in non-thinking mode
• A concurrency limit of 2,500 for V4 Flash

Source: DeepSeek Models and Pricing.

OpenRouter Pricing

OpenRouter lists:

OpenRouter also exposes a free route when capacity is available, but free-route availability, rate limits, provider selection and reliability can change.

Is OpenRouter Cheaper?

For uncached traffic, yes.

For a request containing one million input tokens and 100,000 output tokens:

Which Route Should You Choose?

Use DeepSeek direct when:

• Large prefixes are repeatedly reused
• Exact first-party reasoning behavior matters
• You use DeepSeek’s automatic context caching
• You want the official OpenAI- or Anthropic-compatible interface
• You need DeepSeek’s documented Codex, Claude Code, OpenCode or OpenClaw integration

Use OpenRouter when:

• Most prompts are unique and uncached
• You want lower simple token pricing
• One API key must access many models
• Provider routing and fallbacks are valuable
• You want to compare Flash with alternatives without changing infrastructure

OpenRouter adds another layer between the application and the model. Test reasoning controls, tool calls, structured output, routing policy and long-context limits before relying on it in production.

Frontier API Price Comparison

Prices below are current public list prices on August 5, 2026. They do not include every batch discount, regional multiplier, long-context surcharge, tool charge or subscription plan.

DeepSeek’s price advantage is very large:

• Official Flash output is about 89 times cheaper than GPT-5.6 Sol output.
• It is about 89 times cheaper than Claude Opus 5 output.
• It is about 179 times cheaper than Claude Fable 5 output.
• OpenRouter’s Flash output rate widens those differences further.

This does not mean Flash is equally capable. It means developers can afford more attempts, verification and parallelism before reaching the cost of one premium-model call.

Where Can You Use DeepSeek V4 Flash?

Official DeepSeek API

The first-party API is available through:

• OpenAI-compatible Chat Completions
• An Anthropic-compatible endpoint
• Thinking and non-thinking modes
• Tool calling
• JSON output
• One-million-token context
• Automatic context caching

It is the reference choice for exact model behavior.

DeepSeek Chat and Applications

DeepSeek’s official launch information states that V4 became the standard model across official services with one-million-token context. The API remains the more controllable route for selecting modes and integrating tools.

OpenRouter

OpenRouter provides:

• A paid route at $0.09/M input and $0.18/M output
• A free route when capacity permits
• Provider routing
• Fallbacks
• A single interface for comparing models

Fireworks AI

Fireworks lists deepseek-v4-flash through its model platform. It is appropriate for teams that want:

• Managed serverless access
• Dedicated deployments
• Production capacity planning
• Integration with an existing Fireworks stack

Pricing and deployment options should be checked at purchase time because hosted offerings change.

Hugging Face Inference Providers

The official model card exposes inference-provider access and currently shows providers including Novita. Availability can vary by account and region.

DeepInfra and Other Hosts

DeepInfra lists DeepSeek V4 Flash, and Artificial Analysis tracks several providers for performance. Different hosts may use:

• FP4, FP8 or other quantization
• Different prompt encoders
• Different reasoning-mode mappings
• Different speculative decoding
• Different maximum context lengths
• Different tool-call parsers

The model name alone does not guarantee identical behavior.

Coding and Agent Tools

DeepSeek documents integrations with:

• Codex
• Claude Code through the Anthropic-compatible API
• OpenCode
• OpenClaw

It can also be used through tools that accept an OpenAI-compatible or Anthropic-compatible custom provider, subject to each client’s feature support.

Provider Checklist

Before committing to a host, verify:

1. The exact model revision
2. Supported reasoning modes
3. Maximum context and maximum output
4. Tool calling in thinking mode
5. JSON or schema support
6. Quantization type
7. Context-cache pricing
8. Data retention and training policy
9. Regional processing
10. Real throughput and first-answer latency

Can DeepSeek V4 Flash Run Locally?

Yes—but not like a conventional 13B model.

The model activates about 13B parameters per token, yet all 284B parameters must remain accessible because different experts can be selected for different tokens.

What “13B Active” Actually Means

The active count reduces compute. It does not reduce storage to 13B-model levels.

Official and Community Deployment Paths

The model repository supports or references:

• vLLM
• SGLang
• DeepSeek’s custom inference implementation
• KTransformers / KT-Kernel
• Hugging Face Transformers
• Community quantizations for llama.cpp, Ollama and LM Studio

The easiest local-app listings do not imply that ordinary desktop hardware can run the full model well.

Realistic Local Hardware Requirements

Single RTX 5090 Heterogeneous Deployment

KTransformers documents a validated configuration:

Much of the expert capacity remains in system RAM. The GPU accelerates selected experts and attention-critical work.

This is a powerful workstation or server, not a normal gaming-PC setup.

Full One-Million-Token Local Deployment

KTransformers separately documents:

The full-context setup is a specialist server even though it uses consumer-branded GPUs.

What About RTX 4090 or RTX 3090?

KTransformers lists Ada-class RTX 4090 hardware as supported and reports a working heterogeneous benchmark using a server-class dual-Xeon host. The GPU is only one component; CPU memory bandwidth, NUMA topology and RAM capacity heavily affect performance.

RTX 3090 support should not be assumed from general llama.cpp compatibility alone. A community quantization may load, but that does not establish:

• Correct one-million-token behavior
• Good reasoning quality
• Acceptable throughput
• Full tool-call compatibility
• Equivalent output to the official model

Practical Hardware Table

Should You Self-Host?

Self-hosting makes sense when:

• Data cannot leave the organization
• The model will run continuously at high utilization
• You need a fixed model revision
• You plan to modify or fine-tune the model
• You have large-model infrastructure expertise
• The MIT licence has strategic value

An API is normally better when:

• Usage is intermittent
• The team needs immediate deployment
• One-million-token requests are required
• Hardware administration is not a core competency
• Low latency and high concurrency matter
• The official cached-input price can be exploited

At $0.14/M input and $0.28/M output, buying and operating a large server is difficult to justify purely for cost at modest usage.

Architecture and Why It Is Efficient

DeepSeek V4 Flash combines several ideas aimed at reducing the cost of long-context inference without shrinking total model capacity.

Sparse Mixture of Experts

The model contains 284B parameters but activates roughly 13B per token.

Instead of using one dense feed-forward network in each layer, the model has:

• A shared expert
• Many routed experts
• A router that selects a small subset for each token

Benefits:

• Lower per-token compute than a dense 284B model
• Large total expert capacity
• Better throughput
• Lower API serving cost

Trade-offs:

• All experts must remain available
• Routing and communication add complexity
• Local deployment still needs enormous memory
• Quantization and serving kernels must support the model’s expert format

Hybrid Long-Context Attention

V4 combines:

• Sliding-window attention for precise local detail
• Compressed Sparse Attention for selecting relevant distant information
• Heavily Compressed Attention for a low-cost global view

This avoids applying full quadratic attention to every token across a one-million-token sequence.

The design is particularly useful for:

• Large repositories
• Long agent histories
• Technical-document collections
• Extensive logs
• Multi-stage research

A one-million-token limit still does not guarantee perfect recall. Retrieval quality can vary by position, task and prompt structure.

Manifold-Constrained Hyper-Connections

DeepSeek replaces a single conventional residual stream with multiple constrained information paths.

The goal is to improve:

• Signal propagation
• Training stability
• Model expressiveness
• Information exchange between layers

This is primarily an architectural and training innovation. It is not a feature users enable through the API.

Muon Optimizer

DeepSeek uses the Muon optimizer for many matrix parameters and AdamW for selected components.

The company reports that the V4 models were pretrained on more than 32 trillion tokens and then post-trained through:

1. Domain-specific specialists
2. Supervised fine-tuning
3. Reinforcement learning
4. On-policy distillation into a unified model

Mixed FP4 and FP8 Weights

The released instruct model uses:

• FP4 for MoE expert parameters
• FP8 for most other parameters

This substantially reduces storage and bandwidth compared with BF16, while preserving higher precision where DeepSeek considers it more important.

Multi-Token Prediction

V4 includes a next-token draft mechanism that can support speculative decoding. A draft component proposes several tokens, and the main model verifies them.

Potential advantages:

• Higher decoding throughput
• Better hardware utilization
• Lower serving cost

Actual gains depend on the runtime, prompt and acceptance rate.

Reasoning Modes

Non-Thinking

Best for:

• Classification
• Extraction
• Rewriting
• Short answers
• High-volume simple tasks
• Low-latency applications

It is much weaker on difficult reasoning and coding benchmarks but may offer a better latency-to-quality balance for routine work.

High

High is the strongest default for most serious tasks.

Use it for:

• Code review
• Debugging
• Planning
• Document analysis
• Tool-based research
• Repository work

It often approaches Max while using fewer reasoning tokens.

Max

Use Max for:

• Difficult mathematics
• Complex coding
• Long tool loops
• Research synthesis
• Hard multi-step planning
• High-value tasks where another attempt is acceptable

Max can be extremely verbose. More tokens increase cost, latency and the chance of unproductive exploration. It should not be the default for every request.

One-Million-Token Context: What It Can and Cannot Do

A one-million-token context can contain:

• A large software repository snapshot
• Hundreds of documents
• Extensive logs
• Long policy or legal collections
• A large research corpus
• A prolonged agent trajectory

What It Enables

• Cross-file reasoning
• Fewer aggressive summaries
• Retention of tool history
• Comparing many source documents
• Large-prefix caching
• Long iterative work

What It Does Not Guarantee

• Perfect retrieval from every position
• Equal quality at 10K and 1M
• Unlimited output
• Low latency
• Low prefill cost
• Immunity to distracting or conflicting context

DeepSeek’s own long-context benchmarks show that V4 Pro retains an advantage over Flash, particularly on MRCR and CorpusQA.

Better Long-Context Practice

For production use:

• Keep stable source material at the start to improve cache reuse
• Use descriptive document and file identifiers
• Ask for evidence locations
• Separate source text from instructions
• Retrieve only relevant repository files when possible
• Test at expected lengths, not only at short prompts
• Measure middle-of-context retrieval
• Compact stale agent history

The context window is a capacity ceiling, not a replacement for retrieval design.

Best Use Cases

Coding Agents

Flash is well suited to:

• Repository inspection
• Multi-file edits
• Test generation
• Build-error diagnosis
• Dependency migrations
• Code review
• Documentation updates
• First-pass bug fixing

Its low price makes writer-reviewer and parallel-agent patterns economically practical.

Terminal and Infrastructure Work

Useful for:

• Build troubleshooting
• CI analysis
• Container configuration
• Dependency repair
• Log inspection
• Safe cleanup planning
• Reproducible command sequences

The model should operate in a sandbox with bounded permissions.

Low-Cost Subagents

A premium orchestrator can delegate:

• File discovery
• Log summaries
• Test suggestions
• Requirement extraction
• Documentation
• Independent review
• Failure classification

Flash’s cost is particularly attractive for high-volume supporting roles.

Long-Document Analysis

Suitable for:

• Technical standards
• Product documentation
• Contracts and policies
• Research collections
• Security evidence packages
• Long operational logs

Critical conclusions should include source evidence and external validation.

Structured Extraction

Non-thinking mode can handle:

• Ticket classification
• Entity extraction
• Data normalization
• Compliance tagging
• JSON-like structured output
• Catalog cleanup
• Batch labelling

Schema validation should be performed outside the model.

Tool-Using Research

The model can orchestrate:

• Search
• Retrieval
• Databases
• Calculators
• Code execution
• Internal APIs
• Document stores

It is economical enough for multi-step research, but factual claims should be grounded in retrieved sources.

Fill-in-the-Middle Completion

DeepSeek supports FIM completion for editor-style code insertion in non-thinking mode. The official API documents a 4K completion limit for this beta feature.

Limitations and Risks

Text Only

DeepSeek V4 Flash does not directly understand:

• Images
• Screenshots
• Audio
• Video
• Visual PDF layouts

Text can be extracted by another system, but that is not native multimodal reasoning.

It Is Not the Strongest DeepSeek Model

V4 Pro is consistently stronger on:

• Knowledge
• Long context
• Web research
• Terminal agents
• Complex software tasks
• Tool use

Choose Flash for cost and speed; choose Pro when failure is expensive.

Agent Benchmarks Depend on the Harness

A coding model’s result can move significantly depending on:

• Claude Code, Codex, OpenHands or another harness
• Tool descriptions
• Time limit
• Maximum turns
• Context compaction
• Patch application
• Test execution
• Internet access
• Output limit

A benchmark score is partly a model-and-system score.

Max Mode Is Verbose

Artificial Analysis found that Max generated substantially more tokens than typical peers.

This can cause:

• Slower completion
• Higher total cost than list prices suggest
• Repetition
• Longer human review
• More opportunities for drift

High mode may be a better production default.

Long Context Is Expensive to Serve Locally

Sparse attention reduces compute but does not eliminate KV-cache and prefill demands. Full one-million-token local use remains a server-class workload.

Provider Variability

The same model may behave differently across providers because of:

• Quantization
• Prompt encoding
• Reasoning-mode mapping
• Context truncation
• Speculative decoding
• Tool parsing
• Capacity and queuing

Benchmark each provider separately.

Factual Confidence Needs External Checks

Even strong models may answer uncertain questions instead of abstaining. For medical, legal, financial, security and compliance use:

• Retrieve authoritative sources
• Require citations
• Validate calculations
• Use deterministic checks
• Keep human approval

Tool Access Creates Operational Risk

A model with shell or API access can make damaging changes without malicious intent.

Use:

• Least privilege
• Sandboxes
• Read-only defaults
• Approval gates
• Command allowlists
• Timeouts
• Transactional changes
• Backups
• Bounded retries
• Audit logs

Choosing Between Flash and Alternatives

Flash vs V4 Pro

Choose Flash when:

• Cost is critical
• Workload volume is high
• Tasks are mostly coding, extraction or agent assistance
• Multiple attempts are acceptable
• Lower latency matters

Choose Pro when:

• Difficult knowledge questions dominate
• Repository failures are expensive
• Long-context accuracy matters more
• Research and browsing are central
• The additional API cost is acceptable

Flash vs Premium Closed Models

Flash is rarely the single-attempt quality leader against the strongest proprietary models.

Its economic advantage allows a different strategy:

• Generate two candidate solutions
• Run an independent reviewer
• Execute tests
• Compare evidence
• Escalate only failed cases to a premium model

This hybrid workflow can be more cost-effective than sending every task directly to the most expensive model.

How to Evaluate It Properly

Build a private evaluation set from real work, not public benchmark prompts.

Include:

• Small code edit
• Cross-file bug
• Incomplete issue description
• Failing test
• Dependency migration
• Terminal diagnosis
• Structured extraction
• Tool call
• Long-context retrieval
• Factual question where abstention is correct

Freeze:

• Model revision
• Provider
• Reasoning mode
• Prompt
• Tool schema
• Maximum turns
• Context-management policy
• Timeouts
• Repository commit
• Test command

Measure:

The most useful economic metric is:

Cost per accepted task, not price per million tokens.

Frequently Asked Questions

What is DeepSeek V4 Flash?

It is DeepSeek’s efficiency-focused V4 model: a 284B Mixture-of-Experts model that activates about 13B parameters per token and supports one million tokens of context.

Was DeepSeek V4 Flash 0731 officially released?

Yes. DeepSeek released the 0731 build on July 31, 2026 as the official General Availability (GA) version. The deepseek-v4-flash API endpoint now auto-routes to 0731. It retains the same 284B/13B architecture with substantially improved agentic performance from re-post-training.

Is DeepSeek V4 Flash open source?

The repository and weights are MIT licensed. “Open weights” remains the most precise description because the complete training dataset and infrastructure are not published.

Can it be used commercially?

Yes. The MIT licence permits commercial use, modification and redistribution subject to its notice requirements.

Is it free?

The weights are downloadable without a model licence fee. Hosting requires hardware. API use is paid, although OpenRouter may offer a capacity-limited free route.

How many parameters does it have?

DeepSeek reports 284B total parameters and approximately 13B active per token.

Does 13B active mean it runs like a 13B model?

No. The full expert set must remain accessible. Memory requirements are hundreds of gigabytes.

What is the context window?

One million tokens.

What is the maximum output?

The official API lists a maximum of 384K tokens.

Does it support images?

No. It accepts text and produces text.

Is OpenRouter cheaper than DeepSeek?

For uncached input and output, yes at the August 5 prices. DeepSeek direct is potentially much cheaper for repeated cached prefixes.

What is the official API price?

$0.14/M uncached input, $0.0028/M cached input and $0.28/M output.

Can it run on one RTX 5090?

Yes through a documented CPU-GPU heterogeneous route, but the validated setup requires at least 256GB system RAM, an AVX-512 CPU and about 340GB of storage. Its documented default context is 16K, not one million tokens.

What hardware is required for full one-million-token local use?

KTransformers documents four RTX 5090 GPUs, a dual-socket 64-core AVX-512 CPU, 256GB DDR5, NVMe storage and PCIe 5.0.

Can it run on an RTX 4090?

A heterogeneous deployment is possible on suitable server hardware, but the host CPU and memory are crucial. An RTX 4090 in an ordinary 64GB desktop is not enough.

Can it run in Ollama or LM Studio?

Community quantizations are listed for llama.cpp, Ollama and LM Studio-compatible tools. Quality, context support and performance vary; they should not be assumed equivalent to the official model.

Which reasoning mode should be used?

Use non-thinking for simple high-volume tasks, High for most serious work and Max only for difficult tasks where additional latency and verbosity are acceptable.

Does it support tools?

Yes. The official API supports tool calling. The application—not the model—executes the tools.

Does it support JSON output?

Yes, through the official API. Production systems should still validate the output against a schema and retry boundedly on malformed responses.

Can it be used with Codex or Claude Code?

DeepSeek documents both. Codex uses the OpenAI-compatible integration, while Claude Code can use DeepSeek’s Anthropic-compatible endpoint.

Is it better than DeepSeek V4 Pro?

No overall. Flash is cheaper and faster; Pro is stronger across most difficult official benchmarks.

Is it better than Claude or GPT-5.6?

Not consistently on single-attempt quality. It is dramatically cheaper and can be attractive in workflows that use parallel attempts, tests and reviewers.

What is its best use case?

Cost-sensitive coding agents and high-volume reasoning workloads where outputs can be verified.

Should a startup self-host it?

Usually not initially. Test through the API first. Self-host only when privacy, sustained utilization, model modification or fixed-version control justifies the infrastructure.

Final Verdict

DeepSeek V4 Flash is one of the most economically important open-weight models of 2026.

Its headline numbers—284B total parameters, 13B active and one-million-token context—matter, but they are not the main reason to use it. Its real advantage is the combination of:

• Strong coding and reasoning
• Extremely low API prices
• Fast hosted generation
• Automatic low-cost prefix caching
• MIT-licensed weights
• Broad agent-tool compatibility
• Serious long-context engineering

It does not replace V4 Pro, GPT-5.6 Sol, Gemini 3.1 Pro, Claude Opus 5 or Fable 5 for every difficult task. Those models generally offer a higher capability ceiling, multimodal input or stronger long-horizon reliability.

The 0731 GA release significantly strengthened Flash’s competitive position. With a Terminal-Bench 2.1 score of 82.7 and a Toolathlon of 70.3, Flash now competes directly with models that cost 10–90× more per output token. Its Artificial Analysis Intelligence Index of 50 confirms this is not just vendor hype.

Flash is compelling when the system can turn low token cost into better process:

• Multiple attempts
• Independent review
• Test execution
• Retrieval grounding
• Selective escalation to a stronger model

The best default strategy is:

1. Start with the official API or OpenRouter.
2. Use High reasoning for most serious tasks.
3. Exploit stable-prefix caching when using DeepSeek direct.
4. Verify agent outputs with tests and tools.
5. Measure cost per successful task.
6. Consider self-hosting only after proving the workload and economics.

The 0731 release demonstrates that post-training alone can dramatically shift a model’s competitive position. Developers who evaluated the April preview and dismissed Flash for agentic work should re-evaluate with the current GA build.

References

DeepSeek

• DeepSeek V4 official launch
• DeepSeek API changelog
• DeepSeek V4 Flash model card and benchmarks
• DeepSeek V4 technical report
• DeepSeek API models and pricing
• DeepSeek thinking-mode guide
• DeepSeek context-caching guide
• DeepSeek tool-calling guide

Independent Evaluation

• Artificial Analysis — DeepSeek V4 Flash Max
• Artificial Analysis — DeepSeek V4 Flash High
• Artificial Analysis — DeepSeek V4 Flash Non-reasoning

Providers and Local Deployment

• OpenRouter — DeepSeek V4 Flash
• Fireworks — DeepSeek V4 Flash
• Hugging Face — DeepSeek V4 Flash
• KTransformers single-RTX-5090 deployment guide
• KTransformers one-million-token deployment guide

Model Comparisons and Pricing

• OpenAI GPT-5.6 Sol model and pricing
• Anthropic model pricing
• Google Gemini API pricing
• Z.ai GLM-5.2 technical and benchmark report
• Qwen 3.8 Max launch guide

Last updated: August 5, 2026. API prices, provider availability, benchmark leaderboards and model aliases can change. Recheck primary sources before production deployment or procurement.