DEV Community: NeverPayTwice

Claude Batch API: half price, if you can wait

NeverPayTwice — Sun, 15 Nov 2026 19:20:00 +0000

Originally published at neverpaytwice.pages.dev.

Short answer: Anthropic's Message Batches API charges 50% of the standard price on all usage: input, output, cache writes and cache reads. You send up to 100,000 requests at once and collect the answers later. Most batches finish within an hour; a batch can take up to 24 hours.

If nobody is waiting for the answer (nightly jobs, classification, evaluations, backfills), batching halves that part of your bill with no change in quality. If a person is waiting, it isn't an option.

Batch prices

USD per million tokens, from Anthropic's batch processing page:

Model	Standard input / output	Batch input / output
Claude Opus 5.5	$4 / $20	$2 / $10
Claude Sonnet 5.5	$2 / $10	$1 / $5
Claude Haiku 5.5 (prompts up to 100K tokens)	$0.10 / $0.50	$0.05 / $0.25
Claude Haiku 5.5 (prompts over 100K tokens)	$0.50 / $2.50	$0.25 / $1.25
Claude Fable 5.2	$8 / $40	$4 / $20
Claude Opus 4.8	$5 / $25	$2.50 / $12.50
Claude Sonnet 4.6	$3 / $15	$1.50 / $7.50
Claude Haiku 4.5	$1 / $5	$0.50 / $2.50

An example: an Opus 5.5 request with 5,000 input tokens and 800 output tokens costs (5,000 × $4 + 800 × $20) ÷ 1,000,000 = $0.036 at the standard rate and $0.018 in a batch. Ten thousand of them a month: $360 or $180.

What fits in a batch, and what doesn't

Good fits: nightly or weekly summaries, tagging and classifying records, running evaluations, filling in old data, generating content in bulk. Anything where an answer in an hour, or by tomorrow, is fine.
Bad fits: chat and anything else a person is waiting on, and agent loops where each step needs the previous answer. Each request in a batch is answered once, on its own; there is no back-and-forth inside a batch.
Not available in a batch: streaming, fast mode (the speed setting), server-side fallbacks and max_tokens: 0. Almost everything else in the Messages API works, including tools, images and prompt caching.

The rules worth knowing

Size: up to 100,000 requests or 256 MB per batch, whichever comes first.
Time: most batches finish within an hour. A batch that isn't done after 24 hours expires, and the requests that never ran are marked expired.
You don't pay for failures: requests that come back errored, canceled or expired aren't billed.
Order: results can come back in any order. Give each request a custom_id and match on it, never on position.
Results expire too: they can be downloaded for 29 days after the batch was created.
No edits: a submitted batch can't be changed. Cancel it and send a new one.
Separate limits: batches have their own rate limits and don't use up your normal Messages API limits.

Batching and prompt caching together

The two discounts stack: a cache read inside a batch costs half the normal cache-read price. But requests in a batch run at the same time and in any order, so cache hits are best-effort; Anthropic says users typically see cache hit rates from 30% to 98%. To raise yours, put identical cache_control blocks in every request and share as much of the prompt as you can. Because a batch can run longer than five minutes, Anthropic also suggests the 1-hour cache for shared context. The caching break-even math shows when the 1-hour cache pays off.

What a batch looks like

In Python, with Anthropic's official SDK:

import anthropic
from anthropic.types.message_create_params import MessageCreateParamsNonStreaming
from anthropic.types.messages.batch_create_params import Request

client = anthropic.Anthropic()
batch = client.messages.batches.create(requests=[
    Request(custom_id=f"item-{i}", params=MessageCreateParamsNonStreaming(
        model="claude-sonnet-5-5", max_tokens=1024,
        messages=[{"role": "user", "content": text}]))
    for i, text in enumerate(texts)
])
# later: when client.messages.batches.retrieve(batch.id).processing_status == "ended"
for r in client.messages.batches.results(batch.id):
    if r.result.type == "succeeded":
        print(r.custom_id, r.result.message.usage)

What would batching save you?

Save each response's JSON as one line in a file (in Python, message.to_json()). If you add a field such as "job" to each line, the script groups the totals by it, so you can see which jobs are worth moving. It prices every response at the standard and the batch rate. It also reads a batch results file, so you can check what a batch actually cost you. It prints numbers only and sends nothing anywhere. (Download it, or get it with the other scripts on GitHub.)

python3 claude_batch_savings.py responses.jsonl --by job

Example output (made-up data):

job                    responses      standard    batch rate   difference
nightly-summaries           1200      $21.5327      $10.7664     $10.7664
evals                        500      $18.6521       $9.3261      $9.3261
chat                         300       $7.1660       $3.5830      $3.5830
total                       2000      $47.3508      $23.6754     $23.6754

Chat can't wait, so leave it out: moving the nightly summaries and the evals saves $20.09 of $47.35 here, about 42% of the whole bill.

We tested the script on hand-checked cases: its standard prices match our bill-check script on every response, it reads both saved responses and batch result files, it leaves errored, canceled and expired batch results out of the totals, and it lists anything it can't price instead of counting it as free. Fast-mode responses are priced at the standard rate, since a batched copy would run at normal speed.

Or let something watch the bill for you

NeverPayTwice is a small app we make. It tracks your AI usage and its cost per day and per model against a monthly budget you set, flags every time you paid again for something you had already bought, and keeps a receipt for each AI purchase. It runs on your own computer; nothing is uploaded and API keys are never stored. Mac, Windows or Linux, $9 one time.

Sources: Anthropic's batch processing page (prices, limits, result types, caching) and API pricing page, checked November 15, 2026. Prices can change; check the current pages if something doesn't match.

Try the demo with sample data, no sign-up, or get NeverPayTwice for $9.

Why is my Claude API bill so high? 9 things to check

NeverPayTwice — Sun, 15 Nov 2026 17:33:30 +0000

Originally published at neverpaytwice.pages.dev.

Short answer: the usual causes are thinking tokens you never see but pay for as output, a prompt cache that silently never hits, the whole conversation being sent again on every turn, and paying a premium you didn't need (fast mode, a bigger model, real-time instead of batch).

Every response tells you exactly what you paid for in its usage block. Save those blocks, and the free script below shows where the money went, which requests skipped the cache, and which ones it can't price.

1. Thinking you never see is billed as output

On current models thinking is on by default, and on Claude Opus 5.5 it can't be switched off. The thinking happens and is billed the same whether or not you display it, and on the newest models the default display shows nothing, so it is easy to miss. Thinking tokens are counted inside output_tokens, at the output price, which is five times the input price. usage.output_tokens_details.thinking_tokens tells you how much of the output was thinking.

Fix: use the effort setting (output_config.effort). It controls how deeply the model thinks and how many tokens it spends overall. Simple tasks such as classification or short chat often do fine at low. Measure quality on real requests before and after. More on thinking costs.

2. The prompt cache never hits

Caching works on an exact prefix: any change anywhere early in the prompt makes everything after it miss. A timestamp or request ID in the system prompt, JSON written with keys in a different order, or a tool list that changes between calls will each stop the cache from ever hitting, without any error. Prompts shorter than the model's minimum cacheable length (between 512 and 4,096 tokens, depending on the model) are not cached either.

Check: if cache_read_input_tokens stays at zero on requests that share a long beginning, something is changing the prefix. Put stable content first and anything that varies after the last cache breakpoint. The caching break-even math shows when caching pays off.

3. Every turn sends the whole conversation again

The API keeps no memory between requests, so a chat or agent loop sends the full history every time. Turn 30 pays for turns 1 to 29 again as input. Without caching, the cost of a long conversation grows much faster than its length.

Fix: cache the conversation so earlier turns are read from the cache at a fraction of the price, keep tool results short, and start fresh conversations when the old context no longer matters.

4. Cache writes cost more than plain input

Writing to the cache costs 1.25 times the input price for the 5-minute cache and 2 times for the 1-hour cache. If you write a lot to the cache and rarely read it back, caching costs you more than it saves. The 1-hour cache only pays off when the same prefix is read at least twice.

5. Fast mode doubles the price

Fast mode on Claude Opus 5.5 costs $8 per million input tokens and $40 per million output tokens, twice the standard rate. If usage.speed says "fast" on requests where nobody is waiting, you are paying double for speed you don't need.

6. Work that could wait isn't batched

The Message Batches API runs requests asynchronously at half the price. Nightly summaries, bulk classification, evaluations and backfills rarely need an answer in seconds. Batch prices and limits.

7. A bigger model than the job needs

Claude Opus 5.5 costs $4 / $20 per million input / output tokens; Claude Sonnet 5.5 costs $2 / $10, half as much; Claude Haiku 5.5 costs $0.10 / $0.50. But judge cost per finished task, not per request: a cheaper model that needs more retries or turns isn't cheaper. Lowering effort on the model you already use is often worth trying first.

8. Long prompts on Haiku 5.5

Claude Haiku 5.5's $0.10 / $0.50 price covers prompts up to 100,000 tokens. Above that it is $0.50 / $2.50, five times as much. A pipeline that occasionally sends a huge document to Haiku can cost far more than expected.

9. Paying twice for the same answer

Retries after timeouts, double-clicks and pipelines that re-run can send the same request more than once. The official SDKs also retry some failed requests automatically (twice by default). Each repeat that completes is billed as a new request. How to spot duplicate AI API charges has a script that finds them.

Smaller items that also change the price: US-only inference (inference_geo: "us") adds 10%, and web search is charged per search on top of tokens.

See where your own money goes

Save each response's JSON as one line in a file (in Python, message.to_json() gives you that line), then run the script on the file. It prices every response at Anthropic's standard rates, splits the cost into new input, cache writes, cache reads, output and thinking, and lists the requests that sent a lot of new input with no cache reads. It prints numbers only and sends nothing anywhere. (Download it, or get it with the other scripts on GitHub.)

python3 claude_api_bill_check.py responses.jsonl

Example output (made-up data: 400 responses, where the first 150 sent a 12,000-token system prompt without caching):

400 responses, $14.8819 at standard API rates

Where the money went:
  new input                    $    7.5466   50.7%
  output (not thinking)        $    3.5290   23.7%
  thinking (billed as output)  $    3.2231   21.7%
  cache reads                  $    0.5232    3.5%
  cache writes (5 min)         $    0.0600    0.4%
  cache writes (1 hour)        $    0.0000    0.0%

By model:
  claude-opus-5-5              $   12.7058
  claude-sonnet-5-5            $    2.1761

Prompt tokens read from cache: 57.9%
150 responses sent 10,000+ new input tokens with no cache reads (lines: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ...)

In this example, half the bill is new input, and the 150 uncached requests are where it came from. Thinking is over a fifth of the bill, so effort is worth testing too.

We tested the script on hand-checked cases: its per-response prices match our tested per-request cost function to the cent, it skips lines that aren't responses, and it lists anything it can't price instead of counting it as free: models it has no price for, fast mode on models other than Opus 5.5, and Haiku 5.5 prompts over 100,000 tokens. Batch and US-only prices are not applied.

Or let something watch the bill for you

Sources: Anthropic's API pricing page and API documentation on thinking, effort, prompt caching, fast mode and message batches, checked November 15, 2026. Prices can change; check the current pages if something doesn't match.

Try the demo with sample data, no sign-up, or get NeverPayTwice for $9.

Why your Claude Code token count is wrong (and how to get the real number)

NeverPayTwice — Sun, 15 Nov 2026 17:16:15 +0000

Originally published at neverpaytwice.pages.dev.

Short answer: Claude Code writes each AI response to its log several times, and every copy carries the full token count. If you add up every line, you count most responses two or more times.

On the made-up sample log in our free scripts repo (30 responses, each logged 2 to 4 times, as Claude Code does), a plain sum says 5.3M tokens. The real figure is 1.8M. To get the right number, count each response once. Our free counter does that in your browser, or use the short script below.

Where Claude Code keeps its usage logs

Claude Code keeps a local log of every session. They live in a hidden folder in your home directory:

System	Folder
Mac and Linux	`~/.claude/projects`
Windows	`%USERPROFILE%\.claude\projects`

Inside there is one folder per project, holding .jsonl files (mostly one per session). Each line is one JSON event. Lines for AI responses carry a usage block with four token counts:

input_tokens: new input sent to the model
output_tokens: what the model wrote back
cache_creation_input_tokens: input written to the prompt cache
cache_read_input_tokens: input read back from the cache (much cheaper than new input)

Why adding up the logs gives the wrong answer

It looks simple: add the usage numbers on every line. But three things in how the logs are written make that total too high.

One response, several lines. A single response is written once per content block: thinking, text, and each tool call. Every one of those lines repeats the usage of the whole response. A response with a thinking block, some text and two tool calls can appear four times.
Resumed sessions copy their history. When you resume a session, earlier lines can be copied into a new log file, so the same response shows up in more than one file.
Early lines are incomplete. While a response streams, the first lines can carry a partial output count. Only the last one is final, so even picking "any one line" can under-count output.

None of this means you were billed twice. Each response is one request to the API. The over-count only appears when you total the log lines yourself, for example to estimate spending or build a dashboard.

How to count correctly

Every response line carries a message.id and a requestId. Together they identify one response. So:

Keep one record per (message.id, requestId) pair, across all files.
For its output tokens, use the largest value seen for that pair (the final streaming count).
Skip lines that are not real responses: "model": "<synthetic>" and API error messages.

A short script to do it yourself

This Python 3 script follows the rules above. It only reads your logs and prints three numbers. (Download it, or get it with the other scripts on GitHub.)

import json, pathlib, sys

root = pathlib.Path(sys.argv[1]) if len(sys.argv) > 1 else pathlib.Path.home() / ".claude" / "projects"
best, plain = {}, 0

for f in sorted(root.rglob("*.jsonl")):
    n = 0
    for line in f.open(encoding="utf-8", errors="replace"):
        try:
            o = json.loads(line)
        except ValueError:
            continue
        if not isinstance(o, dict):
            continue
        n += 1
        m = o.get("message")
        if o.get("type") != "assistant" or not isinstance(m, dict) or not m.get("usage"):
            continue
        if m.get("model") == "<synthetic>" or o.get("isApiErrorMessage"):
            continue
        u = m["usage"]
        t = [u.get("input_tokens") or 0, u.get("output_tokens") or 0,
             u.get("cache_creation_input_tokens") or 0, u.get("cache_read_input_tokens") or 0]
        plain += sum(t)
        if m.get("id") or o.get("requestId"):
            key = (m.get("id") or "", o.get("requestId") or "")
        else:
            key = (str(f), n)
        if key not in best:
            best[key] = t
        else:
            best[key][1] = max(best[key][1], t[1])  # keep the final (largest) output count

real = sum(sum(t) for t in best.values())
print(f"{len(best):,} responses in {root}")
print(f"Plain sum of the logs: {plain:,} tokens")
print(f"Real usage:            {real:,} tokens" + (f"  (the plain sum is {plain / real:.2f}x too high)" if real else ""))

Run it with python3 count_claude_code_tokens.py (on Windows: py count_claude_code_tokens.py). We checked it against our app's engine on our own logs and on sample data: the totals match exactly.

Turning tokens into dollars

Token types are priced differently: output costs several times more than input, cache writes cost a little more than input, and cache reads cost much less. Multiply each type by your model's published per-million price, using the de-duplicated counts. On a subscription plan this shows what the same usage would cost at API rates, not what you paid.

Want this every day, across every AI company?

NeverPayTwice is a small app we make. It keeps this honest count up to date for Claude Code, and for any AI API you route through its live meter (Anthropic, OpenAI, Google Gemini and compatible APIs). It also flags every time you paid again for an answer you had already bought, and keeps a receipt for each purchase. It runs on your own computer (Mac, Windows or Linux), and nothing is uploaded. $9, one time.

Try the demo with sample data, no sign-up, or get NeverPayTwice for $9.