Gemini 4 Argon API Pricing: Tokens and Search (2026)
Oct 15, 202614 min read
Google's pricing page is the source of record for them, and if you're wiring those costs into a budget or a workflow built in Activepieces, check the figures there first. A price I couldn't verify would mislead you more than a gap does.
Gemini 4 Argon pricing source and date
The price in one sentence
Per million tokens, with input and output metered as separate lines: that is how Google bills Gemini 4 Argon. The single headline rate tells you little until you know how many tokens each step reads and writes.
What Gemini 4 Argon is and token billing
You pay for tokens, counted once for what you send (prompt, attached context, instructions) and once for what comes back. Gemini 4 Argon is Google's flagship reasoning model.
That's why the useful question is which steps deserve a flagship at all. A six-step flow that calls Claude, ChatGPT and Perplexity in turn, with spreadsheet updates between them, shows the practical pattern.
Each step is a separate call with its own token count, so you can match each to a different model.
Activepieces makes that routing a per-step setting rather than a rewrite. The sections that follow price those steps one at a time.
Each step is a separate call with its own token count, so you can match each to a different model.
On 2026-10-14 I confirmed that Google's own model page lists Gemini 4 Argon as the flagship reasoning model.
If you are running this arithmetic for your own team, see what the same workload costs on Activepieces.
Gemini 4 Argon pricing tiers and limits
Pick any of the paid tiers Google sells Gemini 4 Argon in (Standard, Batch, Flex and Priority) and the table below reads "not published" for every cell I couldn't confirm, so some tier pricing isn't complete here.
Read those values off Google's pricing page and date them as above.
The pricing table
To see which tiers differ on price and which differ only on terms, read the table: it sets all four tiers against the seven dimensions that move your bill, which means you can separate pricing variation from feature variation.
Nothing here is a figure to budget from.
| Tier | Input $/1M | Output $/1M | Caching | Batch discount | Rate limits | Context breakpoints | Data-use terms |
|---|---|---|---|---|---|---|---|
| Free | not published | not published | not published | not published | not published | not published | not published |
| Standard | not published | not published | not published | not published | not published | not published | not published |
| Batch | not published | not published | not published | not published | not published | not published | not published |
| Priority | not published | not published | not published | not published | not published | not published | not published |
Fill each cell from the live page, because a blank in your own copy is a line item you haven't priced.
Free tier versus paid tiers
On every tier the token is the metered unit, counted separately for input and output, so a tier's real cost depends on how many of each your step sends.
Free access often comes with terms that let the provider use your prompts, so a free pilot on customer emails can turn into a compliance problem that no paid tier would have caused.
Rate limits by usage tier
Pick a model tier and you still don't control your limits, because your account's usage tier sets them. The cap that binds first is usually requests or tokens per minute, not price.
When a flow fans out hundreds of runs at once, it hits that ceiling and stalls or retries, which stretches a job that looked cheap on paper. Record your limits next to your rates and the date you read them.
Worked cost of 1,000 automation runs
$7.00 buys a thousand email summaries on Gemini 4 Argon, while a cheaper Gemini Flash model does the same thousand for about $2.63, making email summaries a domain where model choice saves substantial money.
A thousand ticket classifications cost $1.20 versus $0.45, and classifications thereby become another task where model choice drives costs significantly.
According to Google Cloud, Argon costs $2 per million input tokens and $10 per million output tokens, against $0.75 and $3.75 for the Flash model. Both rates run at 37.5% of Argon's, so every step costs about 2.7 times more on Argon.
Gemini 4 Argon cost of summarising an email
I assume 2,000 input tokens (a long thread) and 300 output tokens (a summary). On Argon that's $0.004 in plus $0.003 out, or $0.007 per run, so $7.00 per 1,000. On Flash it's $0.0015 plus $0.001125, about $2.63 per 1,000.
Make the summary chattier and the bill grows, though input is still the larger share of it.
I assume 500 input tokens and a 20-token label for classifying a support ticket. Argon costs $0.001 in plus $0.0002 out, so $1.20 per 1,000. Flash costs $0.000375 plus $0.000075, so $0.45 per 1,000.
Output is tiny here, so input length sets the price, and trimming the ticket text saves more than shortening the answer.
Gemini 4 Argon monthly cost at scale
Multiply by volume and the gap moves from cents to hundreds of dollars, whether you run 1,000, 10,000 or 100,000 runs a month, because at scale these per-task differences become major spending drivers.
At 100,000 runs, summaries cost $700 on Argon and $262.50 on Flash, so at volume your model choice alone determines whether this task costs under $300 or approaches $700 monthly. Classification costs $120 versus $45.
viz type=groupedbars title="Argon and Gemini Flash introductory prices, input and output" unit="$ per 1M tokens" source="Google Cloud - https://cloud.google.com/gemini-enterprise-agent-platform/generative-ai/pricing" cols="Gemini 4 Argon,Gemini 3.8 Flash"0, under half on both." Input: 2, 0.75 Output: 10, 3.75
Send a classifier to Argon and you spend $75 a month more for a label, and a classifier rarely needs Argon's reasoning.
Hidden costs and limits that inflate the bill
The Dec 1 output price change
On Dec 1, Argon's introductory output price of $10 per 1M tokens becomes $20, and that is the largest surprise here. Any budget built on today's rate doubles on the output side.
At either point, Argon costs about 2.7 times as much per output token as Gemini Flash, whose standard 2027 output rate is $7.50 and whose promo rate is $3.75.
Five meters that bill beside the headline rate
Beyond that, five meters bill separately from the headline rate, and each can outweigh it.
Google charges prompts above the model's long-context threshold a higher rate, so one oversized document can reprice the whole request. Reasoning bills as output, so a short answer can carry a long invoice.
On top of tokens, grounding costs $14 per 1,000 queries, or 1.4 cents each.
Cached context bills per hour it's kept, so a cache nobody reads still costs money. On Google's free tier, your prompts can be used to improve its products, which rules it out for customer data.
Keeping each meter in check
Ask a classification step for one word and it can still bill thousands of tokens of reasoning, because thinking tokens cost the output rate, which is $20 from Dec 1. Set a thinking limit on simple steps.
Just above the breakpoint, long-context cost climbs, and not gradually. Trim or split inputs that sit just over it.
Search on every run and the step adds 1.4 cents per run before any tokens, at $14 per 1,000 queries. Turn grounding on only where freshness matters.
When a flow is throttled, it slows down, and a retry after a timeout can bill twice if the first call still ran. Back off and deduplicate so a throttled burst doesn't become a double charge.
Worth checking against a plan that does not meter every step: one credit covers a whole run on Activepieces.
Gemini 4 Argon against the closest alternatives
Put Argon beside its rivals and they split into a $20-or-less output group and one outlier. Artificial Watch lists GPT-6 Astra at $50 per million output tokens, so a premium flagship isn't automatically the most expensive one.
Against the cheaper Gemini model
Gemini 3.8 Flash is Google's most intelligent Flash model, aimed at agents and software engineering. Gemini 3.5 Flash-Lite is the fastest and most cost-effective 3.5 model. Both are metered in the same tokens as Argon, so the saving comes from which step you send where.
For summarising an email or tagging a ticket, the answer is short and a Flash-class model handles that.
Gemini 4 Argon against OpenAI and Anthropic pricing
Read the table for what each rival charges per million output tokens.
| Model | Output, $ per 1M tokens |
|---|---|
| GPT-6 Astra | 50 |
| Claude Opus 5.5 | 20 |
| ChatGPT-5.6 | 20 |
| Claude Sonnet 5.5 | 10 |
| GPT-6.1 Sol | 10 |
| Grok 4.7 | 6 |
At $50, Astra costs 2.5 times Opus 5.5 on every generated token.
Opus 5.5 also charges $4 per million input tokens, so a 10,000-token prompt costs $0.04 before any output.
Sonnet 5.5 charges $2 for input and $10 for output, half of Opus on both. Sol matches Sonnet's $10 output price, and Grok 4.7 at $6 is the cheapest of the six.
Argon is worth its premium on demanding reasoning where one wrong answer triggers rework, such as multi-step analysis or agentic coding.
For high-volume steps that return a label or a short summary, a $6 to $10 output model, or a Flash tier, wins on cost with little loss in quality.
Cheapest passing model per step
Pick the cheapest model that clears your accuracy bar on a labelled sample of that step, and send only the steps that fail it to Gemini 4 Argon.
Test the step before choosing the tier
Every step is metered separately, per run and per token, so every step gets its own test. The list below is the order to work in, and it shows that the model choice comes from your own data, not from the price page.
- Label a sample of real inputs for the step, with the answer you would accept for each.
- Run each candidate model over that same sample.
- Score the outputs against an accuracy bar you set before seeing results.
- Pick the cheapest model that passes.
- Reserve Argon for steps where every cheaper model fails.
- Add caching and batch processing once the model is settled.
Last come caching and batch, because they lower the bill without changing the answer.
Cheap default model with Argon escalation for automation
Make the cheap model the default for a step and treat Argon as an escalation path.
If the cheap model returns a label outside your allowed set, fails a format check, or reports low confidence, resend that one input to Argon.
You then pay flagship rates only on the runs that need them, and the share of runs that escalate becomes a number you can measure and tune.
Fix model spend with Activepieces
A platform that resells you a model has already picked it and priced it, which leaves nothing to route by step.
Activepieces runs on the model you chose instead: connect your own Google key and Gemini spend is billed to your Google account at whatever rate Google charges you, while Claude, ChatGPT, Cursor or any MCP client can reach it.
Its Google Gemini integration is one of 741 on the integrations page, each AI step in a flow takes its own model, and MoneyGram, Moneypenny, Alan and FundingSocieties run it in production, so a classification step can call a cheap model while a later step reasoning over a long document calls Argon.
Nothing routes automatically, though. The routing rules, the escalation condition and the fallback stay the builder's design choices, and the labelled-sample test above is what should inform them.
Gemini 4 Argon cost pricing and guardrails
Once the labelled sample has told you which steps need Argon, the job this week is to price those steps in tokens, the unit you're billed on, and put guardrails around them. Do it in this order:
- Re-read the pricing page and note the date you read it, so any later bill can be checked against the rates in force.
- Log input and output token counts on a real sample of your own traffic.
- Set a billing budget and a quota alert in the Google Cloud console.
- Run the two-step cost test: the same sample through Argon alone, then through a cheaper model with Argon only on escalations.
- Schedule a re-check of the pricing page.
Measure real token use
Pull a few hundred genuine requests, not invented prompts, and record input and output tokens per run.
Real inputs carry signatures, quoted threads and pasted context that test prompts leave out, and output length is where a reasoning model most often surprises people.
Multiply those counts by the rates you noted, and you've got a cost per run that belongs to your workload.
Spend has crossed a line: that is all a budget alert tells you. A quota limits what can be consumed in the first place. Set both, with the alert below the quota, so a looping workflow trips a warning before it hits a hard stop.
Put a recurring calendar entry in the diary now, and compare the page against your dated note each time. Tiers and rates change, and your routing decisions are only as current as the numbers behind them.
Frequently asked questions
Because these are the details most likely to have shifted since you last checked the pricing page, each answer below is tagged with its source.
Free usage and thinking tokens
Is there a free tier for the Gemini 4 Argon API?
I can't confirm one for Argon. Google has offered free usage on some Gemini models in its developer tooling, but whether Argon has one, and under what limits, isn't something I verified.
Check the model's own pricing row before you build a prototype around free calls. Source: unverified.
Does Gemini 4 Argon charge for thinking tokens?
Treat reasoning tokens as billable output until the pricing page says otherwise. Earlier Gemini reasoning models counted thinking toward the output meter, so a short answer can still produce a long bill.
I didn't confirm Argon's treatment, so test with a single call and compare the usage metadata to the invoice line. Source: unverified for Argon.
Price changes and spend caps
How often does Google change Gemini API prices?
Often enough that a hardcoded rate in your cost model will go stale. Introductory pricing, preview-to-general-availability moves and tier changes have all altered the metered rate on past Gemini models.
If your routing depends on a price gap between two models, re-read both rows each quarter. Source: unverified as a schedule; the pattern is observed, not published.
Can I cap my monthly Gemini API spend?
To stop the calls you need a quota, because budget alerts only notify you of overspend, so set both. Google Cloud billing offers alerts, and request quotas can be lowered per project.
I didn't verify a hard dollar cutoff specific to Argon, so assume an alert alone won't halt a runaway loop. Source: unverified for Argon.
Is the API price the same as a Gemini app subscription?
No, they're separate products with separate meters. The app subscription is a flat plan for a person using a chat interface, while the API bills per token consumed by your code.
Subscribing doesn't lower your API invoice, and API usage doesn't count against the plan. Source: unverified on a single page, but the two are sold separately.
Related reading
References
Running the numbers
See what the same workload costs here.
Free forever plan, and every paid plan self-hosts at no extra cost.
See pricing Talk to sales
