Thirty-Nine Cents for a Whole Repository and a Whole Report

Through OrcaRouter the DeepSeek V4.1 Flash 1017 pricing lets you fill a request to both limits — 1,048,576 input tokens and 393,216 output tokens — and at $0.15 and $0.60 per million that call costs $0.1573 plus $0.2359: thirty-nine cents [OURS]. That is a full mid-sized repository read and a report the length of a short book, billed at less than the price of the coffee you drink while it runs.

Per-token pricing hides this. Nobody reasons about $0.15 per million; everybody reasons about thirty-nine cents per artifact.

The three rates, and what each one is for

Line Rate What it covers
Input $0.15 / M Everything you send: code, logs, documents, images
Cache read $0.003 / M A prefix the provider has already seen
Output $0.60 / M Everything the model writes

 

The output rate is four times the input rate. That is the opposite of the usual pattern — most cards price output higher, but rarely by only 4× — and it has a consequence for how you should shape a request: it is cheaper to let the model read than to let it write, by a wide margin.

A practical example. Suppose you have a 900,000-token codebase and want an audit. You could ask for a fifty-thousand-token report, or for a three-hundred-thousand-token report. The difference in cost is 0.25 × $0.60 = fifteen cents. Twenty-five times more report for fifteen cents is not a trade-off worth agonizing over; ask for the thorough one.

The number to watch in your own logs

Once you are budgeting per artifact, one metric predicts the invoice better than any price sheet: the ratio of output tokens to requests.

A workflow averaging a thousand output tokens per call costs a tenth of a workflow averaging ten thousand, at identical input volumes and identical rates. Nothing in the pricing page tells you which one you are running, and the difference only appears after a month of billing.

The reason to watch it is that the ratio drifts. A prompt tweak that asks for “detail” instead of “a summary”, a schema that gains three fields, a retry policy that re-runs truncated answers — each one moves the ratio, and each one moves it in the expensive direction. A team that measures the ratio weekly notices; a team that reads the invoice monthly finds out late.

The second metric is cache hit rate. Every percentage point of hit rate saves about 0.15 cents per million input tokens at this card’s rates — negligible on one call, material across a million. Both numbers are yours, both are free to collect, and neither appears on a model page.

The three artifacts worth costing

A one-megabyte source read. Say 250,000 input tokens, 20,000 output. Cost: 0.25 × $0.15 + 0.02 × $0.60 = $0.0495, under five cents.

A full repository audit. 1,000,000 input, 100,000 output: 0.15 + 0.06 = $0.21.

A maximum-fill request. Both limits: $0.39, as above.

Now compare those to the price of the same work done any other way. A hosted eval run of a hundred audit prompts at the middle size costs twenty-one dollars. The reason teams can run evaluation suites daily instead of quarterly is that the per-call number crossed below a dollar.

Where the cache changes the shape

At $0.003 per million, a cache read is two percent of the input rate [OURS]. On a workflow that sends the same large prefix repeatedly — a system prompt, a schema, a style guide, a shared codebase — that ratio is worth more than any other lever on the card.

Take the million-token audit again, but with ninety percent of the input cacheable:

0.1 × $0.15 + 0.9 × $0.003 + 0.1 × $0.60 = $0.0177 + $0.06 = $0.078

Down from $0.21 to under eight cents — a 63% reduction [OURS]. The output cost is now the majority of the bill, which is the correct shape for a model that reads cheaply and writes expensively.

That inverts a common optimization instinct. Teams usually trim input first because that is where the tokens are. On this card, input is already cheap and cacheable; the output ceiling and the number of retries are what actually move the invoice.

The peak schedule, applied to artifacts

Both rates double between 01:00–04:00 and 06:00–10:00 UTC [OURS]. Applied to the numbers above:

Artifact Off-peak Peak
One-megabyte read $0.0495 $0.099
Full repository audit $0.21 $0.42
Maximum-fill request $0.39 $0.78

 

None of those numbers is large enough to justify rescheduling an interactive request. All of them are large enough to justify moving a nightly batch: a suite of a thousand audits costs $210 off-peak and $420 in a peak window, and moving it is a one-line change.

The decision that per-token pricing hides

Once a call costs cents, a different question dominates: how many calls does the task need?

Two workflows produce the same report. The first sends the whole repository in one request and asks for one artifact. The second chunks the repository, summarizes each chunk, then writes a final synthesis from the summaries. The second is a common architecture, inherited from a time when context windows were small.

Price both. The single pass costs about $0.39. The chunked version, for a 1,000,000-token repository in forty chunks of 25,000 with a 3,000-token summary each: 40 × (0.025 × $0.15 + 0.003 × $0.60) = 40 × $0.00555 = $0.222, plus a synthesis call over 120,000 summary tokens producing 30,000 output = $0.036. Total $0.258 [OURS].

So chunking is 34% cheaper, and it is also worse: forty independent summaries lose the cross-file relationships the single pass was bought for. The price difference is thirteen cents. The quality difference is the reason anyone wants a million-token context.

That is the trade the per-token view obscures. At these rates, the right default is usually the architecture that produces the better artifact, not the one that saves a dime — and the exception is a workload so large that thirteen cents times a million calls becomes a budget line.

The corollary is worth stating for anyone building an evaluation harness: because a full-context run costs well under a dollar, you should be evaluating on real, whole inputs rather than truncated samples. A test suite that trims its inputs to fit a budget is measuring a different model.

What the money buys besides tokens

Two serving facts make the per-artifact cost meaningful rather than theoretical.

Output throughput is 199.2 tokens per second on our gateway over the seven days ending 2026-10-26, the fastest card in this batch, with a 1,453 ms median first token and an error rate of 0.0089% [OURS]. At that rate the 393,216-token ceiling takes about thirty-three minutes to emit — long enough that you should treat a maximum-fill request as a job, not a request.

And the ceiling is real: 393,216 tokens is roughly three times the length of an average novel. The reason to pay thirty-nine cents rather than four is usually that you want the long artifact, not the short one.

Independent evaluation, for calibration rather than marketing: 45.1 on the Artificial Analysis Intelligence Index (86.7th percentile), 43.3 on Humanity’s Last Exam, 55.9 on SciCode, 82.67 on long-context recall [INDEPENDENT].

The takeaway

Thirty-nine cents buys the largest request this card accepts, at off-peak rates. A practical audit costs about twenty-one cents, or eight cents with a warm cache. The per-million rates are the least useful way to think about it.

Budget in artifacts: reads cost pennies, reports cost tens of cents, and a nightly suite of a thousand audits costs a couple of hundred dollars — half of that if you schedule it outside the two peak windows. See More

Scroll to Top