Skip to content

Build1 publisher3 min readPublished

Default LLM calls pay list price for work that caching and batch would discount

A dev.to guide to GPT-5.6 pricing shows batch halving both token rates and a cheap-first cascade saving money until 9 in 10 calls escalate. Batch is opt-in and caching fails silently on short prefixes, so the default request often pays list price.

The Engineer · Build desk

Illustration accompanying Default LLM calls pay list price for work that caching and batch would discount

What happened

  • Batching halves both the input and output rates, with no cache-write surcharge and no minimum length, but teams have to opt in to it.
  • The post finds that a two-model cascade saves money until 9 in 10 calls escalate, provided the cheap model is 10x cheaper and its answers can be checked.
  • A failed fetch is billed again on every later agent turn, and over three attempts raw HTML costs 136 times as much as extracted text, the post reports.
  • Across seven protected targets, a plain request returned no usable pages, a better IP alone returned three, and Decodo's Web Scraping API returned six.

Compiled by The EngineerSomething wrong?How this is made

Why it matters

  • constraint Short shared instructions, such as a one-line classifier prompt, can never qualify for the cache discount, so savings on those calls have to come from batch or from routing to the cheaper model.
  • decision Moving a workload that already gets the prefix discount into batch can cost more than it saves, so each job needs its cached_tokens share measured before it is switched.
  • exposure A cascade whose check only validates format lets wrong-but-valid answers through, so its reported escalation rate, and the saving computed from it, can look better than the output quality warrants.

GPT-5.6 applies the cache discount only after the reused prefix passes a minimum length. A shorter prefix is billed at the list rate, and the call returns no error [3]. The post's own classifier example falls below that line and says so in a code comment: its shared prefix is a one-sentence labelling instruction, well under the cache minimum, so every call is priced uncached [11]. You can check this with the cached_tokens field on traffic you already send [6]. Ordering decides whether a long prompt qualifies at all. The cache matches only an unchanged prefix, so stable content goes first and per-request content goes last [8].

Caching also has a write cost. A cache write is billed above the normal input rate, and one read covers it. A prefix that is never reused pays for the write and gets nothing back [7].

Batch is the simpler discount. It is also the one a team has to ask for [4]. The complication is how it interacts with caching. According to the post, a workload may lose its prefix discount when it moves into batch [6]. A job that already clears the cache threshold has to be priced both ways before it moves. The flex option keeps the batch rate without the async round trip, and you pay for it in latency and availability [5].

Price a cheap call at C and a strong one at kC. Every request pays C, and a fraction r of them also pays kC. The cascade therefore matches the flat strong-model cost when r = 1 - 1/k. At k = 10 that gives 0.9 [1]. At a 30% escalation rate the cascade costs 40% of sending everything to the strong model [2].

For the 9-in-10 figure to hold on your workload, two things have to be true. First, the whole call has to be 10x cheaper. The post quotes the 10x gap for input on gpt-5.6-luna against gpt-5.6-terra [9]. Its example spends 1,200 input tokens for every 150 output tokens [11], so the output-rate gap moves the answer less. A narrower output gap still pulls the breakeven below 0.9 [1]. Second, the check has to catch errors. The example escalates only when the cheap model returns something outside four fixed labels [11]. A wrong answer that is still a valid label passes that check and is never counted as an escalation.

Failed fetches get more expensive the longer an agent runs. Output costs more per token, but an agent resends its whole context every turn, so input makes up more of the total [14]. A blocked page that stays in context is billed again on every turn after it arrives [12]. The cheap defence runs before any model sees the page: a status code and a look at the body catch the clear blocks [17]. The invoice counts tokens per request, so a call that returned nothing costs the same as one that worked. The post's advice is to sum the usage field by task [16].

The scraping comparison is the post's case for Decodo's Web Scraping API [13]. The seven targets are not named. The six-of-seven result will match your pipeline only if your targets block the way those seven do. The IP-only run is easier to generalise: a better IP on its own recovered three pages, which the post takes to mean that blocking depends on more than the address [13].

What to watch

  • Whether the GPT-5.6 price card states that the cached-prefix discount applies inside batch jobs.
  • The output-rate gap between gpt-5.6-luna and gpt-5.6-terra; anything under 10x pulls the cascade breakeven below 9 in 10.
  • A rerun of the seven-target scraping test with the targets named, by a party that does not sell the API being tested.
Loading claim ledger
Loading source directory links
Loading share composer
Loading topic controls
Loading related stories