DEV Community: Mohamed Abidi

Gemini API cost: two prices double before January

Mohamed Abidi — Fri, 23 Oct 2026 19:28:16 +0000

If you picked Gemini 4 Argon this year because it cost the same as Claude Sonnet, check Google's pricing page again. On December 1, Argon goes from $2 to $4 per million input tokens and from $10 to $20 per million output tokens. Same model, same traffic, twice the invoice.

Gemini 3.8 Flash follows on January 1: $0.75 to $1.50 input, $3.75 to $7.50 output.

Price increases on an API are rare enough that most cost estimates don't plan for them. So let's take one concrete workload, price it on every current Gemini model before and after the change, and then look at the four things that move a Gemini bill more than the price list does: thinking tokens, caching, the Batch API and grounding.

I maintain a Gemini price table for a cost calculator, so I re-check Google's pricing page every few weeks. In October, two rows had something I hadn't seen on an LLM price list before: a second price with a start date. No announcement in my inbox, no deprecation notice, just a footnote on the page.

A document pipeline of 300,000 requests a month costs $6,000 on Gemini 4 Argon today and $12,000 from December 1. On Gemini 3.8 Flash: $2,250 today, $4,500 from January 1.
Thinking tokens bill as output. 1,500 thinking tokens per request add 75% to the Flash bill, and they don't appear in the answer.
The Batch API cancels the increase exactly (50% off) for work that can wait. A cached 5,000-token prefix cuts another 45–48%. Gemini 3.1 Flash-Lite runs the same job for $780.

How is the Gemini API billed?

Per million tokens, input and output separately. Cached input costs 10% of the input price, the Batch API halves input and output, and Pro models charge more once a prompt passes 200,000 tokens. These are the paid-tier list prices from Google's pricing page, in USD per million tokens, checked October 14, 2026:

Model	Input	Output	Cached input	Scheduled change
Gemini 4 Argon	$2	$10	$0.10	$4 / $20 from Dec 1, 2026
Gemini 3.1 Pro Preview	$2	$12	$0.20	$4 / $18 over 200K tokens
Gemini 3.8 Flash	$0.75	$3.75	$0.075	$1.50 / $7.50 from Jan 1, 2027
Gemini 3.5 Flash-Lite	$0.30	$2.50	$0.03	none
Gemini 3.1 Flash-Lite	$0.25	$1.50	$0.025	none
Gemini 2.5 Flash-Lite	$0.10	$0.40	$0.01	none (older generation)

Output is 5× input on Argon and Flash, 6× on Pro. That ratio matters later, when thinking tokens show up.

The example: a document extraction pipeline

Say you run a pipeline that reads inbound documents (contracts, invoices, support emails) and extracts structured fields. It isn't an agent: one request per document, no back-and-forth. These numbers are an illustration; swap in your own.

Instructions, JSON schema and a few worked examples: 5,000 tokens, identical on every request
The document itself: 3,000 tokens
The extracted JSON: 400 tokens
Volume: 10,000 documents a day, so 300,000 a month

That's 8,000 input tokens and 400 output tokens per request. A month is 2.4 billion input tokens and 120 million output tokens.

To get your own per-request numbers, paste a real prompt into a token counter that counts for Gemini, Claude and GPT. Gemini averages about 4 characters per token in English, so a 3,000-token document is roughly 12,000 characters.

What does it cost on each Gemini model?

Model	Input	Output	Monthly today	After the increase
Gemini 4 Argon	$4,800	$1,200	$6,000	$12,000 (Dec 1)
Gemini 3.1 Pro Preview	$4,800	$1,440	$6,240	no change
Gemini 3.8 Flash	$1,800	$450	$2,250	$4,500 (Jan 1)
Gemini 3.5 Flash-Lite	$720	$300	$1,020	no change
Gemini 3.1 Flash-Lite	$600	$180	$780	no change
Gemini 2.5 Flash-Lite	$240	$48	$288	no change

Three things stand out.

Input is 77–80% of the bill on the bigger models. The 400-token answer is the cheap part. The 5,000 tokens of instructions you send 300,000 times a month are not.

The ranking flips on December 1. Today Argon is slightly cheaper than Gemini 3.1 Pro for this job ($6,000 vs $6,240). From December 1 it costs almost twice as much ($12,000 vs $6,240). If 3.1 Pro passes your evals, it's the cheaper strong model from then on. It's still labelled Preview, so weigh that too.

Flash-Lite is 2–8× cheaper than Flash. Extraction into a fixed schema is the kind of task small models often handle. Run your eval set on 3.1 Flash-Lite before assuming you need Flash.

I checked the table with this Gemini API cost calculator, entering 8,000 input and 400 output tokens at 300,000 requests a month. It also shows the post-increase prices.

Why is my Gemini bill higher than the math?

Usually because of one of three things the table above doesn't include.

1. Thinking tokens

Gemini's newer models think before they answer, and thinking tokens are billed as output at the full output price. They don't show up in the response text, so you only see them in the usage metadata.

Say Gemini 3.8 Flash thinks for 1,500 tokens before writing the 400-token JSON. Output per request goes from 400 to 1,900 tokens:

Gemini 3.8 Flash	Output tokens / month	Output cost	Monthly total
No thinking	120M	$450	$2,250
1,500 thinking tokens	570M	$2,137.50	$3,937.50 (+75%)
Same, from Jan 1	570M	$4,275	$7,875

Field extraction rarely needs long reasoning. Set a low thinking budget (or thinking level, depending on the model) in the request config, and compare accuracy on your eval set with thinking low and off.

2. Grounding with Google Search

Grounding is billed per search, not per token. Gemini 3 and newer models share 5,000 free search requests a month, then $14 per 1,000. If every one of the 300,000 documents triggered one search, that's (300,000 − 5,000) × $14 / 1,000 = $4,130 a month, more than the whole Flash bill. A grounded request can trigger more than one search, so treat that as a floor. Turn grounding on only for the requests that need fresh facts.

3. Long prompts on Pro

Gemini 3.1 Pro bills the whole request at $4 input and $18 output once the prompt passes 200,000 tokens. This pipeline never gets close, but a "just send the whole repo" coding tool or a long chat history does. Gemini 2.5 Pro has the same threshold ($1.25 → $2.50 input).

Does caching lower Gemini API cost?

Yes, and this pipeline is close to the ideal case: the same 5,000-token prefix starts every request. Cached input costs 10% of the input price.

Gemini has two kinds of context caching:

Implicit caching is automatic. When a request starts with the same tokens as a recent one, those tokens are billed at the cached price. Nothing to set up, no storage fee, but hits aren't guaranteed. Put the fixed instructions first and the document last, or nothing matches.
Explicit caching stores a prefix you create, for a time you choose, with guaranteed hits and a storage fee per million tokens per hour: $0.50 on Gemini 3.8 Flash. Gemini 4 Argon supports implicit caching only.

The prefix has to be long enough to cache: 4,096 tokens on these models. A 2,000-token system prompt doesn't qualify, which is one reason to keep your worked examples in the prefix rather than trimming them to save tokens.

If all 5,000 prefix tokens hit the cache:

Model	Without caching	With the prefix cached	Saved
Gemini 4 Argon (today)	$6,000	$3,150	47.5%
Gemini 4 Argon (from Dec 1)	$12,000	$6,300	47.5%
Gemini 3.8 Flash (today)	$2,250	$1,237.50	45%

On Flash, an explicit cache for that prefix costs 0.005M tokens × $0.50 × 720 hours = $1.80 a month to keep warm. For a pipeline that runs all day, buying guaranteed hits is an easy call.

Does the Batch API cancel the price increase?

For this pipeline, exactly. The Batch API takes 50% off input and output for jobs submitted asynchronously, and the increase is 2×:

Model	Standard, after increase	Batch, after increase
Gemini 4 Argon	$12,000	$6,000
Gemini 3.8 Flash	$4,500	$2,250

The catch is latency. Google targets a 24-hour turnaround (often much sooner), so batch only fits work nobody is waiting on: nightly extraction, backfills, evals, classification. If documents land in a queue anyway, a few hours' delay is often invisible to users. Batch also stacks with caching.

Is the Gemini API free?

Partly. Gemini 3.8 Flash, the Flash-Lite models and the Gemini 2.5 models have a free tier in Google AI Studio and the API, within rate limits. Gemini 4 Argon and Gemini 3.1 Pro are paid only.

The catch is data: on the free tier, Google may use your prompts and responses to improve its products. On the paid tier it doesn't. The free tier is fine for prototyping. For customer documents like the ones in this example, you want the paid tier.

Price your own requests

Every response carries usage_metadata. Log it, then price it. With the Python google-genai SDK:

PRICES = {  # USD per 1M tokens, Gemini 3.8 Flash until Dec 31, 2026
    "input": 0.75, "output": 3.75, "cache_read": 0.075,
}

def request_cost(usage) -> float:
    cached = usage.cached_content_token_count or 0
    fresh = usage.prompt_token_count - cached        # prompt count includes cached tokens
    output = usage.candidates_token_count + (usage.thoughts_token_count or 0)
    return (
        fresh * PRICES["input"]
        + cached * PRICES["cache_read"]
        + output * PRICES["output"]
    ) / 1_000_000

Two fields catch people out: thoughts_token_count is billed as output even though it isn't in the answer, and cached_content_token_count tells you whether implicit caching is actually hitting. If it's zero on the second request with the same prefix, your prefix isn't stable.

What to do before December 1

Log usage_metadata for a day of real traffic. Get average input, output, thinking and cached tokens per request.
Reprice it at the new prices: $4 / $20 for Argon, $1.50 / $7.50 for 3.8 Flash. Put that number in next quarter's budget, not today's.
If you're on Argon, run your eval set on Gemini 3.1 Pro and on a Flash model. From December 1, Pro costs half of Argon's input price and 60% of its output price.
Move anything nobody waits on to the Batch API. For async work, that undoes the increase.
Put the fixed instructions first, check that cached tokens show up from the second request, and set a thinking budget on simple tasks.

Are you moving off Argon before December 1, or absorbing the increase? I'm curious what your evals say about 3.1 Pro versus Argon on the same job.

Claude API cost: I priced one AI agent on every model

Mohamed Abidi — Tue, 20 Oct 2026 12:59:25 +0000

Every Claude pricing page gives you the same thing: a table of dollars per million tokens. Sonnet 5.5 is $2 in and $10 out. Fine. But nobody ships "a million tokens". You ship a support agent, a coding assistant, a RAG endpoint, and you want to know what it will cost next month.

The per-token price doesn't answer that, because the number that decides your bill isn't on the price list: how many tokens your app sends per request, and how fast that number grows.

So let's price one concrete agent, step by step, on every current Claude model. Then we'll see where the money actually goes, and which two settings change the answer.

A 5-step support agent at 30,000 conversations a month costs $3,690 on Sonnet 5.5, $7,380 on Opus 5.5, $18,450 on Fable 5.1 and $184.50 on Haiku 5.5.
88% of that is input tokens, not the answer: every step re-sends the system prompt, the tools and everything said so far.
Prompt caching cuts the same bill by 61–67% (Sonnet: $3,690 → $1,289). Model choice moves it 100×.

How does Claude API pricing work?

Every request is billed on two counts: the tokens it reads (input) and the tokens it writes (output). Output costs 5× input on every current Claude model. Here are the list prices, in USD per million tokens, from Anthropic's pricing page, checked October 14, 2026:

Model	Input	Output	Cached read
Claude Fable 5.1	$10	$50	$0.25
Claude Opus 5.5	$4	$20	$0.20
Claude Sonnet 5.5	$2	$10	$0.10
Claude Haiku 5.5	$0.10	$0.50	$0.01

Two discounts sit on top: prompt caching (repeated input billed at the "cached read" price) and the Batch API (50% off everything, for work that can wait up to 24 hours).

That table is all a price list can tell you. The rest depends on your app.

The example: a 5-step support agent

Say you run a support agent. A user asks a billing question, and the agent works through it in 5 model calls: look up the account, fetch the invoice, check the refund status, and so on. These numbers are an illustration; swap in your own.

System prompt + tool definitions: 6,000 tokens
The user's question: 200 tokens
Each step, the model writes 300 tokens (a tool call or the answer)
Each tool returns 2,000 tokens (JSON from your billing API)
Volume: 1,000 conversations a day, so 30,000 a month

The trap is that an agent doesn't send "the new stuff" on each call. The Messages API is stateless, so every call re-sends the whole conversation so far:

calls = [6_200 + 2_300 * step for step in range(5)]
# [6200, 8500, 10800, 13100, 15400]

input_tokens = sum(calls)   # 54,000 per conversation
output_tokens = 5 * 300     # 1,500 per conversation

The fifth call reads 15,400 tokens to write 300. Across the conversation, input outweighs output 36 to 1.

What does it cost per month on each Claude model?

Multiply: 54,000 input tokens × 30,000 conversations = 1.62 billion input tokens a month. 1,500 output tokens × 30,000 = 45 million output tokens.

Model	Input	Output	Monthly total	Per conversation
Claude Fable 5.1	$16,200	$2,250	$18,450	$0.615
Claude Opus 5.5	$6,480	$900	$7,380	$0.246
Claude Sonnet 5.5	$3,240	$450	$3,690	$0.123
Claude Haiku 5.5	$162	$22.50	$184.50	$0.006

Input is 87.8% of the bill on every model, because the input/output price ratio is the same 5× across the lineup. If you've been trimming your answers to save money, you've been optimizing the 12%.

The spread between models is the other lesson: Fable 5.1 costs exactly 100× Haiku 5.5 for the same traffic. Whether Haiku can actually resolve your billing questions is a question for your eval set, not the price list. But if it passes on even half your traffic, routing that half is the biggest saving available.

To check this table, I entered one conversation as one "request" (54,000 input, 1,500 output, 30,000 a month) into this Claude API cost calculator, which prices every model side by side. A spreadsheet works too; the formula is below.

Why is the Claude API so expensive?

It usually isn't the price per token. It's three things that multiply it:

Re-sent context. Every agent step re-reads the system prompt, the tool schemas and every earlier tool result. In the example, the same 6,000-token system prompt is billed 5 times per conversation, 150,000 times a month.
Fat tool results. The 2,000-token tool result is the biggest line in the example. Raw JSON from an API carries IDs, timestamps, null fields and nested metadata the model never uses, and it stays in the context for every later step.
Hidden output. Extended thinking is billed as output tokens. A model that "thinks" for 2,000 tokens before a 300-token answer bills 2,300 output tokens at the output price.

One more, which catches people comparing models: Claude 4.7 and later use a tokenizer that produces about 30% more tokens for the same text. A lower price per token on a newer model can still mean a similar bill. Count a real prompt on the model you'll use before you compare.

What does prompt caching change?

Prompt caching bills a repeated prompt prefix at the cached-read price. In an agent loop, almost everything is a repeated prefix: call 3 starts with everything call 2 sent.

With a cache marker at the end of each call (and enough traffic that the shared 6,000-token system prompt stays warm), each conversation reads 44,600 tokens from cache and writes only the new 9,400. Cache writes cost 1.25× input on the 5-minute cache, so I've included them (calculators that leave writes out, including the one above, show a slightly lower number):

Model	Without caching	With caching	Saved
Claude Fable 5.1	$18,450	$6,109.50	67%
Claude Opus 5.5	$7,380	$2,577.60	65%
Claude Sonnet 5.5	$3,690	$1,288.80	65%
Claude Haiku 5.5	$184.50	$71.13	61%

On Sonnet 5.5, a cached read costs $0.10 per million tokens against $2 uncached, 95% off. What's left of the bill is mostly cache writes and output.

Caching has rules that can silently turn it off (a timestamp in the system prompt, a reordered tool list, a user who comes back after 6 minutes). That's tomorrow's post in this series. For a cost estimate, the point is simpler: an uncached agent estimate is roughly 3× too high in this scenario, so don't kill a project on it.

The threshold that changes the cheapest model

Haiku 5.5 has a long-context tier: prompts over 100,000 input tokens are billed at $0.50 input and $2.50 output, 5× its normal price. Other current Claude models bill their full context window at standard prices.

Five steps never get close. But agents that loop (coding agents, research agents) do. In the example, the context grows 2,300 tokens per step, so step 42 is the first call over 100,000 tokens. From there, every Haiku call costs 5× more, and the gap to Sonnet shrinks from 20× to 4×.

If your agent runs long, either keep the context under the threshold (summarize or drop old tool results) or price Haiku at its long-context rate.

Your own formula

Log the usage object every response returns, then price it:

PRICES = {  # USD per 1M tokens, Sonnet 5.5
    "input": 2.00,
    "output": 10.00,
    "cache_read": 0.10,
    "cache_write": 2.50,  # 5-minute write = 1.25× input
}

def request_cost(usage) -> float:
    return (
        usage.input_tokens * PRICES["input"]
        + usage.output_tokens * PRICES["output"]
        + usage.cache_read_input_tokens * PRICES["cache_read"]
        + usage.cache_creation_input_tokens * PRICES["cache_write"]
    ) / 1_000_000

input_tokens in the response counts only the uncached part, so the four fields add up without double counting. Sum request_cost per conversation and you have the number that matters: cost per resolved task, not cost per token. The field names are in the Messages API reference.

Is the Claude API free, or included in Claude Pro?

No to both. The API is pay-as-you-go per token; new accounts may receive trial credit. Claude Pro and Max subscriptions cover the Claude apps, and API usage is billed separately (Claude plans).

What to do Monday morning

Log usage for 100 real conversations and compute average input and output tokens per conversation, not per call.
Price that on two models: the one you use and the next one down. Run your eval set on the cheaper one.
Turn on prompt caching and check that cache_read_input_tokens is most of the input from the second call on.
Look at your largest tool result and cut the fields the model never reads.
If any run goes past ~40 steps, check where its context crosses a pricing threshold.

What does one task cost in your app, and how many model calls does it take? I'm curious how far real agents are from the 5-step example.