• Home
  • Business
  • DeepSeek V4.1 Flash Abliterated API: 22 Parameters, One Short of the Tier
DeepSeek V4.1 Flash Abliterated API: 22 Parameters, One Short of the Tier

DeepSeek V4.1 Flash Abliterated API: 22 Parameters, One Short of the Tier

OrcaRouter lists 23 distinct request parameters somewhere on its cyber tier; the DeepSeek V4.1 Flash abliterated API documents 22 of them across all three endpoint shapes — the widest surface on the shelf [OURS].

That last detail is the useful one. Twenty-three distinct parameters appear somewhere in the tier; Flash carries twenty-two of them. A client written against this card runs on nine of the other ten without a capability check, and the one card it does not cover — Kimi K3.1 Pro — is the one you would route long-output work to anyway.

The twenty-two, grouped

Read as a flat list the surface is noise. Grouped by what they do, it is five decisions.

Sampling control (7). `temperature`, `top_p`, `top_k`, `min_p`, `frequency_penalty`, `presence_penalty`, `repetition_penalty`. The full complement. Nine of the eleven cards have some subset of these; only Flash has all seven.

Determinism and inspection (4). `seed`, `logprobs`, `top_logprobs`, `logit_bias`. Reproducibility and token-level visibility, which is what an audit trail needs. Flash is one of five cards with `seed` and one of five with `logprobs`.

Output shape (4). `max_tokens`, `max_completion_tokens`, `response_format`, `structured_outputs`. Both token fields, both ways of asking for JSON. Only Flash and Hy4 accept `max_completion_tokens`.

Reasoning (3). `reasoning`, `reasoning_effort`, `include_reasoning`. Turn thinking on, size the budget, and ask for the trace back. All eleven cards have `reasoning` and `include_reasoning`; seven have `reasoning_effort`.

Tooling (3). `tools`, `tool_choice`, `parallel_tool_calls`. Function calling, forced selection, and concurrent dispatch. All eleven have `tools` and `tool_choice`; three have `parallel_tool_calls`.

Plus `stop`, which belongs to all five groups and none.

What the surface says about the card

A parameter list is a published commitment. Every entry is something a client can send and expect an answer, which means the surface tells you what the team behind the card has tested.

Flash’s surface is the largest on the tier and its traffic is the largest too — 32.99 billion tokens in the seven days to 2026-11-15, 40% of the tier’s 82.43 billion [OURS]. That is not a coincidence. The card with the most clients gets the most parameters, because each parameter exists because a client asked for it.

The two cards with the narrowest surfaces are the two with the least traffic: Kimi K3.1 Pro and GLM 5.3 at eleven each, and Hy4 also at eleven. Kimi carries 9.62 billion tokens a week and GLM 5.3 carries 6.03 billion, so narrow surface is not the same as unused — but neither is anywhere near Flash’s volume.

For a client designer the practical reading: if you are building one integration and want it to work across the tier, build it against Flash’s surface and treat every other card as a subtraction.

The one parameter that is missing

`stream` is not in Flash’s list. It is in GLM 5.3’s, and nowhere else in the tier.

A chat-completions endpoint streams; that is what the endpoint is for. So the omission is almost certainly a documentation gap rather than a capability difference — the catalogue lists what each card’s integration advertises, and one card’s integration advertises `stream` while ten do not.

Treat it as a gap to verify, not a fact to design around. One request with `stream: true` settles it, and it is a request you would send anyway.

The general lesson is worth more than the specific case: a parameter list tells you what is documented, not what is implemented. The two differ, and the direction of the difference is not predictable. Flash’s twenty-two may well all work; so may parameters on cards that do not list them.

Building a capability-driven client

The mistake is a hard-coded parameter set. The fix is a map and a merge.

“`python

TIER = {

  “orca/orcacyber-flash-1.0”: {“temp”, “top_p”, “top_k”, “min_p”, “freq”,

      “pres”, “repet”, “seed”, “logprobs”, “top_logprobs”, “logit_bias”,

      “max_tokens”, “max_completion_tokens”, “response_format”,

      “structured_outputs”, “reasoning”, “reasoning_effort”,

      “include_reasoning”, “tools”, “tool_choice”, “parallel_tool_calls”,

      “stop”},

  “orca/orcacyber-k3.1-pro”: {“temp”, “max_tokens”, “response_format”,

      “reasoning”, “reasoning_effort”, “include_reasoning”, “tools”,

      “tool_choice”, “structured_outputs”, “stop”, “max_completion_tokens”},

  # …

}

def build(card, want: dict) -> dict:

    return {k: v for k, v in want.items() if k in TIER[card]}

“`

Two properties make this worth the twenty lines.

The first is that it fails soft. A parameter the card does not document is dropped, which means the request succeeds with a default instead of a 400. That is the right trade for a routing layer, where the alternative is an outage.

The second is that it makes the difference visible. Log what was dropped and you learn which cards in your rotation are losing which controls, which is the input to a routing decision rather than a debugging session.

The failure mode to avoid is silently dropping a parameter that changes behaviour. Dropping `temperature` is harmless; dropping `reasoning_effort` on a card you rely on for tight budgets is not. Log the drops, and alert on the ones in a short list of behaviour-critical parameters.

What it costs to have the widest surface

Nothing in price — $0.80 in and $1.60 out, the tier’s standard flash rate [OURS].

Something in latency: 998 ms median first token, the fastest in the tier, and 8,938 ms at p95 [OURS]. So the widest surface and the lowest median belong to the same card, which is the opposite of the usual trade.

And something in error rate: 0.166%, the second lowest in the tier and statistically identical to its base checkpoint’s 0.168% [OURS]. Twenty-two parameters and one failure in six hundred requests.

The card is, by every serving row, the best-provisioned on the shelf. The surface is a symptom of that rather than a cost of it.

Where the surface is not enough

Three jobs the twenty-two parameters do not cover.

Server-side prompt caching control. Caching happens on the cache-read rate — $0.15 per million against $0.80 input, an 18.75% share [OURS]. There is no parameter to request it; it is automatic on a stable prefix.

Per-request timeout. Not a model parameter. It is a client setting, and it is the one that matters most at an 8,938 ms p95.

Output-length budgeting across calls. `max_tokens` bounds one response. Splitting a job across calls is your loop, not the card’s.

A wide surface is not a complete one, and the three gaps above are the ones that shape real designs.

How to read any card’s surface

Three questions, in order.

How wide is it relative to the tier? Twenty-two against eleven is a factor of two, and that factor describes how many clients the card has been tested against.

Which families are complete? Flash has all seven sampling controls, all four determinism controls, all three tooling controls. A card with `tools` but no `tool_choice` cannot force a call; a card with `logprobs` but no `top_logprobs` gives you scores without alternatives.

What is missing that you were going to send? That is the only question with a wrong answer, and a capability map answers it in one lookup.

The short version

Twenty-two parameters across chat-completions, Responses and Messages, one short of the tier’s union and the widest surface any card here publishes.

Build against it and every other card becomes a subtraction. Keep the subtraction in a map, drop what is not documented, and log the drops — that turns a compatibility problem into a routing signal.

The single missing entry is `stream`, which almost certainly works and is worth one request to confirm. A list describes what is documented; only a request describes what is implemented.

Sourcing note: parameter surfaces, endpoint types, prices, latency, error rates, traffic and context windows are read from the eleven cards’ public model data on 2026-11-15, with seven-day windows ending that day [OURS]. The union count, the grouping and the capability-map pattern are our own. No benchmark rows are quoted.