DeepSeek V4: Flash vs Pro, Pricing & V4.1 Guide

Published: November 7, 2026.

DeepSeek V4 is DeepSeek’s model generation for long-context reasoning, coding, agents, tool use, and high-throughput API workloads. The family began with V4 Flash and V4 Pro in April 2026, but the current lineup has moved beyond those original preview checkpoints.

As of November 2026, the official DeepSeek API lists two models: deepseek-flash, which currently serves DeepSeek-V4.1-Flash-1017, and deepseek-v4-pro, which serves DeepSeek-V4-Pro-0813. The official website and app also use V4.1-Flash-1017.

For most new applications, DeepSeek V4.1 Flash is the practical default. It is less expensive, supports native image input, provides higher documented API concurrency, and uses a newer architecture than the current Pro checkpoint. V4 Pro remains available for text-only workloads, but teams should choose it only after task-specific testing shows enough benefit to justify its higher price.

Use deepseek-flash for most new chat, vision, coding, agent, and cost-sensitive integrations. Use deepseek-v4-pro when a tested text-only workload performs materially better on Pro. Do not use retired model aliases or assume that the original V4 Preview models are still being served.

What is DeepSeek V4?

DeepSeek V4 is the successor generation to the V3 and V3.2 line. It retains selected DeepSeek technologies, including a Mixture-of-Experts design, DeepSeekMoE routing, and Multi-Token Prediction, while introducing new attention and training methods intended to support much longer contexts and stronger agent workflows.

The original DeepSeek V4 Preview launched on April 24, 2026 with two models:

DeepSeek-V4-Flash: a smaller, faster model designed for lower latency and lower API cost.
DeepSeek-V4-Pro: a much larger model intended for more demanding reasoning, coding, and agent tasks.

Both original models were text models with context support up to approximately one million tokens. DeepSeek later released dated updates, an experimental vision model, and then the architecturally different V4.1 Flash line.

“DeepSeek V4” should therefore be treated as a model generation rather than one permanent checkpoint. The exact checkpoint, API ID, modality, price, reasoning controls, and hosted availability must be checked separately.

DeepSeek V4 release timeline

Release	Date	What changed	Current position
DeepSeek V4 Preview	April 24, 2026	Introduced V4 Flash and V4 Pro with one-million-token context and selectable reasoning	Historical preview
DeepSeek-V4-Flash-0731	July 31, 2026	Updated Flash post-training and published a dated open-weight checkpoint	Weights remain available; hosted model superseded
DeepSeek-V4-Pro-0813	August 13, 2026	Updated Pro for general API, web, coding, and agent workloads	Current Pro checkpoint in the official API
DeepSeek-V4-Flash-Vision-Exp	August 21, 2026	Added experimental image understanding to the Flash line	Retired from direct hosted use
DeepSeek-V4.1-Flash	September 10, 2026	Introduced a new Causal Encoder–Decoder architecture and native vision	Superseded by the 1017 update
DeepSeek-V4.1-Flash-1017	October 17, 2026	Updated V4.1 Flash post-training and became the web, app, and API Flash model	Current Flash checkpoint

No separate V4.1 Pro or V4.2 checkpoint was listed in the official DeepSeek news index, API catalog, or verified Hugging Face collection at the time of checking. V4 Pro remains the August 13 checkpoint, while Flash has moved to the V4.1 architecture.

Current DeepSeek V4 model lineup

The current official API model list is smaller than the complete V4 checkpoint history. It exposes one Flash model and one Pro model.

API model ID	Current checkpoint	Input	Best starting use
`deepseek-flash`	DeepSeek-V4.1-Flash-1017	Text and images	General chat, coding, vision, agents, long documents, and cost-sensitive workloads
`deepseek-v4-pro`	DeepSeek-V4-Pro-0813	Text only	Text-only tasks where testing demonstrates an advantage over Flash

The current Flash checkpoint is newer than the current Pro checkpoint, but “newer” does not automatically mean better for every task. Flash and Pro have different architectures, model sizes, prices, modalities, throughput positions, and deployment requirements.

DeepSeek V4 Flash vs. V4 Pro

Category	V4.1 Flash	V4 Pro
Current checkpoint	DeepSeek-V4.1-Flash-1017	DeepSeek-V4-Pro-0813
API ID	`deepseek-flash`	`deepseek-v4-pro`
Architecture generation	V4.1 Causal Encoder–Decoder	Original V4 architecture
Input modalities	Text and images	Text only
Total API context	1,048,576 tokens	1,048,576 tokens
Maximum documented output	393,216 tokens	393,216 tokens
Reasoning modes	Non-thinking, low, high, and max	Non-thinking, low, high, and max
Tool calling	Supported	Supported
JSON output	Supported	Supported
OpenAI Responses API	Supported	Supported
Anthropic Messages API	Supported	Supported
Documented concurrency	2,500	500
API cost	Substantially lower	Higher
Best default	Most new integrations	Validated text-only Pro workloads

Official DeepSeek API model comparison showing V4.1 Flash and V4 Pro features, context length, and vision support.

Flash is the more versatile option because it combines text, vision, reasoning, tool calling, long context, and lower pricing. It is also the model currently used by DeepSeek’s official website and app.

Pro should not be selected only because “Pro” sounds more capable. Evaluate both models on a representative task set and compare correctness, latency, output length, tool reliability, and total cost. A newer Flash model may outperform the older Pro checkpoint in some workflows, while Pro may remain preferable in others.

Current API names and retired aliases

DeepSeek checkpoint names and API model IDs are not interchangeable. A checkpoint identifies a particular set of weights, while an API name can be an alias that DeepSeek later redirects to a newer model.

The current stable IDs are:

deepseek-flash for DeepSeek-V4.1-Flash-1017.
deepseek-v4-pro for DeepSeek-V4-Pro-0813.

The older names deepseek-v4-flash and deepseek-v4-flash-vision-exp may still be accepted for compatibility, but the original models behind those names are retired. Requests are routed to the current Flash model and billed according to the current Flash rates.

The older deepseek-chat and deepseek-reasoner aliases were retired on July 24, 2026. They should not appear in new integration code. Check the live DeepSeek model list and the official API changelog before deploying or updating an application.

How the original DeepSeek V4 architecture works

The original V4 Flash and Pro models use sparse Mixture-of-Experts architectures. Instead of activating every parameter for every token, a routing system selects a smaller group of expert networks for each token.

According to the DeepSeek-V4 technical report:

V4 Flash has approximately 284–285 billion main-model parameters and activates about 13 billion per token.
V4 Pro has approximately 1.6 trillion main-model parameters and activates about 49 billion per token.

The activated-parameter figure describes how much of the network participates in a token calculation. It does not represent the download size, total storage, RAM requirement, VRAM requirement, or the amount of model weights that can be discarded.

Hybrid compressed attention

The original V4 architecture combines Compressed Sparse Attention and Heavily Compressed Attention. These mechanisms reduce the amount of key-value information that must be retained or consulted across very long sequences.

This is one reason the models can support context windows far beyond the 128K-class context associated with earlier DeepSeek generations. Compression and sparse selection reduce long-context cost, but they do not make million-token prompts free or guarantee that every detail will be recalled accurately.

DeepSeekMoE and Multi-Token Prediction

V4 retains DeepSeekMoE routing from the V3 generation. Different tokens can use different experts, allowing the model to contain a large amount of specialized capacity without activating the full network for every generated token.

It also retains Multi-Token Prediction, which trains the model to predict additional future tokens. That capability can support speculative decoding, but actual speed depends on the serving framework, hardware, draft acceptance rate, context length, and batch configuration.

mHC and the Muon optimizer

Manifold-Constrained Hyper-Connections, or mHC, are designed to improve signal propagation and stability in very deep networks. They are part of the model’s internal training architecture rather than a setting an API user switches on or off.

Muon is an optimizer used during training. It influences how model parameters are updated, but it is not a reasoning mode, inference option, or API feature.

What changed in DeepSeek V4.1 Flash?

DeepSeek-V4.1-Flash is not simply the original V4 Flash with newer post-training. It introduces a substantially different architecture documented in the DeepSeek-V4.1 technical report.

Causal Encoder–Decoder architecture

V4.1 Flash uses a 40-layer Causal Encoder–Decoder design with 20 causal encoder layers and 20 decoder layers. The architecture separates input processing from autoregressive output generation more explicitly than the original V4 design.

The 552-billion-parameter backbone activates approximately 8 billion parameters per input token during prefill and approximately 16 billion parameters per generated token during decoding. These figures describe routed compute, not the total amount of weights needed for deployment.

DeepSeek V4.1 Flash architecture diagram showing the causal encoder, decoder, CSA2, Engram, and vision encoder.

CSA2 and hierarchical sparse indexing

V4.1 introduces a second-generation compressed sparse-attention system called CSA2. It uses a hierarchical indexer to identify which earlier tokens are most relevant instead of applying the same full attention operation across the entire history.

The architecture supports Full, Reindex, and Reuse attention behaviors. These modes help the model balance complete attention, refreshed token selection, and reuse of earlier sparse selections across layers.

SWA Bounded Replay

SWA Bounded Replay supplements sparse long-range attention with a bounded local replay mechanism. Its purpose is to preserve important nearby information that could otherwise be lost when attention is aggressively compressed or sparsified.

Engram conditional memory

V4.1 includes an approximately 196-billion-parameter Engram memory component. Engram behaves more like conditional lookup memory than an ordinary transformer block: it stores and retrieves useful patterns without activating all of that capacity during every token calculation.

This is one reason a package-level parameter count can be much larger than the 552-billion-parameter backbone figure without causing the same number of parameters to be activated during inference.

Native image understanding

V4.1 Flash adds a native vision encoder and projector. This allows the current Flash API model to accept images alongside text for tasks such as screenshot analysis, chart interpretation, document-image reading, and visual question answering.

Vision support means image understanding, not image generation. V4.1 Flash returns text and does not create images through the standard chat API.

DSpark speculative decoding

DSpark is an auxiliary speculative-decoding component designed to draft tokens that the main model can verify. It is not a separate general-purpose chat model and should not be treated as an alternative to Flash or Pro.

Why DeepSeek V4 parameter counts differ

Official papers, model cards, and platform metadata can show different parameter numbers because they count different parts of the package.

Model	Primary architecture figure	Larger package figure	Why the figures differ
V4 Flash	Approximately 284–285B main-model parameters	Approximately 304B in later package metadata	Later packages include attached speculative-decoding or auxiliary components
V4 Pro	Approximately 1.6T main-model parameters	Approximately 1.7T in dated package metadata	The packaged checkpoint includes more than the paper’s main-model count
V4.1 Flash	552B backbone parameters	Approximately 763B in model-package metadata	The package also contains Engram memory, vision, speculative-decoding, and auxiliary components

The official materials do not provide one universal accounting table that reconciles every parameter across every component. The safest approach is to identify whether a source is reporting the backbone, main language model, complete package, conditional memory, vision stack, or activated parameters.

None of these parameter figures should be converted directly into a RAM, VRAM, disk-space, or GPU estimate without specifying the exact checkpoint, weight format, runtime, context length, batch size, and parallelism strategy.

DeepSeek V4 context window and output limits

The current official API documentation lists a total context capacity of 1,048,576 tokens for both Flash and Pro, with a documented maximum output of 393,216 tokens.

The input and output share the total context budget. A request cannot use the complete one-million-token window for input and then generate the full maximum output on top of it.

Long context is useful for:

Large code repositories.
Long legal or technical documents.
Multi-document research.
Extended agent histories.
Long-running coding sessions.
Large sets of tool results.

A large context window does not guarantee perfect recall. Very long prompts can still suffer from context-position bias, instruction dilution, conflicting evidence, repeated information, and retrieval failures. The user should structure source material, label sections, reduce irrelevant text, and test whether critical details are consistently recovered.

Long prompts also increase preprocessing latency, cache storage, and input cost. Self-hosted deployments require additional KV-cache capacity, even when the architecture uses compressed or low-precision caching.

Does DeepSeek V4 support images?

The correct answer depends on the model version.

Model	Native image input	Status
Original V4 Flash	No	Text-only historical checkpoint
V4 Pro	No	Current Pro API model remains text-only
V4 Flash Vision Exp	Yes	Experimental model retired from direct hosted use
V4.1 Flash	Yes	Current multimodal Flash line
V4.1 Flash-1017	Yes	Current Flash API, web, and app checkpoint

The current DeepSeek vision documentation lists JPEG, PNG, GIF, and WebP inputs. Images can be supplied through supported URLs, base64 data, or a compatible file reference.

DeepSeek currently limits each image to a maximum of 1,024 image tokens after processing, and those tokens are billed as input tokens. Animated GIF behavior, resizing, and frame handling should be verified against the current documentation before building a production workflow.

The current Files API workflow is for supported image files, not native PDF understanding. Applications that need to process PDFs should extract embedded text or render the relevant pages into images before sending them to the model.

Thinking modes and reasoning effort

Both current API models support direct answers and extended reasoning. Thinking is enabled by default, with high as the documented default effort.

Mode	Practical use	Main tradeoff
Non-thinking	Short factual answers, rewriting, extraction, classification, and low-latency tasks	Less reasoning time for difficult problems
Low	Moderate analysis with lower latency and output use	May underinvest in hard problems
High	General reasoning, coding, planning, and difficult questions	More latency and output tokens
Max	Selected complex tasks where additional reasoning may help	Highest latency and cost, with no guarantee of a better answer

The open V4.1 Flash checkpoint supports a more granular numerical reasoning-control mechanism, while the hosted API presents simpler effort levels. Do not assume that self-hosted and hosted reasoning controls are identical.

Visible reasoning text should not be treated as a complete or guaranteed-faithful record of the model’s internal computation. Applications should verify the final result rather than accepting a long reasoning trace as proof of correctness.

Fill-in-the-middle and prefix-completion features are documented for non-thinking mode. Check the current thinking-mode documentation before combining reasoning with specialized completion endpoints.

Tools, agents, search, and coding support

Both current V4 API models support tool calling, structured JSON output, the OpenAI-compatible Chat Completions interface, the Responses API, and an Anthropic-compatible Messages interface.

Tool support does not mean the model independently browses the web, edits files, or runs code. The model selects or formats a tool call; DeepSeek’s service or the user’s application must execute the tool and return the result.

DeepSeek also offers separate Search and Fetch APIs. Search returns relevant web results, while Fetch retrieves content from a supplied URL. These services have their own request charges in addition to any model tokens used to interpret the results.

The current V4 generation is suitable for:

Repository-scale coding assistance.
Multi-step coding agents.
Search and research workflows.
Tool-using customer-support agents.
Structured extraction and JSON generation.
Long-running conversations with large tool histories.
Visual analysis through the Flash model.

Agent reliability still depends on permissions, tool schemas, retries, sandboxing, timeout handling, output validation, and human approval for consequential actions. Benchmark performance does not remove these engineering requirements.

Current DeepSeek V4 API pricing

The following prices are the current official rates per one million tokens. DeepSeek uses different peak and off-peak prices and separates cache-hit input from cache-miss input.

Model	Period	Cache-hit input	Cache-miss input	Output
DeepSeek Flash	Off-peak	$0.003	$0.15	$0.60
DeepSeek Flash	Peak	$0.006	$0.30	$1.20
DeepSeek V4 Pro	Off-peak	$0.022	$0.66	$1.98
DeepSeek V4 Pro	Peak	$0.044	$1.32	$3.96

Official DeepSeek models and pricing table with deepseek-flash and deepseek-v4-pro column headers, capabilities, peak and off-peak token prices, and concurrency limits. — Screenshot of the official DeepSeek models and pricing table, captured November 8, 2026. Token prices are per 1 million tokens. Check the source for current rates before estimating costs; open the image to view the full-size table.

Peak periods are documented as 01:00–04:00 UTC and 06:00–10:00 UTC, Monday through Friday, excluding Chinese public holidays. Other periods, including weekends and Chinese public holidays, use off-peak rates.

The Search API and Fetch API are each priced separately at $0.75 per 1,000 successful requests. Model tokens used to process the returned content are billed in addition to those tool-request charges.

A lower token rate does not automatically produce the lowest completed-task cost. Reasoning effort, output length, retries, cache-hit ratio, image tokens, agent loops, and tool calls can have a larger effect than the listed input price alone.

Review the official DeepSeek pricing page immediately before budgeting or launching a production workload because prices, time windows, and model availability can change.

How to call the current DeepSeek V4 API

The following example follows the current OpenAI-compatible DeepSeek documentation. It uses the current Flash API ID and reads the key from an environment variable rather than placing a credential in source code.

import os

from openai import APIConnectionError, APIStatusError, OpenAI

api_key = os.environ.get("DEEPSEEK_API_KEY")
if not api_key:
    raise RuntimeError(
        "Set the DEEPSEEK_API_KEY environment variable before running."
    )

client = OpenAI(
    api_key=api_key,
    base_url="https://api.deepseek.com",
)

try:
    response = client.chat.completions.create(
        model="deepseek-flash",
        messages=[
            {
                "role": "user",
                "content": (
                    "Review this migration plan, identify the three "
                    "highest-risk assumptions, and suggest mitigations."
                ),
            }
        ],
        reasoning_effort="high",
        extra_body={
            "thinking": {
                "type": "enabled"
            }
        },
    )
except APIConnectionError as exc:
    raise SystemExit(
        "Could not connect to the DeepSeek API."
    ) from exc
except APIStatusError as exc:
    raise SystemExit(
        f"DeepSeek returned HTTP {exc.status_code}: {exc.message}"
    ) from exc

print(response.choices[0].message.content)

Replace deepseek-flash with deepseek-v4-pro only when the application needs Pro and has been tested against its higher price and lower documented concurrency.

This request uses DeepSeek’s hosted infrastructure. It is not local inference and should not be confused with a self-hosted OpenAI-compatible endpoint.

Are DeepSeek V4 weights open source?

DeepSeek publishes official V4 and V4.1 model weights, model cards, configuration files, technical reports, and inference resources through its verified Hugging Face and GitHub accounts. The official repositories and weights for the major V4 checkpoints discussed here use the MIT License.

The MIT License broadly permits use, modification, distribution, sublicensing, and commercial use, provided the required copyright and permission notice is retained. It also provides the material without warranty.

Official DeepSeek V4.1 Flash 1017 model repository on Hugging Face showing MIT license and image-text support.

“Open weights” is still the most precise description when discussing the complete AI system. Public weights and inference code do not necessarily include every training dataset, internal data-processing tool, training pipeline, or production-serving component needed to reproduce DeepSeek’s original model development.

The hosted DeepSeek API, website, and app are governed by separate service terms. An MIT-licensed checkpoint does not make the provider’s production API backend, account system, billing system, search infrastructure, or web application open source.

Organizations planning commercial redistribution or regulated deployments should review the exact model license, dependencies, serving framework, and DeepSeek Open Platform terms with qualified legal counsel. This article is not legal advice.

Can DeepSeek V4 run locally?

The official V4 weights can be self-hosted, but the full models are frontier-scale systems rather than ordinary laptop models.

Official model resources document support through combinations of:

Hugging Face Transformers.
vLLM.
SGLang.
DeepSeek’s reference inference resources.
Multi-GPU tensor, pipeline, data, or expert parallelism.

DeepSeek’s reference deployments use multi-GPU server environments. The official materials do not provide one universal consumer-hardware minimum because requirements change with the exact checkpoint, weight format, context length, batch size, image use, concurrent requests, and parallelism configuration.

Current V4 and V4.1 checkpoints also require model-specific prompt handling. DeepSeek publishes the deepseek-recipe repository for message encoding, reasoning controls, image preprocessing, tool formatting, and response parsing. Loading the weight files without the correct protocol can produce malformed tool calls, missing reasoning controls, or incorrect message formatting.

Community quantizations may reduce storage and memory requirements, but they are not official DeepSeek packages unless DeepSeek is the verified publisher. Quantization can also alter reasoning quality, visual performance, tool formatting, and output stability.

For a typical personal computer, a smaller DeepSeek model outside the full V4 family is usually more realistic. Availability on Hugging Face does not prove that the model will fit on consumer hardware.

DeepSeek V4 vs. V3.2 and R1

Model line	Main role	Relationship to V4	Current position
DeepSeek V3.2	Hybrid reasoning, tool use, and text agents	Previous generation that introduced sparse attention and stronger agent training	Open weights remain available; no longer the current hosted generation
DeepSeek R1	Reasoning-focused branch developed from V3-Base	Separate lineage, not an earlier name for V4	Open weights remain useful for research and self-hosting
DeepSeek V4	Long-context reasoning, coding, tools, and agents	Successor generation with new attention and training methods	Pro remains current; original Flash was superseded
DeepSeek V4.1 Flash	Fast multimodal reasoning and agent workloads	New Causal Encoder–Decoder architecture within the V4 generation	Current Flash, website, and app model

V4 is not “R1 version 2.” R1 is a reasoning-focused post-training branch based on DeepSeek-V3-Base, while V4 is a later architecture generation that integrates selectable reasoning into a broader general, coding, and agent model.

V4.1 Flash is also not merely R1 with image support. It has a different architecture, different parameter routing, a native vision stack, different context mechanisms, and current API features designed around the V4 platform.

DeepSeek V4 limitations

DeepSeek V4 can produce convincing but incorrect answers. Long reasoning, large context, tool use, and image input increase capability, but they also create additional failure modes.

Hallucinations: the model can invent facts, citations, APIs, package names, or events.
Incorrect code: generated code can contain security flaws, outdated dependencies, or subtle logic errors.
Tool mistakes: an agent may select the wrong tool, provide malformed arguments, or repeat an unsuccessful call.
Agent loops: long-running tasks can enter repetitive planning or tool-use cycles.
Overthinking: high or max effort may add latency and cost without improving a simple answer.
Long-context failures: relevant information can still be overlooked, misweighted, or confused with contradictory passages.
Vision errors: Flash can misread small text, charts, screenshots, formulas, or low-quality images.
OCR limitations: native vision does not guarantee field-level accuracy for invoices, contracts, forms, or identity documents.
Alias changes: working model names can later be redirected or retired.
Price changes: token and tool pricing can change after an application is deployed.
Provider differences: a third-party V4 service may use another checkpoint, quantization, context limit, or safety configuration.
No calibrated confidence: a confident response is not a reliable probability that the answer is correct.

Do not allow an unverified V4 response to make medical, legal, financial, tax, identity, compliance, or engineering-safety decisions. High-stakes outputs require source checking, deterministic validation where possible, and qualified human review.

Which DeepSeek V4 model should you use?

Your requirement	Recommended starting point	Why
General chat or API integration	`deepseek-flash`	Current model, lower cost, broad capabilities
Image, chart, or screenshot analysis	`deepseek-flash`	Current Pro model does not accept native image input
Cost-sensitive high-volume workloads	`deepseek-flash`	Lower token rates and higher documented concurrency
Coding agents and tool workflows	Start with `deepseek-flash`	Current agent features, lower cost, and newer post-training
Difficult text-only workload already validated on Pro	`deepseek-v4-pro`	Use Pro when measured task quality justifies its higher cost
Maximum reasoning effort	Benchmark Flash and Pro	Max effort is a mode, not proof that one checkpoint always wins
Exact V4 research reproduction	Use the required dated open checkpoint	API aliases can change, while a fixed checkpoint is reproducible
Self-hosting on server infrastructure	Official Hugging Face checkpoint	Provides a fixed model revision and MIT-licensed weights
Running on an ordinary laptop	Choose a smaller non-V4 model	Full V4 checkpoints are frontier-scale deployments
New production application	Use current API IDs	Avoid retired aliases and outdated Preview instructions

For most readers, the decision is straightforward: start with deepseek-flash, use non-thinking or low effort for simple tasks, raise the effort only when the task requires deeper analysis, and test Pro against a representative workload before accepting its higher cost.

Official sources checked

Model availability, API routing, pricing, licenses, and official documentation checked on November 6, 2026.