Gemini 4 Argon Pricing: Real Costs Before and After Dec 1

Gemini 4 Argon pricing explained: $2/$10 until Nov 30, $4/$20 after, 95% off cached input, the 1M unified limit, and real per-call costs with a Python calculator.

By Sophie LinPricing Guides

Gemini 4 Argon pricing cover; editorial artwork, not a price chart

Our first three questions against an 11,059-token policy document each came back with cached_tokens: 0 and cost about $0.046 on SandBase. Then we resent one of them, word for word. That call reported 9,005 cached tokens and cost $0.0113, a quarter of the price. For most Argon workloads, that gap will move your bill more than the introductory discount does.

This guide to Gemini 4 Argon pricing is for developers budgeting real traffic: the December 1 rate change, the 95% cached-input discount, what the 1M unified limit means for long outputs, and per-call costs billed by GET /v1/tasks/<id>/cost, not estimated. All tests ran on SandBase on 2026-10-14 between 18:29 and 18:35 UTC.

Key takeaway

  • Google charges $2 per million input tokens and $10 per million output tokens through November 30, 2026, then $4 / $20 from December 1. Cached input is 95% off; Google states the discount with the intro rate and doesn’t restate it for the standard rate.
  • SandBase lists google/gemini-4-argon at $4 / $20 today, with cached reads at $0.20 per million. That equals Google’s post-November rate and is 2x Google’s direct intro rate.
  • Measured on SandBase: $0.0018 per chat turn, $0.0455 per 11K-token RAG question ($0.0113 with 9,005 cached tokens), $0.196 for 9,789 output tokens.
  • In 12 calls, cache hits showed up only when we resent an identical request (5 of 5). New questions over the same document missed (4 of 4). Budget with a hit rate you measure.
  • Artificial Analysis spent $1.99 per Intelligence Index task on Argon at the $2 / $10 rate. At $4 / $20 the same tokens cost about $3.98, more than Claude Opus 5.5 (Xhigh) at $3.46.

Gemini 4 Argon pricing: the three rates you’ll see

Two Google prices, one SandBase price, and they differ only until November 30. Google’s Cloud launch post (October 13, 2026) states both periods; Google’s announcement gives the intro price and cache discount, with $4 / $20 in a regional footnote.

RateInput / 1MCached input / 1MOutput / 1MApplies
Google direct, intro$2.00$0.10$10.00Oct 13 to Nov 30, 2026
Google direct, standard$4.00$0.20 (assumed)$20.00From Dec 1, 2026
SandBase list (google/gemini-4-argon)$4.00$0.20$20.00Now; no intro period

Google Cloud blog paragraph: Argon at $2 / $10 through November 30, 2026, then $4 / $20, cached input 95% off

Google Cloud’s launch post gives both price periods and the 95% cached-input discount in one paragraph, under model ID gemini-4-argon (captured 2026-10-14 UTC).

Plainly: until November 30, Argon via SandBase costs twice Google’s direct price. From December 1 they match. What SandBase adds is one key and one OpenAI-compatible endpoint across Argon, Claude and GPT, not a lower Argon price. If Argon is your only model and the budget is tight before December, go direct.

Google states the cache discount only alongside the intro rate; we assume it carries over to $0.20, SandBase’s rate today. Google gives no cache-write or storage price either. The SandBase card lists a cache_read_multiplier of 0.05 and no write multiplier, and none of our calls reported cache_write_tokens above 0.

SandBase Gemini 4 Argon model page: $4.00 input, $20.00 output, 1M context, 65.5K max output

The SandBase model page lists Argon at $4.00 / $20.00 per million tokens with a 65.5K max output, the cap that matters for long-output budgets (captured 2026-10-14 UTC).

How Argon’s list price compares on SandBase

Per token, Argon is a mid-priced flagship. SandBase list prices from GET /v1/models/<id> on 2026-10-14; cached input is input price × the card’s cache_read_multiplier.

ModelInput / 1MCached input / 1MOutput / 1M
Gemini 4 Argon$4.00$0.20$20.00
Claude Opus 5.5$4.00$0.20$20.00
Claude Sonnet 5.5$2.00$0.20$10.00
Claude Fable 5.1$10.00$0.25$50.00
GPT-6 Astra$10.00$1.00$50.00
GPT-6.1 Sol$2.00$0.10$10.00
GPT-6 Luna$0.10$0.01$0.50
Gemini 3.1 Pro preview$2.00$0.20$12.00
Gemini 3.8 Flash$1.50$0.15$7.50

The OpenAI models and Gemini 3.1 Pro preview move to a higher rate above 272K or 200K prompt tokens; Argon has one tier. Argon and Opus 5.5 share a rate exactly, so between them, tokens spent decide the bill.

Cost per task: what an independent eval run spent

The best public proxy for token appetite is what Artificial Analysis spent per Intelligence Index task. Data: Artificial Analysis, Intelligence Index v4.3, data as of 2026-10-12 (free-tier snapshot); rows are model × effort settings, measured configuration “Gemini 4 Argon (High)”. Full rankings are in our Argon benchmark leaderboard article.

Configuration (AA)Intelligence IndexAA price in / outCost per index task
Claude Opus 5.5 (Max)57.6$4 / $20$5.98
Claude Opus 5.5 (Xhigh)56.0$4 / $20$3.46
Claude Opus 5.5 (High)53.6$4 / $20$1.82
GPT-6 Astra (Max)52.7$10 / $50$3.26
Gemini 4 Argon (High)52.6$2 / $10$1.99
GPT-6 Astra (Xhigh)52.4$10 / $50$2.31
Claude Sonnet 5.5 (Xhigh)51.9$2 / $10$2.01
GPT-6.1 Sol (Max)51.8$2 / $10$0.72

The catch is in the third column. AA priced Argon at the intro rate. Every Argon price in its snapshot doubles on December 1, so the same tokens would cost about $3.98 per task. That flips the picture: at $1.99, Argon is the second-cheapest of the nine AA configurations scoring 52 or higher; at $3.98 it costs more per task than Opus 5.5 (Xhigh), which scored 56.0, and twice Opus 5.5 (High), which scored 53.6 at the same per-token price.

Argon is also a heavy token user: GPT-6.1 Sol (Max), same $2 / $10 rate, 0.8 points lower, cost $0.72 per task, so Argon (High) spent roughly 2.8x the tokens. Index tasks aren’t your tasks (methodology), but check this before assuming $2 / $10 means cheap.

SandBase Lab intelligence leaderboard with Gemini 4 Argon (High) at 52.6 in fifth place

The SandBase Lab intelligence board, built on Artificial Analysis data, places Gemini 4 Argon (High) at 52.6, fifth among the 87 SandBase-listed models it ranks; the Lab uses a 2026-10-14 snapshot (captured 2026-10-14 UTC).

SandBase Lab cost per task leaderboard, 15 cheapest of 55 models, $0.053 to $0.265 per task

The Lab cost-per-task board sorts cheapest first; its 15th row is $0.265 per task, so Argon’s $1.99 sits well outside the budget tier even at intro pricing (captured 2026-10-14 UTC).

Worked examples: chat, RAG and a long-output job

Each row is a real SandBase call. Tokens come from the response’s usage block; the SandBase column equals the amount billed by /v1/tasks/<id>/cost. The intro column prices the same tokens at $2 / $10.

Job (measured 2026-10-14 UTC)Input tokens (cached)Output tokensGoogle introGoogle from Dec 1 / SandBase
Chat turn, 2-sentence answer66 (0)78$0.000912$0.001824
RAG question, 11K-token prefix, miss11,059 (0)65$0.022768$0.045536
RAG question, same request resent11,059 (9,005)63$0.005639$0.011277
Long output: Python module + tests86 (0)9,789$0.098062$0.196124

The math for the cached RAG call, at $4 / $20: (11,059 − 9,005) × $4/M = $0.008216 for fresh input, 9,005 × $0.20/M = $0.001801 for cached input, 63 × $20/M = $0.001260 for output. Total $0.011277, which is exactly what /cost billed.

Scaled to a month (projection, not measurement):

Monthly volume (projection)Google introFrom Dec 1 / SandBase
Hobby: 3,000 chat turns like row 1$2.74$5.47
Startup: 50,000 RAG questions, 0% cache hits$1,138$2,277
Startup: 50,000 RAG questions, 50% hits$710$1,420
Team: 2,000 long-output jobs like row 4$196$392

The RAG rows are where planning goes wrong. A 50% hit rate saves 38%; every call hitting saves 75%. Our runs say you can’t assume either.

Cached input: what actually hit

Nine of our calls used the same 11,059-token system prompt (240 numbered policy clauses). The record:

  • First sends of four distinct questions (three within 20 seconds, one about two minutes later): cached_tokens: 0 every time.
  • Five resends of a question we’d already asked, 20 seconds to under three minutes after the first send: 9,005 or 9,006 cached tokens every time, about 81% of the prompt.
  • Two resends wrapped the system prompt in an Anthropic-style cache_control block. They hit like the plain ones; the marker changed nothing visible.

Why new questions missed, we can’t say: cache keying, routing and warm-up are all plausible. One day of observations, not a rule. Log prompt_tokens_details.cached_tokens on every call for a week and budget with that hit rate, not with 95% off everything.

The 1M unified limit and output-heavy jobs

Google describes Argon’s limit as a 1M “unified input-output token limit via the Gemini API”, and the model card says the combined input plus output context goes up to 1M tokens. Two cost consequences follow.

Input and output share one budget, so a 700K-token document leaves at most 300K for the answer. And output costs 5x input: one Google-direct call with 200K in and 800K out would cost $8.40 at the intro rate and $16.80 from December 1, $16 of it output. Google also mentions a “continuation protocol”; we couldn’t reach its docs, so we don’t price it.

SandBase is different today. The model page lists a 65.5K max output and the schema caps max_tokens at 65,536, so a single SandBase response tops out around $1.31 in output ($0.66 at intro-equivalent rates). A max_tokens: 100000 request on a “Say OK.” prompt returned HTTP 200 with a 6-token answer: not rejected, but that doesn’t show whether a long answer would be cut at 65,536. Plan on 65.5K output per call at most.

Our long-output call asked for a Python key-value store with TTL, LRU eviction, JSON snapshots and 40+ unit tests. It returned 9,789 output tokens in 70.7 seconds with finish_reason: stop, for $0.196; the module’s 42 tests all passed locally. One run, but a useful unit: about $0.20 per 10K output tokens on SandBase, $0.10 at Google’s intro rate.

Open question: SandBase says Argon always reasons, yet all 12 calls reported reasoning_tokens: 0. In our Python tutorial, a harder math prompt did report reasoning tokens, counted inside completion_tokens and billed at the output rate. Either way, completion_tokens is the number you’re billed on.

A Python cost calculator, checked against real bills

This prices one call from the usage block the API returns. prompt_tokens includes cached tokens, the convention SandBase’s billing follows.

"""Gemini 4 Argon cost calculator (prices as of 2026-10-15, USD per 1M tokens)."""
CACHE_READ_FACTOR = 0.05  # cached input is 95% off the input rate
RATES = {
    "google-intro": (2.00, 10.00),     # Google direct, through Nov 30, 2026
    "google-standard": (4.00, 20.00),  # Google direct, from Dec 1, 2026
    "sandbase": (4.00, 20.00),         # SandBase list price for google/gemini-4-argon
}


def argon_cost(prompt_tokens: int, completion_tokens: int, cached_tokens: int = 0,
               rate: str = "sandbase") -> float:
    """Cost of one call. prompt_tokens includes cached_tokens, as in the API's usage block."""
    if not 0 <= cached_tokens <= prompt_tokens:
        raise ValueError("cached_tokens must be between 0 and prompt_tokens")
    price_in, price_out = RATES[rate]
    fresh = prompt_tokens - cached_tokens
    return (fresh * price_in
            + cached_tokens * price_in * CACHE_READ_FACTOR
            + completion_tokens * price_out) / 1_000_000


if __name__ == "__main__":
    # usage blocks copied from real SandBase responses on 2026-10-14 (UTC)
    runs = {
        "chat turn": (66, 78, 0),
        "RAG, cache miss": (11059, 65, 0),
        "RAG, cache hit": (11059, 63, 9005),
        "long output": (86, 9789, 0),
    }
    for name, (p, c, k) in runs.items():
        row = {r: round(argon_cost(p, c, k, r), 6) for r in RATES}
        print(f"{name:16} {row}")

To check it against a bill, pass the id from a POST https://api.sandbase.ai/v1/chat/completions response to GET /v1/tasks/<id>/cost with the same Bearer key (Chat Completions guide). For the cached RAG call (6a4939b2-b988-4dc1-87b4-3449767e7d93) the endpoint returned, trimmed:

{"status": "completed", "settled": true, "currency": "USD", "cost": "0.011277",
 "usage": {"prompt_tokens": 11059, "completion_tokens": 63, "cached_tokens": 9005,
           "cache_creation_tokens": 0, "reasoning_tokens": 0}}

The calculator’s sandbase figure matched the billed cost for all 12 calls, including all five with cached tokens. Total spend for this article’s tests: $0.4366.

Cutting the Argon bill

  • Keep the cacheable prefix byte-identical, document first and question last, then check cached_tokens.
  • Set max_tokens to what the job needs. A runaway 65K answer costs $1.31 on SandBase.
  • Route cheap turns elsewhere. GPT-6.1 Sol lists at $2 / $10 on SandBase; GPT-6 Luna costs a fortieth of Argon.
  • Going direct to Google? Run evaluation and backfill jobs before November 30, at half price.
  • Add a $4 / $20 column to any budget built on $2 / $10.

For calling Argon (streaming, response_format, finish_reason), see the Argon Python API tutorial; for whether it’s worth its price over Opus 5.5 or GPT-6 Astra, the three-way comparison. Our pre-launch Argon post has background from before general availability.

FAQ

How much does Gemini 4 Argon cost?

Through Google directly, $2 per million input tokens and $10 per million output tokens through November 30, 2026, then $4 / $20 from December 1. Cached input is 95% off (stated with the intro rate). On SandBase it’s $4 / $20 now, with cached reads at $0.20 per million.

Is Gemini 4 Argon cheaper on SandBase than on Google?

No. Until November 30, SandBase’s $4 / $20 is double Google’s intro rate. From December 1 the rates match.

Can I get 1M output tokens from Argon on SandBase?

No. SandBase lists a 65.5K max output per response. Google’s 1M figure is a unified input plus output limit on the Gemini API.

Does the 95% cache discount apply automatically?

It applied with no extra parameter when we resent identical requests: 9,005 of 11,059 input tokens billed at the cached rate. New questions over the same prefix didn’t hit in our tests.

Limitations

These are 12 calls from one account on one day, with short prompts and one synthetic document. Cache behavior may change. Doubling AA’s per-task cost assumes the same tokens. We didn’t test Google direct, the continuation protocol, or a response above 9,789 output tokens. Prices are as of 2026-10-14 UTC; check the Argon model page before you commit a budget.