Gemini 4 Argon API Pricing: Tokens, Cache and December Rates

Gemini 4 Argon Standard API pricing is $2 per million input tokens and $10 per million output tokens through November 30, 2026. Output includes thinking tokens. Google’s published rates rise to $4 and $20 on December 1. Standard cached input is $0.10 per million tokens during the promotion and $0.20 afterward.

These are Google Gemini Developer API rates, checked October 14, 2026, not Ofox prices or an app subscription price. Our public catalog and authenticated Ofox model-list checks did not list Argon. The examples below are synthetic budgets, not real Argon bills. The downloadable worksheet exposes every assumption so you can replace sample counts with recorded usage.

All four service tiers and the price-change date

Every number below is USD per 1,000,000 tokens. Each cell shows “through November 30 → from December 1, 2026.”

Source: the Argon section of Google’s API pricing page. Argon supports implicit caching only. Do not import the explicit-cache storage charges or supported parameters of a different Gemini model into this table.

Choose the service mode before calculating a budget. Batch and Flex share token rates here, but equal rates do not mean identical execution behavior. A rate table alone does not establish turnaround time, availability guarantees or whether your workflow supports that mode. Verify those requirements before moving a time-sensitive job. Priority costs more per token; this article has no measured latency comparison to justify paying that premium for a particular workload.

The calculation: count cache hits once

For a single ordinary request, define:

• I: total input tokens, including any input that received a cache hit.
• C: the cached subset of I, established by usage data, not a guessed reuse percentage.
• O: total billable output tokens, including thinking.
• Pi, Pc, Po: the chosen tier’s ordinary-input, cached-input and output rates per million.

token_cost_usd = ((I - C) × Pi + C × Pc + O × Po) / 1,000,000

The required relationship is 0 ≤ C ≤ I. Adding cached tokens on top of an input total that already includes them double-counts input. If an SDK exposes input and cached counts differently, first map those fields to these definitions; field names alone are not proof of inclusion.

Download the rate table and worked examples (CSV) and the local calculator (Python). The calculator makes no network requests. It is a budgeting aid for token charges, not a replacement for provider billing records. Save it locally and run:

python3 gemini-4-argon-cost.py --input 100000 --output 10000 --cached 80000 --tier standard --period promo

Expected output is 0.148000 USD, with the explicit exclusions printed alongside it. Use --period regular to calculate the published December rates. A date-independent period argument makes the pricing assumption visible when reproducing an old estimate.

Three reproducible budgets

100,000 input tokens and 10,000 billable output tokens

With no cache hit at Standard promotional rates:

100,000 / 1,000,000 × $2  = $0.20 input
10,000 / 1,000,000 × $10  = $0.10 output
Total                    = $0.30

The same counts at the published December rates cost $0.60. At 1,000 identical requests, those token-only budgets become $300 versus $600. Identical request counts are an assumption; task complexity, retries and thinking can change the actual token totals.

The same request with 80,000 cached input tokens

Here I=100,000, C=80,000, and O=10,000:

20,000 uncached × $2 / 1M  = $0.040
80,000 cached × $0.10 / 1M = $0.008
10,000 output × $10 / 1M   = $0.100
Total                      = $0.148

At December rates, the total is $0.296. This is a hypothetical cache hit, not an 80% cache-hit guarantee. Implicit caching depends on the service recognizing eligible reuse; repeated text in your application does not by itself establish billable cached usage.

A short visible answer with substantial thinking

Suppose a request has 20,000 uncached input tokens, 2,000 visible output tokens and 18,000 thinking tokens. The billable output assumption is 20,000, not 2,000. Standard promotional token charges are therefore $0.04 + $0.20 = $0.24. Pricing only the visible answer would produce $0.06 and understate this synthetic example by $0.18.

Do not estimate token counts from words or characters when reconciling an actual bill. Retain the provider’s usage fields and the applicable rate period.

Long decode: context size and billed input can diverge

Long decode can involve multiple model hops. Google’s long-decode guide explains that earlier generated tokens are fed into later hops, so cumulative billed input can exceed the original prompt size. Its worked example starts with 1,000 prompt tokens, generates 200,000 tokens and records 397,216 cumulative input tokens, even though the final context is about 201,000 tokens. These are different quantities.

The guide describes a 95% cache discount on repeated input across these hops. Use the applicable long-decode usage semantics rather than assuming the original prompt is the only input charged. Do not add each progress event’s cumulative usage snapshot: keep the latest complete cumulative values for that interaction, or you will count earlier work repeatedly. Record the interaction ID and completion state alongside usage.

Cancelled or failed jobs can still incur charges for work already performed. An empty visible result can also be associated with thinking that exhausted the output budget. A zero-length answer is not evidence of a zero-cost request.

The downloadable calculator accepts already-normalized input/cache/output totals; it does not reconstruct multi-hop usage from raw events. Validate that mapping separately before using it for long-decode reconciliation.

Search grounding is an additional line item

Google lists a shared monthly allowance of 5,000 for Gemini 3 and newer models, then $14 per 1,000 for Search grounding. The table uses “requests,” while its footnote specifies billing for each individual Search query performed. A user request can generate multiple Search queries. Do not multiply chat turns by $0.014 and call that a verified Search bill.

For a synthetic case with the allowance already exhausted, 2,000 billable Search queries would add $28. Keep token charges and tool charges separate. The worksheet excludes Search, Maps, other tool charges, taxes and currency conversion. Read the current tool-specific pricing and billing records for the service you enable; an allowance shared across models is not a fresh allowance for every application request.

A practical monthly budget and reconciliation process

1. Record the exact model, tier and applicable pricing period. For work crossing November and December, split usage by the applicable billing records rather than pricing the whole month at one rate.
2. Pilot a representative mix of tasks. Save total input, cached input, billable output and tool usage per completed attempt, including failed attempts and retries that incurred usage.
3. Group by task type. A long repository investigation and a short classification request should not share one assumed output count.
4. Multiply measured task averages by planned task volume, then add explicitly justified retry and tool assumptions. Keep the no-cache scenario as a comparison when cache behavior is uncertain.
5. Reconcile against provider records. Investigate mismatches in token inclusion, thinking, service mode, repeated hops and price date before blaming rounding.

We have locally checked the arithmetic and calculator error handling; we have not validated these examples against a paid Argon invoice. That distinction is why the sample counts remain labeled synthetic.

Does Google AI Pro include this API usage?

Do not treat consumer subscription eligibility as API credit. The access guide separates Gemini app, AI Studio, Antigravity and Developer API conditions. The API’s published Free/Pro exclusion is not a claim that Pro users cannot use Argon in the Gemini app.

A lower unit rate also does not prove a lower cost per accepted result. Read the Argon benchmark comparison before choosing a production model, and measure accepted outputs, retries and review effort on your own task set.