Uncensored DeepSeek Flash API

Most teams evaluating an LLM API optimize the wrong variable. They benchmark on the hardest twenty prompts they can think of, pick the winner, and discover six weeks later that ninety-five percent of their traffic is short, structured, repetitive work a model costing a quarter as much would have handled identically. DeepSeek-V4-Flash exists for that ninety-five percent. This page is about knowing when you are in it — and when you are not.

01What you actually get

Property	DeepSeek-V4-Flash-0731 · W4A16-AUTOROUND-REAP
Model id	DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP
Context / max output	262,144 tokens / 16,384 tokens
Price per 1M (input / output)	$0.50 / $2.00
Streaming · tool calling · reasoning	Yes — all three dialects
Structured output	json_schema and response_format
Image input (vision)	No — text only
Refusal layer / output filter	None
Served on	Shannon's own GPU cluster

Three API dialects reach the same weights: /v1/chat/completions (OpenAI-shaped), /v1/messages (Anthropic-shaped), and /v1/responses. Streaming works on all three. Full parameter reference is in the API documentation.

02Where it comes from: the DeepSeek lineage

DeepSeek-AI has spent five model generations on one obsession: getting frontier behavior out of a model that is cheap to serve, not merely cheap to train. Nearly every architectural decision in the line traces back to that, and the important ones are published. Three explain what you are calling when you hit this endpoint.

DeepSeekMoE — fine-grained experts plus a shared one

A Mixture-of-Experts layer replaces one large feed-forward network with many smaller ones and a router that selects a handful per token. DeepSeek's variant slices experts finer than the conventional eight-expert layout, so the same activated FLOPs buy a far more combinatorially specific mixture, and it isolates a shared expert that every token passes through, so common knowledge is not redundantly re-learned inside each specialist. DeepSeek-V3 shipped that as 256 routed experts plus 1 shared expert, activating 8 routed per token — 671B total parameters, 37B active — along with auxiliary-loss-free load balancing: rather than a penalty term that degrades quality, a per-expert bias nudges routing scores up or down each step as that expert runs under- or over-loaded.

MLA — attention that fits in memory

The other half of the serving-cost problem is the KV cache, which grows linearly with context and dominates memory at long sequence lengths. Multi-head Latent Attention, introduced in DeepSeek-V2, compresses keys and values jointly into a low-rank latent vector and caches that, reconstructing usable K/V on the fly. DeepSeek's published V2 figures, against their earlier dense DeepSeek 67B, report a 93.3% reduction in KV cache and 5.76× higher maximum generation throughput. That is why a 262K-token window is table stakes in this family rather than a premium add-on.

Sparse attention — and the precedent for cheap tokens

V3.2-Exp added DeepSeek Sparse Attention: a lightweight indexer scores context tokens against the query, and a selector keeps only the top-scoring ones. The interesting part is the receipt, not the mechanism. DeepSeek published a side-by-side against V3.1-Terminus with MMLU-Pro identical at 85.0, AIME 2025 up (88.4 → 89.3), SWE-bench Verified marginally down (68.4 → 67.8) — essentially flat quality — and cut their API prices by more than 50% the same day. Architecture, honestly reported, turning directly into price. Flash is that argument taken one step further.

The V4 generation

V4, previewed in April 2026 under an MIT license, replaces the attention stack again with a hybrid of Compressed Sparse Attention and Heavily Compressed Attention, trains with the Muon optimizer on more than 32T tokens, and keeps V3's multi-token-prediction objective — which doubles as speculative decoding, and which DeepSeek measured at an 85–90% second-token acceptance rate for roughly a 1.8× decoding speedup in V3. The V4 abstract reports V4-Pro running at 27% of V3.2's single-token inference FLOPs and 10% of its KV cache. The family exposes three reasoning-effort levels, which is what our reasoning_effort parameter maps onto.

Sources: DeepSeek-V2 (arXiv 2405.04434) · DeepSeekMoE (arXiv 2401.06066) · DeepSeek-V3 Technical Report (arXiv 2412.19437) · DeepSeek-V3.2-Exp model card · DeepSeek-V4 (arXiv 2606.19348). All figures are DeepSeek-reported.

03What "Flash" actually means

This is the point most comparisons get wrong, so it is worth stating flatly: DeepSeek's Flash is not a quantized, pruned or distilled Pro. It is a separately trained, smaller Mixture-of-Experts model with its own pre-training run. The V4 preview paper gives the two sizes:

Figures from the DeepSeek-V4 preview paper. The official checkpoints we serve — V4-Flash-0731 and V4-Pro-0813 — list slightly larger totals of 304B and 1.7T on their model cards; DeepSeek does not restate activated parameters for those builds.

Two numbers do the work here. Total parameters set the memory footprint, which decides how much hardware a copy of the model occupies. Activated parameters set the arithmetic per token, which decides throughput. Flash is roughly 5.6× smaller on the first and 3.8× smaller on the second — and there is a subtlety worth noticing in that gap: Flash activates 13 of 284 billion parameters, about 4.6%, while Pro activates 49 of 1,600 billion, about 3.1%. Flash is the less sparse model. It is not simply Pro with fewer experts switched on; it is a denser, differently balanced design that spends a larger share of itself on every token it produces. That is a real engineering choice, not a downgrade.

What DeepSeek's own numbers say

Both official model cards publish scores on the same agentic and software-engineering benchmarks, which makes this an unusually clean comparison — the same lab, the same evaluation harness, two sizes:

Benchmark (DeepSeek-reported)	V4-Flash-0731	V4-Pro-0813
Terminal Bench 2.1	82.7	87.9
Toolathlon-Verified	70.3	74.1
DeepSWE	54.4	62.7
NL2Repo	54.2	61.5
DSBench-FullStack	68.7	71.1

Pro wins every row. That is the honest headline, and we would rather you read it here than discover it in production. But read the margins, because they are what you are actually buying. On Terminal Bench 2.1 the gap is 5.2 points on a model with a twenty-fifth of the parameters; on tool-use it is 3.8 points. The gap widens where the work gets deepest — 8.3 points on DeepSWE, 7.3 on NL2Repo, both of which reward sustained multi-step code reasoning. That is the shape of the trade in one table: Flash closes most of the distance on bounded tasks and gives ground on open-ended ones.

DeepSeek's own Flash card makes the point more sharply still: Flash-0731 outperforms the V4-Pro preview on the listed benchmarks despite its far smaller activated parameter count. A newer small model beating an older large one is the normal state of affairs in this field, and it is the reason "bigger tier" should never be your default answer.

04Reading the suffix: W4A16-AUTOROUND-REAP

Our model ids state their compression scheme out loud, because it is the thing that most affects output quality and almost nobody discloses it. This one decomposes into three claims.

W4A16 — 4-bit weights, 16-bit activations

Weights are stored at 4 bits each; activations flow through at 16-bit precision. This is weight-only quantization, and it targets the actual bottleneck in token generation, which is memory bandwidth rather than arithmetic. Quantizing activations too would buy a little more speed and risk a much larger accuracy cliff; leaving them at 16 bits is the conservative, high-fidelity choice. The notation is serving-ecosystem shorthand — the quantization literature writes the same thing as W4 with a group size.

AUTOROUND — learned rounding, not nearest rounding

Naive quantization rounds every weight to the nearest representable value. That is demonstrably not optimal: rounding one weight the "wrong" way can cancel error introduced by its neighbors, and with billions of weights those interactions dominate. AutoRound, from Intel, treats the rounding decision itself as something to learn — a trainable per-weight perturbation constrained to ±0.5, exactly enough to flip any single rounding decision and never more, plus learnable clipping ranges, optimized by signed gradient descent against a block-wise output-reconstruction objective over a small calibration set. Two hundred steps, then done.

Intel's published comparisons have AutoRound beating GPTQ in 30 of 32 tested scenarios, AWQ in 27 of 32 and OmniQuant in 29 of 32 at 4-bit weight-only settings, with gains over naive round-to-nearest of 6.9 to 33.2 accuracy points at 2 bits. None of it costs anything at inference time: it is a better choice of numbers, made once, offline.

REAP — dropping experts nobody routes to

REAP (Router-weighted Expert Activation Pruning), from Cerebras Systems and the University of Calgary, is one-shot compression for MoE models. It scores each expert by how strongly and how often the router gates to it, multiplied by the magnitude of that expert's output, then deletes the least salient experts outright — no retraining afterward.

The paper's central finding is the useful one: at high compression ratios, pruning experts beats merging them. Merging functionally distinct experts causes what the authors call functional subspace collapse — the router loses the fine-grained, input-dependent control that made the MoE worth building, and is left steering between static averages. Their numbers across models from 20B to 1T parameters: at 25% expert compression on coding tasks, REAP loses 2.8% mean accuracy where merging baselines lose over 5%; at 50%, REAP loses 8.0% where merging loses over 20%. On Qwen3-Coder-480B at 50% pruning the drop is 1.4%, against 39.3% for naive frequency-based pruning. Cerebras has published REAP checkpoints for the DeepSeek line among others.

Why 4-bit here and 3-bit on Pro

Both tiers have to fit and stay fast on the same class of hardware. Pro carries 1.7 trillion parameters, so it needs the more aggressive 3-bit treatment to fit at all. Flash carries roughly 300 billion, so it does not — and the bit it saves is spent on fidelity instead of on fitting.

That extra bit matters more than its arithmetic suggests, because quantization damage is not linear. In the AWQ paper's WikiText-2 measurements, Llama-2-7B goes from 5.47 perplexity at FP16 to 5.60 at 4-bit — a 2.4% penalty — but to 6.24 at 3-bit, a 14% penalty. That is roughly six times the degradation for 25% more compression, and the same pattern holds at 70B. The GPTQ paper is blunter still: at 3 bits, naive round-to-nearest collapses on 175B-class models, into the thousands of perplexity, while remaining perfectly usable at 4 bits. Below four bits, a good quantization algorithm stops being a nicety and becomes the only thing holding the model together.

So the honest reading of these two suffixes is: Flash sits closer to its own uncompressed self than Pro sits to its own. Pro is still the stronger model — the benchmark table above settles that. It simply gave up more to get here, and you pay for the privilege.

Sources: AutoRound — "Optimize Weight Rounding via Signed Gradient Descent for the Quantization of LLMs" (arXiv 2309.05516), Intel, Findings of EMNLP 2024. REAP — "REAP the Experts: Why Pruning Prevails for One-Shot MoE Compression" (arXiv 2510.13999), Cerebras Systems. Perplexity figures from AWQ (arXiv 2306.00978) and GPTQ (arXiv 2210.17323).

05Flash vs Pro at the endpoint

Section 03 covered the foundations. Here is what the two tiers look like as products on our gateway:

	DeepSeek-V4-Flash-0731	DeepSeek-V4-Pro-0813
Quantization	W4A16-AUTOROUND-REAP	3BIT-REAP
Weight precision	4-bit, learned rounding	3-bit
Foundation (total / active)	~304B / 13B	~1.7T / 49B
Input per 1M tokens	$0.50	$1.95
Output per 1M tokens	$2.00	$3.90
Context / max output	262,144 / 16,384	262,144 / 16,384
Tools · structured output · streaming	Yes	Yes
Vision	No	No
Refusal layer	None	None

Note what does not change: context, output ceiling, tool calling, structured output, and the absence of a refusal layer are identical. The only things that move are the foundation, the quantization, and the price. That makes switching between them a one-string change in your code and a purely economic decision in your architecture.

What one maximum-size call costs

Fill the entire 262,144-token context and take the full 16,384-token output:

At list price. Flash: $0.131 input + $0.033 output. Pro: $0.511 + $0.064. Ratio 3.51×. Flash also shares the $0.50 / $2.00 floor with MiniMax-M3, Laguna-S-2.1, MiMo-V2.5, MiMo-V2.5-Pro and Hy3 — see the full catalog for how those differ on vision and structured output.

06The volume math, worked out

"3.9× cheaper" is only true on input. On output Flash is 1.95× cheaper. Your real saving therefore depends on your input-to-output ratio, and the spread is wide enough to change design decisions. Four realistic workloads, each at 100,000 requests:

Workload	In / out per call	Flash	Pro	Saving
Ticket classification	1,200 / 120	$84	$281	3.3×
RAG question answering	8,000 / 600	$520	$1,794	3.4×
Long-document summary	60,000 / 1,500	$3,300	$12,285	3.7×
Synthetic data generation	500 / 2,000	$425	$878	2.1×

The pattern: the more context you push and the less text you generate, the more Flash saves you. Retrieval pipelines, document triage, log and transcript analysis, and long-context extraction are the sweet spot — they are input-dominated by an order of magnitude, and input is where the 3.9× discount lives. If instead your workload is a short prompt producing thousands of tokens of prose, the gap narrows to roughly 2× and the capability argument for Pro gets correspondingly stronger.

One more piece of arithmetic worth internalizing: at $0.50 per million input tokens, the entire 262,144-token window costs 13.1 cents to fill. Long-context prompting stops being a budget question at that price, which sometimes means you can skip building a retrieval layer at all and let the context window do the work — an engineering saving on top of the token saving.

07What "uncensored" means here, precisely

The word is used loosely, so here is our definition, stated as a property of the endpoint: there is no refusal classifier in front of the model and no content filtering applied to its output. Nothing intercepts a prompt and returns a canned decline; nothing inspects the completion and redacts it. For high-volume production work the consequences are less dramatic and more useful than the word suggests:

• No false positives on benign traffic. Filtered endpoints routinely decline medical summaries, security write-ups, legal discovery, fiction, harm-reduction material and moderation work itself — exactly the categories where a batch job is processing text about a sensitive topic rather than producing anything harmful. At a hundred thousand requests, a one-percent false-refusal rate is a thousand broken rows.
• Deterministic contracts. Ask for a json_schema response and you get JSON matching the schema, not a paragraph of apology where an object should be. Your parser needs no refusal branch, and your retry logic does not have to distinguish a transport failure from a policy one.
• You own the policy. That is the trade. If your product needs guardrails for your end users, you build them at your layer, where you know your users and your jurisdiction, instead of inheriting a provider's guesses about both. Your account remains governed by our Responsible Use Policy.

Uncensored is not the same as unaligned or unhelpful. The model still follows instructions and still respects a system prompt. If you want it to refuse certain categories for your users, say so there — that instruction is now yours to write rather than ours to impose.

08Capabilities and honest limits

Two capabilities carry most of the weight for volume work. Strict json_schema output turns a completion into a database row with no parsing layer and no refusal branch. Tool calling in all three dialects makes Flash a sensible engine for the cheap sub-steps of an agent whose top-level planner runs on a stronger model. Add reasoning_effort, which lets you spend extra tokens only on the fraction of traffic that needs them, and a 262,144-token context identical to Pro's — you do not surrender context by choosing the cheap tier, which is unusual.

The limits are equally concrete:

• No vision. Flash is text-only and will reject image parts in a message. For images on an uncensored model at the same $0.50 / $2.00 floor, MiniMax-M3 and MiMo-V2.5 are the vision-capable options; Kimi-K2.6 and Kimi-K3 are stronger vision models above that tier.
• Not the top of the ladder. DeepSeek's own numbers put Pro ahead on every published agentic benchmark, with the gap widest on sustained multi-step code reasoning. Where one wrong answer costs more than a thousand cheap ones, spend the extra $1.45 per million on DeepSeek-V4-Pro.
• 16,384 output tokens per request. Long generations must be chunked across calls. This is the same ceiling on every model we serve, and it binds well before the context window does.

09Calling it

Point any OpenAI-compatible client at the gateway and change the model string. Nothing else in your stack has to move.

curl https://api.shannon-ai.com/v1/chat/completions \
  -H "Authorization: Bearer $SHANNON_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
    "messages": [
      {"role": "system", "content": "Label the ticket. Reply only with the schema."},
      {"role": "user", "content": "The invoice PDF renders blank on Safari 18."}
    ],
    "response_format": {
      "type": "json_schema",
      "json_schema": {
        "name": "ticket_label",
        "schema": {
          "type": "object",
          "properties": {
            "category": {"type": "string"},
            "severity": {"type": "integer"},
            "needs_human": {"type": "boolean"}
          },
          "required": ["category", "severity", "needs_human"],
          "additionalProperties": false
        }
      }
    }
  }'

The same model id works unchanged on /v1/messages and /v1/responses, which is the fastest way to A/B a cheaper model underneath an existing integration without rewriting your client. Parameters, streaming event shapes, tool-calling schemas and rate limits are documented in the API reference; every model in the catalog is listed at Shannon Research.

10Frequently asked questions

---

Sources: DeepSeek-V2 (arXiv 2405.04434) · DeepSeekMoE (arXiv 2401.06066) · DeepSeek-V3 Technical Report (arXiv 2412.19437) · DeepSeek-V4 (arXiv 2606.19348) · DeepSeek-V4-Flash-0731 and DeepSeek-V4-Pro-0813 model cards · AutoRound (arXiv 2309.05516, Intel) · REAP (arXiv 2510.13999, Cerebras Systems) · AWQ (arXiv 2306.00978) · GPTQ (arXiv 2210.17323). All foundation and benchmark figures are as published by their respective authors; Shannon AI prices and served context are our own list values as of September 2026.