Gemini 4 Argon Price Increase: Calculate Your December Bill

Quick answer (verified October 17, 2026): Google's gemini-4-argon API costs $2 per million input tokens and $10 per million output tokens on its Standard tier through November 30, 2026. On December 1, those prices become $4 input and $20 output. Output includes thinking tokens. Implicitly cached input is 95% cheaper than ordinary input; Batch and Flex cost half as much as Standard at the same date. There is no free API tier for this model. Source: Google Gemini API pricing.

The click-worthy question is your actual December number. A service with 100,000 monthly support replies in our example goes from $900 to $1,800, before grounding or extra retries. But a coding agent with longer outputs and provider-confirmed cache hits has a very different bill. Use the UsageBox task-cost calculator with your own volumes and the published rates below, or plug the interactive December cost widget supplied with this article into the page. No signup is required for the existing UsageBox calculator.

Gemini 4 Argon pricing: complete rate table

All figures are in US dollars per 1 million tokens, based on Google's published rates on October 17, 2026. Cached-input rates refer to implicit cache hits; explicit caching is not supported by Argon.

Google also lists an invite-only Contributor tier at half the Standard rate, with different data-use terms; it is not a general public discount. Batch and Flex are distinct service classes, so check their processing and availability characteristics before choosing solely on price. Priority buys a different service class, not a cheaper model. Full pricing and tier terms.

Other charges can appear: for example, Google lists Google Search grounding beyond a shared monthly free allowance at $14 per 1,000 requests on applicable service classes. This is not included in any token-only estimate below. Enterprise agreements can also differ from public list prices.

How much more will your Gemini 4 Argon workload cost?

These are illustrative estimates, not observed UsageBox traffic or vendor invoices. They assume Google's published token rates, no negotiated discount, no paid grounding, and that request counts and token consumption stay constant. Each estimate includes all generated output tokens, including thinking.

For example, the support workload is (200 × $2) + (50 × $10) = $900 in October/November. Its December cost is (200 × $4) + (50 × $20) = $1,800. The dollar increase is $900/month. With Batch rates, those same token counts would be $450 and $900, respectively, assuming the workload is eligible and completes under Batch's operational terms.

The coding-agent case is particularly sensitive to output volume. Argon offers configurable thinking levels, and thinking tokens are part of the billed output. A model that appears inexpensive on input can still run up a large bill while planning, using tools and correcting earlier steps.

What prompt caching actually saves

Argon uses implicit caching, not the explicit cachedContents/caches.create interface. Google's migration documentation says implicit caching is enabled by default for qualifying prompts of at least 4,096 tokens and discounts cached input by 95% on cache hits. That does not mean every prompt above 4,096 tokens is guaranteed to hit the cache.

Take the 10,000-task analysis workload above: 100 million input tokens and 30 million output tokens monthly. Suppose provider usage records show that 70 million input tokens were actually cached, leaving 30 million uncached:

Without cache hits, that workload costs $500. With the assumed hits, the savings are $133/month, or 26.6% of the uncached total. After December 1, the same cached workload becomes $734, versus $1,000 without hits. The percentage saved remains the same because all these listed rates double.

If your prompts have rapidly changing prefixes, you cannot budget as if 70% will be cached. Record actual cached-token counts from the provider's usage metadata and use those numbers in your forecast. An application-level cache hit is not automatically a Gemini billable cache hit.

Reproduce the calculation in Python (or use the interactive estimator)

This example does not call Google's API. It computes a transparent list-price estimate from token totals your application has already collected. It separates cached from uncached input and validates the accounting before applying the rate card.

from decimal import Decimal

RATES = {
    "intro": {
        "standard": ("2", "0.10", "10"),
        "batch": ("1", "0.05", "5"),
        "flex": ("1", "0.05", "5"),
        "priority": ("3.60", "0.18", "18"),
    },
    "december": {
        "standard": ("4", "0.20", "20"),
        "batch": ("2", "0.10", "10"),
        "flex": ("2", "0.10", "10"),
        "priority": ("7.20", "0.36", "36"),
    },
}


def estimate_usd(
    *,
    input_tokens: int,
    cached_input_tokens: int,
    output_tokens: int,  # Includes thinking tokens
    period: str = "intro",
    service_class: str = "standard",
) -> Decimal:
    if min(input_tokens, cached_input_tokens, output_tokens) < 0:
        raise ValueError("Token counts must be nonnegative")
    if cached_input_tokens > input_tokens:
        raise ValueError("Cached input cannot exceed total input")
    input_rate, cache_rate, output_rate = map(
        Decimal, RATES[period][service_class]
    )
    million = Decimal(1_000_000)
    return (
        Decimal(input_tokens - cached_input_tokens) * input_rate
        + Decimal(cached_input_tokens) * cache_rate
        + Decimal(output_tokens) * output_rate
    ) / million


for period in ("intro", "december"):
    amount = estimate_usd(
        input_tokens=100_000_000,
        cached_input_tokens=70_000_000,
        output_tokens=30_000_000,
        period=period,
    )
    print(period, f"${amount:,.2f}")
# intro $367.00
# december $734.00

Use this for planning, not as a replacement for a provider invoice: multimodal usage, tool requests, eligibility, service-class routing, refunds and negotiated pricing can alter a final bill. If an API response exposes separate output and thinking counters, avoid counting thinking twice; reconcile the total charged output against provider accounting.

You can also put your measured call shape into the UsageBox cost-per-task calculator, which includes repeat calls and retry overhead without pretending its price table is live.

Migration risks: the model switch that changes the bill

Google's Argon migration guide highlights several technical differences beyond price:

1. The model ID is gemini-4-argon. Pin it explicitly so rollout, logging and fallback are understandable.
2. Thinking levels can be set to low, medium or high (default: medium). Measure successful-task cost at each setting; fewer output tokens are only useful when the task still succeeds.
3. Argon does not support explicit context-cache creation or references. Remove old explicit-cache API calls when migrating.
4. The API can perform much longer generation, including background execution. Long-running agent steps can amplify token usage or cause client timeout/retry confusion.
5. The model is not on the free tier. A prototype that used free requests on another Gemini model needs a real spend budget before moving to Argon.

Do not assume a successful HTTP request corresponds to one completed customer task. A task can contain several model calls, tools and retry attempts. In a metered SaaS, keep separate identifiers for customer task, provider attempt, model, and service class. That lets you distinguish a customer-visible success from costly duplicate inference.

Checklist: forecast your real December charge before it hits

Before November ends, export a few weeks of real usage and calculate two prices for the same traffic: introductory and post-December. Track the following separately: input tokens, provider-confirmed cached input, output including thinking, model/service class, retries, and the customer or product feature responsible. If you use grounding, capture that as another charge category rather than hiding it in tokens.

Then decide whether to stay on Standard, move suitable jobs to Batch or Flex, reduce thinking on simpler tasks, route low-complexity jobs to cheaper models, or cap high-cost operations. Choose by cost per successful task, not the headline $/million number. A half-priced model that needs three attempts is not cheaper.

For production evidence, UsageBox's LLM cost tracking records token quantities or costs your application computes, routes them to the appropriate customer usage stream, and deduplicates delivery retries. UsageBox is the metering layer, not Google's price service or your invoicing system; your rating rules and invoice remain separate. This matters when an introductory rate expires: preserve the original usage and apply the correct effective-dated rate instead of overwriting history.

FAQ

When does Gemini 4 Argon API pricing double?

Google lists introductory API rates through November 30, 2026, with the new rates taking effect December 1, 2026. Verify the official price sheet again before finalizing a production budget.

Does Gemini 4 Argon charge for thinking tokens?

Yes. Google's output price explicitly includes thinking tokens. Measure the billed total rather than counting only visible reply text.

Is there a free Gemini 4 Argon API tier?

No. The model's official pricing table marks the free tier as unavailable.

Is Batch always the best deal?

It costs half the Standard list price for the same token volume, but only choose it for jobs that fit its processing model. User-facing latency requirements, throughput and retry policy may outweigh the discount.

Does Gemini 4 Argon support explicit prompt caching?

No. It supports implicit caching. Actual cache hits are measured, not assumed.

Sources and verification (October 17, 2026):

• Google - Gemini API pricing, all Argon service classes
• Google - What's new in Gemini 4 Argon and migration notes
• Google - Gemini 4 Argon launch announcement, October 13

Pricing is dated and subject to change. All example workloads are illustrative, not measured benchmarks or quotes.