Gemini 4 Argon API Pricing Guide (2026): What the December 1 Price Doubling Means

Google launched Gemini 4 Argon on October 13, 2026. The launch got the headlines. The pricing page, as it reads today on October 26, 2026, got far less attention, and it holds the number that matters for your budget: Argon costs $2 per million input tokens and $10 per million output tokens only through November 30, 2026. On December 1 it becomes $4 and $20.

That's a 100% increase, seven weeks after launch. Trade coverage flagged the date on October 24, but plenty of teams are wiring Argon into agents with a cost model that expires in about five weeks.

What Google Actually Published

Every paid tier doubles on the same date, not just Standard. Batch and Flex go from $1/$5 to $2/$10. Priority goes from $3.60/$18 to $7.20/$36. Cached input doubles too. Here's the full table, in USD per 1M tokens, straight from the pricing page.

A few details people miss. Argon isn't on the Free tier at all. Caching is implicit only, so you can't pin a prefix with explicit caching, and the page lists no separate cache-write fee. And this isn't a one-off: Gemini 3.8 Flash Standard also goes from $0.75/$3.75 to $1.50/$7.50 on January 1, 2027. Google's pattern is an introductory price followed by a doubling. Plan for it.

What the Doubling Does to a Real Bill

Take a mid-sized coding-agent workload: 100 million input tokens and 20 million output tokens a month, no caching. Output is 17% of the tokens but half the cost, because it's priced at 5x input.

Add caching at a 60% hit rate and Argon lands near $286 a month before the change and $572 after. Caching doesn't save you, because the cached rate doubles too.

The Real Cost Lever: Thinking Tokens

Argon bills thinking tokens as output. At $10 (soon $20) per million, a model that thinks hard on every request can quietly cost more than the answer it writes. The control is thinking_level, which takes low, medium (the default), or high.

Google's own advice is to run your evals at all three levels and pick the lowest one that clears your quality bar. I'd go further: pin the level explicitly in every call. Relying on the default invites a surprise invoice.

One trap. Don't try to save money by squeezing max_output_tokens. It caps thinking and answer together, so a low limit truncates the response rather than making the model think less. Google tells apps with limits under 32K to raise them to at least 32,768 and lower the thinking level instead.

curl "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -X POST \
  -d '{
    "model": "gemini-4-argon",
    "input": "Summarize the failure modes in this retry loop and propose a fix.",
    "generation_config": {
      "thinking_level": "low",
      "max_output_tokens": 32768
    }
  }'

Argon vs the Alternatives

At $2/$10, Argon was an easy model to trial. At $4/$20 it's priced like Claude Opus 5.5, and it has to beat $2/$10 models on your tasks by enough to justify paying double. Here's the field, with prices as of October 26, 2026.

My take: if you need a single answer longer than 64K tokens, or you're feeding it video, Argon's feature set is hard to replace and the new price is a cost of doing business. If you're using it as a general coding or agent model, the December 1 date is a natural checkpoint to re-test cheaper options. Don't settle it with a leaderboard. Run your own prompts.

A Cost Estimator You Can Paste Today

Put numbers on your own traffic first. This script prints monthly cost per plan from token volumes (in millions) and a cache hit rate. It ignores Sonnet's cache-write fee, so treat that row as a floor.

# Prices in USD per 1M tokens (Google and Anthropic pricing pages, Oct 26, 2026)
PRICES = {
    "argon_through_nov30": {"in": 2.00, "cached": 0.10, "out": 10.00},
    "argon_from_dec1":     {"in": 4.00, "cached": 0.20, "out": 20.00},
    "sonnet_5_5":          {"in": 2.00, "cached": 0.10, "out": 10.00},
}

def monthly_cost(plan, in_millions, out_millions, cache_hit=0.0):
    p = PRICES[plan]
    fresh = in_millions * (1 - cache_hit)
    cached = in_millions * cache_hit
    return round(fresh * p["in"] + cached * p["cached"] + out_millions * p["out"], 2)

for plan in PRICES:
    print(plan, monthly_cost(plan, in_millions=100, out_millions=20, cache_hit=0.6))

Run a Real A/B Before December 1

Five weeks is enough time to measure instead of guess. Send the same 50 production prompts to Argon and to a $2/$10 model, score the outputs, and compare cost per accepted answer rather than cost per token. For the non-Google side, a gateway like KissAPI puts Claude Sonnet 5.5 and GPT-6.1 Sol behind one OpenAI-compatible endpoint, so you don't need separate vendor accounts for the test. Call Argon directly through Google's API with the curl shape above.

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.KISSAPI_KEY,
  baseURL: "https://api.kissapi.ai/v1",
});

const PRICE = { // USD per 1M tokens
  "claude-sonnet-5-5": { in: 2, out: 10 },
  "gpt-6.1-sol": { in: 2, out: 10 },
};

async function run(model, prompt) {
  const r = await client.chat.completions.create({
    model,
    messages: [{ role: "user", content: prompt }],
  });
  const u = r.usage;
  const cost =
    (u.prompt_tokens * PRICE[model].in + u.completion_tokens * PRICE[model].out) / 1e6;
  return { model, cost, text: r.choices[0].message.content };
}

const prompt = "Find the race condition in this retry loop and rewrite it safely: ...";
for (const model of Object.keys(PRICE)) {
  const { cost, text } = await run(model, prompt);
  console.log(model, "$" + cost.toFixed(5), text.slice(0, 80));
}

Want to size the budget first? The token counter and the API cost calculator take your real prompts and give you a monthly number in a minute.

What I'd Do Before December 1

1. Log thinking tokens separately. If you can't see how much of your output bill is reasoning, you can't tune it.
2. Pin thinking_level in code. Start at low, and promote a task to medium only when evals show a gap.
3. Move non-urgent work to Batch or Flex. From December 1 they cost $2/$10, which is exactly what Standard costs today.
4. Make the model a config value. Switching on December 1 should be an environment variable, not a deploy.

Frequently Asked Questions

How much does the Gemini 4 Argon API cost per million tokens?

On the Standard paid tier, Gemini 4 Argon costs $2 per 1M input tokens and $10 per 1M output tokens (including thinking tokens) through November 30, 2026. From December 1, 2026 it costs $4 per 1M input tokens and $20 per 1M output tokens. Cached input is $0.10 per 1M tokens before that date and $0.20 after.

Does Gemini 4 Argon have a free tier?

No. Google's Gemini API pricing page states that Gemini 4 Argon is not available on the Free tier, so every request is billed on the paid tier.

How can I reduce Gemini 4 Argon costs after December 1, 2026?

Lower the thinking_level from the default medium to low where quality allows, move non-urgent jobs to the Batch or Flex tiers ($2 input and $10 output per 1M tokens from December 1, 2026), keep a stable prompt prefix so implicit caching hits, and route simpler requests to models that list at $2 input and $10 output per 1M tokens, such as Claude Sonnet 5.5 or GPT-6.1 Sol.