The Uncensored DeepSeek API

People arriving at the phrase "uncensored DeepSeek API" want one specific thing: a model with DeepSeek's reasoning and coding ability that answers the question they actually asked. The capability half is well documented — DeepSeek-AI published the architecture and the numbers, and the weights are on Hugging Face under MIT. The second half is an operating decision, and it is usually made for you. This page covers both: what the V4-Pro foundation is, what our 3BIT-REAP build does to it, and exactly what "uncensored" means when we say it.

01What "uncensored DeepSeek API" actually means

Two different mechanisms get filed under the same word. The first is alignment baked into the weights — refusal behavior learned during post-training. The second is a serving-side moderation layer: a separate classifier that inspects your prompt before the model sees it and the output before you see it, and can cut a response off mid-sentence regardless of what the model wanted to say.

Both are measurable, and DeepSeek's first-party service has been measured. Promptfoo assembled a 1,360-prompt set of politically sensitive questions and reported that DeepSeek's hosted R1 refused or deflected 1,156 of them — roughly 85%. Academic work on the same family found a distinct failure mode the authors called thought suppression, where the model's reasoning trace terminates almost as soon as it starts on a sensitive topic. A separate audit published in Information Sciences documented semantic-level suppression: content present in the model's internal reasoning that is quietly omitted or rewritten before it reaches the user. That is a harder problem than an outright refusal, because a truncated answer looks like an answer.

What we run is the open-weights release, on hardware we operate, in the United States, under Shannon Lab LLC. There is no refusal layer in front of the model and no filter applied to what comes back: your prompt is not classified for policy before it is served, and the output stream is not inspected on its way out. Because the foundation is MIT-licensed and public, you can compare our outputs against the reference weights yourself rather than taking our word for it.

02The foundation: DeepSeek-V4-Pro, a 1.6T MoE

DeepSeek-V4 is DeepSeek-AI's current open-weights family, previewed in April 2026 and shipped under MIT in two sizes: V4-Flash (284B total, 13B activated) and V4-Pro (1.6T total, 49B activated). This article is about the Pro tier. Both were pre-trained on roughly 33 trillion tokens and both natively support a one-million-token context.

The sparsity ratio is the thing to notice: only about 3% of the parameters fire on any given token, which is what makes a model this large servable at all. The MoE block itself is still DeepSeekMoE — the fine-grained routed experts plus always-on shared experts introduced in V2 — with only minor V4 changes, most visibly hash routing in the earliest layers. Multi-Token Prediction, the V3 auxiliary objective that also enables speculative decoding, is retained unchanged.

The new pieces in V4 are structural. Manifold-Constrained Hyper-Connections (mHC) replace the plain residual path with a learned mixing matrix constrained onto the manifold of doubly stochastic matrices via a Sinkhorn–Knopp projection — a residual stream that reweights per input without the numerical drift that kills very deep stacks. Training moved off AdamW onto Muon for most modules, using Newton–Schulz orthogonalization, with AdamW kept only for embeddings, prediction heads, normalization and the static mHC parameters. And expert weights are trained in FP4 with most other parameters in FP8 — quantization-aware from the start, which matters for how gracefully the model takes further compression.

03From MLA to CSA + HCA: how DeepSeek keeps long context cheap

DeepSeek's through-line across four generations is not size, it is attention economics. Every version has attacked the KV cache, which grows linearly with context and dominates memory at long lengths.

• V2 introduced Multi-head Latent Attention (MLA) — a low-rank joint compression of keys and values into a latent vector, so generation caches that vector plus a decoupled RoPE key instead of full per-head K and V. DeepSeek reported KV cache down to roughly 4–14% of standard multi-head attention, with quality held or improved.
• V3 scaled that to 671B, making MLA the default assumption for cheap long context in open models.
• V3.2 added DeepSeek Sparse Attention (DSA), selecting a top-k subset of history per query through a lightweight indexer rather than attending to everything.
• V4 hybridizes. Compressed Sparse Attention (CSA) first compresses the KV entries of every m tokens into one entry with learned weights, then runs sparse top-k selection over those compressed entries. Heavily Compressed Attention (HCA) compresses far more aggressively but stays dense over the result. The two layer types are interleaved through the stack, so cheap global summary and precise local retrieval coexist.

The reported payoff at a one-million-token context is stark: V4-Pro needs about 27% of the per-token inference FLOPs and 10% of the KV cache of V3.2. That is why a 262K request behaves like a normal request rather than a memory event, and why the long-context retrieval numbers hold up instead of collapsing past a few tens of thousands of tokens.

04What the 3BIT-REAP suffix means

Our catalog id ends in 3BIT-REAP, and that describes two independent compression steps applied in order.

REAP: pruning experts, not merging them

REAP is Router-weighted Expert Activation Pruning, from Cerebras Research — "REAP the Experts: Why Pruning Prevails for One-Shot MoE Compression", accepted to ICLR 2026. In a sparse MoE the router does not use its experts evenly: a long tail is selected rarely, weakly, or both. REAP scores each expert by combining router gate values (how often and how strongly it is chosen) with expert activation norms (how much its output contributes), then deletes the losers outright.

The paper's argument is that pruning beats merging: merging averages away the functional specialization that made the MoE worth building, while deleting the experts the router barely reaches preserves it. Across models from 20B to 1T, REAP outperformed merging and competing pruning methods on generative benchmarks, and the authors report near-lossless results on code generation and tool calling at 50% expert pruning on Qwen3-Coder-480B and Kimi-K2 — which is precisely the workload profile this model is here for.

3-bit weights: the compression tier for the biggest foundations

What survives is then quantized to 3-bit weights. Three bits is aggressive, and we do not pretend otherwise: across the lineup we use W8A16 where the foundation is small enough not to need the squeeze, W4A16-AUTOROUND-REAP in the middle, and 3BIT-REAP only on the largest foundations, where it is the difference between serving the model and not serving it.

The tradeoff is worth stating plainly: a 3-bit 1.6T MoE is not bit-identical to the reference release, and a small quality cost is real. What you get for it is a foundation whose uncompressed ceiling sits far above anything that fits comfortably at higher precision — and because V4's experts were trained in FP4 to begin with, the model is unusually well-behaved under further weight compression. If you want a DeepSeek build with a lighter touch on precision, DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP uses 4-bit weights with 16-bit activations and AutoRound's learned rounding, on the same 262K context at $0.50 in / $2.00 out.

05Reasoning, and the reasoning_effort dial

V4's post-training trains domain specialists separately — math, coding, agents, instruction following — with SFT followed by GRPO, the Group Relative Policy Optimization method DeepSeek introduced with R1. Those specialists are then unified into one model by on-policy distillation under a reverse-KL objective, so a single checkpoint carries specialist-grade behavior in several domains at once rather than being a generalist that is mediocre at all of them.

The released model exposes graduated thinking modes rather than a binary switch. On our gateway that is the standard reasoning_effort parameter, the single most useful knob on this model:

• Low — near-direct answering: classification, extraction, rewriting, anything where you are paying for the model's knowledge rather than its deliberation.
• Medium — the default working mode for code review, debugging and multi-step analysis.
• High — long deliberation before answering. Where the hard problems get solved, and where your output-token bill lives, since reasoning tokens are billed as output.

Because there is no refusal layer, the reasoning trace is not truncated on sensitive subject matter — the thought-suppression pattern documented on the first-party service has no mechanism to occur here.

06Code and agentic work: what the foundation scores

These are DeepSeek-AI's own published figures for the V4-Pro release — not ours, and not measured on our quantized build. We show them because they are the honest reason to pick this foundation, and flag them as first-party so you can weight them accordingly.

Two deserve comment. SWE-bench Verified at 80.6% is real-repository issue resolution — reading an unfamiliar codebase, locating the defect, producing a patch that passes the project's own tests. MRCR at one million tokens (83.5) is multi-round coreference retrieval at full length, the number that tells you the long-context claim is not decorative. DeepSeek also reports a Codeforces rating of 3206 for the model, and 62.0 on CorpusQA at 1M context.

Figures above are DeepSeek-AI-reported for the DeepSeek-V4-Pro reference release. Our 3BIT-REAP build is a compressed variant of those weights and has not been independently benchmarked at these tasks; treat the reference scores as the foundation's ceiling, not as a measurement of this endpoint.

07262K context: what actually fits

The reference model is trained for a million tokens. We serve 262,144 — the window every model on the gateway shares, so switching models is a one-line change and never a context regression. In practice 262K is past the point where context binds for most real work:

Workload	Approx. tokens	Fits in 262K?
Mid-size service repo (~50k lines)	~600K	No — select modules
Single subsystem + its tests	~60–120K	Yes, comfortably
Full RFC set for a protocol	~150K	Yes
A 700-page technical book	~250K	Yes, near the limit
Long agent run, 40+ tool turns	~80–200K	Yes

The limit to plan around is output: 16,384 tokens maximum per response. That is a long document or a substantial multi-file patch, but not a codebase. Large generation jobs are done by chaining requests with the previous output back in context — which the 262K window makes cheap — rather than by asking for one enormous completion.

08Price, and where V4-Pro sits in the lineup

At $1.95 in / $3.90 out per million tokens, V4-Pro is the flagship reasoning tier — the model you reach for when the problem is hard. When it is merely large, cheaper models on the same 262K window will do it for a quarter of the price.

Uncensored model	In / 1M	Out / 1M	Vision	Best for
DeepSeek-V4-Pro · 3BIT-REAP	$1.95	$3.90	No	Hard reasoning, code, agents
DeepSeek-V4-Flash · W4A16	$0.50	$2.00	No	Same lineage, high volume
GLM-5.2 · 3BIT-REAP	$0.73	$2.34	No	General-purpose workhorse
Kimi-K3 · 3BIT-REAP	$3.83	$19.12	Yes	Top-end multimodal agents
MiniMax-M3 · 3BIT-REAP	$0.50	$2.00	Yes	Cheapest vision

Being straight about the comparison people will actually make: DeepSeek's own API is cheaper than this — first-party V4-Pro lists around $0.435 in / $0.87 out, and their cache-hit input pricing is lower still. If price per token is your only criterion and the moderation behavior does not affect your work, use the first-party API; we would rather tell you that than have you find out later. The premium buys a different set of properties: no refusal layer and no output filter, a US operator under Shannon Lab LLC, a pinned dated checkpoint (0813) so a silent upstream upgrade never changes your outputs mid-project, three API dialects against one model, and the same 262K window and parameter surface across all twelve models in the lineup.

09Calling it: three dialects, one model

Every model on the gateway answers on all three endpoints, with streaming on each. You do not adopt a new SDK — you change a base URL and a model id.

curl https://api.shannon-ai.com/v1/chat/completions \
  -H "Authorization: Bearer $SHANNON_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "DeepSeek-V4-Pro-0813-3BIT-REAP",
    "reasoning_effort": "high",
    "stream": true,
    "messages": [
      {"role": "system", "content": "You are a systems programmer. Be direct."},
      {"role": "user", "content": "Audit this parser for memory-safety bugs."}
    ]
  }'

• /v1/chat/completions — OpenAI dialect; works with the OpenAI SDKs and anything built on them.
• /v1/messages — Anthropic dialect, for codebases already written against that shape.
• /v1/responses — the Responses-style interface.

Supported on this model: streaming, native tool calling, strict json_schema structured output, response_format, and reasoning_effort. Full parameter reference and a live playground are in the API documentation.

10Honest limits

Four things to know before you build on it:

• No vision. Text-only; it will not accept image input on any endpoint. If you need an uncensored model that sees, use Kimi-K3, Kimi-K2.6, MiniMax-M3, MiMo-V2.5 or inkling.
• 16,384-token output ceiling. Reasoning tokens count against it at high effort, so a long deliberation leaves less room for the answer. Chain requests for large generation jobs.
• 3-bit is a real compression. The reference scores describe the foundation, not this build. For the highest-fidelity tier, the W8A16 models (MiMo-V2.5-Pro, MiMo-V2.5, Hy3) carry the least quantization.
• Uncensored is not consequence-free. No refusal layer means responsibility for what you ask, and what you do with the answer, sits with you — under our terms of service and the law where you operate.

11Frequently asked questions

---

Sources: DeepSeek-AI — DeepSeek-V4-Pro model card · DeepSeek-V4 technical report (CSA/HCA, mHC, Muon) · DeepSeek-V2 (MLA, DeepSeekMoE) · DeepSeek-V3 technical report · REAP the Experts (Cerebras Research) · Promptfoo censorship audit · Discovering Forbidden Topics in Language Models. Benchmark figures are DeepSeek-AI-reported for the reference release; independent third-party verification of the compressed build is pending. Prices are Shannon AI list prices as of September 5, 2026.