AI API pricing

Last verified: 27 October 2026, against Google’s Gemini API pricing page, Anthropic’s API pricing page and the Artificial Analysis comparison pages linked below.

On 1 December 2026, Gemini 4 Argon pricing doubles. Google’s introductory rate of $2 per million input tokens and $10 per million output tokens ends on 30 November, and the standard rate becomes $4 and $20. Cached input goes from $0.10 to $0.20. Those new rates match Claude Opus 5.5’s exactly. Yet the rate card can’t tell you whether Argon stays worth paying for. Argon tends to use more tokens than Opus to finish the same work, and one public coding test found it also finished more of that work. Your bill per completed task depends on both.

That’s what this article works through: what changes, how to cost one task, what the benchmark evidence does and doesn’t show, and how to measure the answer on your own workload before the change lands.

Key Takeaways

• Every Gemini 4 Argon rate doubles on 1 December 2026: Standard, Batch, Flex and Priority, input, output and cached input. Identical token usage costs exactly twice as much in token charges.
• From December, Argon’s standard rates equal Claude Opus 5.5’s ($4 input, $20 output, $0.20 cached), so cost differences between them come down entirely to token use.
• At matched High effort, Artificial Analysis measured Argon using 62,000 output tokens per task against Opus 5.5’s 36,000. At the new prices, that turns Argon’s $1.62 per task into about $3.24, against $1.82 for Opus.
• In one developer’s coding test, Argon passed 16 of 20 runs against Opus 5.5’s 13. At introductory prices it cost $3.61 per passing run against $3.52; at December prices, about $7.21.
• Measure cost per successful task on 20 or more of your own tasks before 30 November, then reprice the same token logs at the new rates.

---

Quick Navigation

---

Gemini 4 Argon pricing: what changes on December 1?

Google made Argon generally available on 13 October 2026, and its launch post put the end date in a footnote: “After the introductory period expires on November 30, 2026”, the price rises to $4 and $20. The Gemini API pricing page lists both columns for every tier:

Tier (USD per 1M tokens)	Input	Output (incl. thinking)	Cached input
Standard, through 30 Nov	$2.00	$10.00	$0.10
Standard, from 1 Dec	$4.00	$20.00	$0.20
Batch or Flex, through 30 Nov	$1.00	$5.00	$0.05
Batch or Flex, from 1 Dec	$2.00	$10.00	$0.10
Priority, through 30 Nov	$3.60	$18.00	$0.18
Priority, from 1 Dec	$7.20	$36.00	$0.36

Every row doubles. There’s no free tier, and no long-context surcharge is listed for this model. Two lines don’t move: grounding with Google Search and Google Maps stays at $14 per 1,000 requests after 5,000 free a month, with no change shown for December. A workload that leans heavily on grounding will see its total rise by less than 2x.

For comparison, Anthropic’s pricing page lists Claude Opus 5.5 at $4 input, $20 output and $0.20 for cache hits, with Batch at $2 and $10. From December, the two models’ standard token rates are identical. One billing difference remains: Opus charges for writing to its cache ($5 per million for a five-minute cache, $8 for one hour), while Argon’s caching is implicit only, with no write charge listed.

Gemini 4 Argon pricing and the cost of one task

The formula for one request is:

Here I is input tokens, split into uncached and cached; O is billable output, which for Argon includes thinking tokens, as both the pricing page and Google’s thinking guide state; and R is the rate for each. A task is the sum over every request it makes, including retries and tool-call turns.

Illustrative example, not a measurement. An agent step sends 200,000 input tokens, of which 150,000 hit the cache, and produces 20,000 output tokens, thinking included.

Line	Through 30 Nov	From 1 Dec
50,000 uncached input	50,000 ÷ 1M × $2 = $0.100	× $4 = $0.200
150,000 cached input	150,000 ÷ 1M × $0.10 = $0.015	× $0.20 = $0.030
20,000 output	20,000 ÷ 1M × $10 = $0.200	× $20 = $0.400
Total	$0.315	$0.630

Same tokens, exactly double the cost. On Claude Opus 5.5 the same token counts would also cost $0.630, plus any cache-write charge to create that cached prefix in the first place.

That’s the controlled, price-only view, and it’s the easy part. The hard part is that two models never use the same tokens for the same job, and Argon’s own usage changes with its thinking level. The evidence on how much it uses is where things get contradictory.

What the benchmark evidence actually shows

Two public sources speak to Argon’s cost per task, and at first glance they disagree.

Artificial Analysis: the configuration matters

Artificial Analysis runs models through its Intelligence Index v4.3.2, a weighted mix of ten evaluations covering agentic knowledge work, coding, scientific reasoning and general knowledge. Its “cost per task” is a weighted average across those evaluations, priced at current list rates using token counts reported by the provider. A “task” here could be a physics problem or a spreadsheet deliverable. It isn’t a software ticket.

The figures widely quoted for Argon (62,000 output tokens and $1.99 per task, against 119,000 tokens and $5.98 for Opus 5.5) are real, but they compare Argon at High thinking against Opus 5.5 at Max effort. Opus at Max scores 58 on the index against Argon’s 53, so that pairing compares a cheaper model with a stronger configuration.

The matched comparison is Argon (High) against Opus 5.5 (High), which score 53 and 54:

Artificial Analysis, read 27 Oct 2026	Gemini 4 Argon (High)	Claude Opus 5.5 (High)
Intelligence Index v4.3.2	53	54
Output tokens per task	62k	36k
of which reasoning	36k	18k
Cost per task, at intro Argon pricing	$1.62	$1.82
Cost per task, Argon repriced at 1 Dec rates	about $3.24	$1.82

The last row is our calculation: Artificial Analysis’s $1.62 doubled, which holds if token counts and cache-hit rate stay the same. The same Argon (High) entry showed $1.99 per task on the Opus Max page, read the same day; at $1.99, the December figure would be about $3.98. Either way, at matched effort Argon writes 1.7 times as many output tokens as Opus, and at equal rates that costs roughly 1.8 to 2.2 times as much per task.

One developer’s coding test

The second source is a write-up on paddo.dev, published 14 October 2026. Its author replayed six merged changes from one production monorepo on clean snapshots, ran each model 20 times in total through the Claude Code harness at medium effort, and scored each run against the tests the original fix shipped with. Argon ran through OpenRouter.

paddo.dev, 20 runs per model	Gemini 4 Argon	Claude Opus 5.5
Runs passing all tests	16	13
Output tokens	1.37M	495k
Total cost at list prices	$57.68	$45.81
Cost per passing run, intro prices	$3.61	$3.52
Cost per passing run, 1 Dec prices	$7.21	$3.52

The last two rows are our calculation from the published totals. Two corrections to how this test is often summarised: it’s 20 runs across six changes, not 20 different tasks, and the author doesn’t say whether the totals include retries or tool-call overhead. They also report a proxy fault that broke caching on Argon’s first run, inflating it to $17.60 before a fix brought a comparable run to $2.62. It’s unclear whether that run sits in the total.

One detail in those totals is easy to miss. At list rates, Argon’s output tokens account for about $13.70 of its $57.68, and Opus’s for about $9.90 of $45.81. Most of both bills is input: a coding agent rereads files and context on every turn. Output-token counts alone understate how differently the two models drive a harness.

Why the two sources only seem to disagree

The author contrasts their result with Artificial Analysis showing Argon using fewer tokens than Opus. That contrast comes from the Max-effort pairing. At matched effort, both sources point the same way: Argon generates more tokens than Opus 5.5, 1.7 times as many on Artificial Analysis’s mixed tasks at High and 2.8 times as many on six coding changes at medium.

Where they genuinely differ is quality. Opus scores a point higher on the index; Argon passed three more runs in the coding test, mostly by solving one change (change B) that Opus failed in every run. The author’s own caveat applies: a different codebase puts a different change in that slot. Six changes from one repository are enough for that team’s decision, and not enough to rank the models.

Why Gemini 4 Argon pricing doesn’t tell you the whole bill

The rate card fixes the price of a token. Several things you control, and some you don’t, fix how many tokens you buy.

• Thinking level. Argon supports low, medium and high thinking, defaults to medium, and bills all thinking tokens at the output rate even though only summaries come back. Artificial Analysis tests at High; the coding test used medium. If your requests don’t need deep reasoning, dropping to low is the single biggest lever after December, and it’s free to test.
• Cache hits. Argon caches automatically for prompts of at least 4,096 tokens, at 95% off input. The coding test’s proxy fault shows the stakes: the same kind of run cost $17.60 with caching broken and $2.62 with it working, 94% of input served from cache. Anything that changes the start of your prompt between calls (timestamps, reordered tool lists, per-request IDs) quietly turns cheap cached input into full-price input.
• Retries, tool calls and loops. Every retry and every tool-result turn is another request with its own input bill. An agent that needs three attempts on a hard task pays for all three, which is why cost per successful task is the number that matters.
• Tier choice. Batch and Flex run at half the standard rate, so from December they cost exactly what Standard costs today. Any work that can tolerate delay, such as evaluations, backfills and nightly jobs, can move tier and stay at the old price. Priority runs at 1.8 times Standard.
• Time and people. In the coding test, Argon took 991 seconds per run on change B against Opus’s 455. A model that’s cheaper per fix but twice as slow can still cost more if a developer is waiting on it, and a model that fails less can save review time no API bill shows. How inference cost per token is calculated across those layers is covered in our breakdown of the three numbers that matter.

How to measure your own Gemini 4 Argon cost per task

You have until 30 November to collect token logs at the cheap rate, and those logs are all you need to price December exactly. The protocol:

1. Pick 20 to 50 real tasks from your backlog or production traffic. Include a few that are hard.
2. Freeze everything: instructions, context, tool definitions, model settings (including Argon’s thinking level and the other model’s effort level) and the acceptance test for each task.
3. Run each model under a documented configuration, in the same harness, from the same region.
4. Log token counts per request from the API’s usage fields: uncached input, cached input, output and thinking. Keep them per task, not just as a monthly total.
5. Log every retry, failed run and tool call, plus non-token charges such as search grounding.
6. Score each run against the same acceptance test. Tests that pass or fail beat a human “looks fine”.
7. Divide total API cost by successful tasks. Failed runs still count in the numerator.
8. Record latency and human review time separately, so they can be weighed rather than hidden.
9. Repeat runs where results vary: three runs per task is a reasonable floor for agentic work.
10. Reprice the same logs at December rates. For Argon that’s a straight doubling of token charges; nothing else in the calculation changes.

Step 7 is the formula our GPT-6 Sol vs Claude Opus 5.5 comparison uses to fold retries and completion rate into a cost per completed task:

Here’s how the results might look. Every number in this table is illustrative, invented to show the arithmetic. Model X stands for a model priced like Argon, Model Y for one priced like Opus 5.5, including a cache-write charge.

Illustrative, 20 tasks	Model X (intro)	Model X (from 1 Dec)	Model Y
Passing tasks	17	17	14
Tokens: uncached / cached / output	3.0M / 25M / 1.2M	same	2.0M / 15M / 0.5M + 1.0M cache writes
Total API cost	$20.50	$41.00	$26.00
API cost per successful task	$1.21	$2.41	$1.86
Including 15 min review per failure at $60/hour	$3.85	$5.06	$8.29

On API cost alone, December flips this example: X goes from 35% cheaper per success to 30% dearer, and no pass rate out of 20 could save it, since it would need 22 passes to match Y. Add the human cost of failures and X wins at either price. Your own numbers will differ. The structure won’t.

A 20-task run is enough to make an engineering decision for one team on one workload. It isn’t enough to say one model is better in general, and the stochastic spread between runs can be larger than the gap you’re trying to measure.

Should you keep using Gemini 4 Argon after December 1?

It depends on which of these describes you.

• Argon passes your tests noticeably more often. If failures cost real review or rework time, a higher pass rate can outweigh a doubled token bill, as the illustrative table shows. Re-measure, but don’t switch on price alone.
• Argon and the alternative pass at similar rates. At equal rates per token, cost tracks token use, and on both public sources Argon uses more. Test the alternative seriously.
• The work isn’t urgent. Move it to Batch or Flex. From December they cost $2 and $10, exactly today’s Standard rate.
• You haven’t tuned thinking. Try low thinking on your simpler tasks before comparing models; it may close most of the gap.
• Latency matters. Argon was the slower model in the coding test, roughly twice as slow on its hardest change. If a person waits on the answer, weigh that alongside cost.
• Your cache-hit rate is low. Fix prompt prefixes first. The difference between broken and working caching was nearly sevenfold in the one documented run.

There’s no general verdict here, and the evidence doesn’t support one. Artificial Analysis says Argon roughly matches Opus 5.5 at High while writing more. One coding test says it passes more often while writing much more. Both lead to the same practical rule: from 1 December, paying the same rate as Opus only makes sense where Argon’s extra success rate, speed or fit earns back its extra tokens.

Frequently asked questions

When does Gemini 4 Argon pricing increase?

On 1 December 2026. Google’s introductory pricing applies through 30 November 2026, according to its Gemini API pricing page and the footnote to its 13 October launch announcement.

How much will Gemini 4 Argon cost per million tokens from December 1?

On the Standard tier, $4.00 per million input tokens, $20.00 per million output tokens (thinking tokens included) and $0.20 per million cached input tokens. Batch and Flex become $2.00, $10.00 and $0.10; Priority becomes $7.20, $36.00 and $0.36.

Will the price increase double every customer’s API bill?

Token charges double exactly for identical usage, because every Argon rate doubles. Total bills can differ: search grounding fees don’t change, and anyone who lowers thinking levels, improves cache hits, or moves work to Batch or Flex will pay less than double.

Is Gemini 4 Argon still cheaper than Claude Opus 5.5 after December 1?

Not per token: from December both list $4 input, $20 output and $0.20 cached on their standard tiers. Per task, Argon used more output tokens than Opus 5.5 in both public sources checked, so it will often cost more, unless a higher pass rate or lower review time offsets that.

How do you calculate Gemini 4 Argon cost per task?

Add uncached input tokens times $4, cached input times $0.20 and output (including thinking) times $20, each per million tokens, across every request the task makes, retries included. Divide the total over a batch of tasks by the number that passed your acceptance test.

How can developers benchmark the models before the pricing change?

Run 20 to 50 real tasks on each model before 30 November with frozen settings and fixed acceptance tests, logging token counts per request. Then reprice the same logs at December rates. Argon’s charges simply double, so you can compare costs without running anything twice.

---

Keep reading

Here are the latest posts from the blog.