# Gemini 4 Argon pricing: calculate the cost of a request

By SeedRouter · Published 2026-10-14 · Updated 2026-10-14

Gemini 4 Argon pricing has three quantities worth tracking: ordinary input, cached input and output including thinking. A short visible answer can still use a substantial output budget. A longer conversation also resends earlier messages, so the cost of turn ten need not resemble turn one.

This guide explains how to estimate a request from its reported usage and how to set a budget before sending it. The table below is SeedRouter's current billing-rate snapshot. Google's published list price and a Google AI subscription are separate things; neither should be substituted for the rates on your account.

## Current Gemini 4 Argon pricing

USD per 1M tokens

| USD per 1M tokens | googlellm | googlellm-vertext |
| --- | --- | --- |
| Input | $0.80 | $1.00 |
| Output, including thinking | $4.00 | $5.00 |
| Cached input | — | — |

Cached tokens are part of input, not additional input. Each continuation request has its own usage. Failed requests are not charged.

Blog rates refresh periodically. For the latest model-page snapshot and the standard request example, open [Gemini 4 Argon pricing](https://seedrouter.ai/models/gemini-4-argon#pricing). If pricing is unavailable, wait for a fresh table before estimating a bill; a missing rate does not mean a free request.

Google describes its introductory pricing period as ending on November 30, 2026. That date concerns Google's own published offer. It does not establish a future SeedRouter price. Check the [official announcement](https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-argon/) for the offer and the table above for the account rates used here.

## Calculate a request without counting cache twice

Use the native `usageMetadata` fields, rather than estimating tokens from the number of words displayed:

| Symbol  | Usage value                                   | Meaning                                             |
| ------- | --------------------------------------------- | --------------------------------------------------- |
| P       | `promptTokenCount`                            | All reported prompt tokens, including cached tokens |
| C       | `cachedContentTokenCount`                     | The cached portion of that input                    |
| O       | `candidatesTokenCount` + `thoughtsTokenCount` | Answer and thinking tokens                          |
| I, R, U | Input, cached-input and output rates above    | USD per million tokens                              |

The request estimate is:

```text
cost = ((P - C) * I + C * R + O * U) / 1,000,000
```

Cached input is already part of the prompt total. Charging all of P at the ordinary rate and then adding C again counts it twice. Likewise, charging only the visible candidate text misses thinking. Google documents these counters in its [token guide](https://ai.google.dev/gemini-api/docs/generate-content/tokens); the [API reference](https://seedrouter.ai/docs/gemini-4-argon) explains how SeedRouter uses the native response.

Treat omitted counters as zero only when the completed response establishes that no such usage was reported. If the connection ends before usage arrives, the amount is unknown from that response. Check your account's usage record instead of displaying a zero-cost success.

## Three worked token budgets

These are illustrative token counts, not measurements of a particular prompt. Substitute the rates from the live table for I, R and U.

| Example                               | Ordinary input | Cached input | Output including thinking | Cost expression                     |
| ------------------------------------- | -------------: | -----------: | ------------------------: | ----------------------------------- |
| Short request                         |          2,000 |            0 |                     1,000 | `0.002 * I + 0.001 * U`             |
| Repeated document, cache hit reported |         10,000 |       40,000 |                     2,000 | `0.010 * I + 0.040 * R + 0.002 * U` |
| Same document, no cache hit           |         50,000 |            0 |                     2,000 | `0.050 * I + 0.002 * U`             |

The second and third examples have the same 50,000-token prompt and output size. Their cost difference is `0.040 * (I - R)`. This isolates the effect of caching without pretending every repeated document will receive a cache hit.

For a monthly estimate, multiply each request class by its expected number of requests, then add the classes. Include follow-up turns and continuations. A plan based only on the number of users misses how differently those users work: one may ask a short question, while another repeatedly sends a large document.

## Thinking and context affect the budget differently

Argon shares 1,048,576 tokens across input, thinking and output. That is a capacity limit, not a promise to generate that many answer tokens. `maxOutputTokens` includes thinking, so setting it to 1,024 does not promise 1,024 tokens of visible text. The model may spend some or most of the allowance reasoning. See Google's [native generation guide](https://ai.google.dev/gemini-api/docs/generate-content/latest-model).

Use `thinkingLevel` to choose `low`, `medium` or `high`; the default is `medium`. Start with a level appropriate to the task, then evaluate whether a higher setting improves the result enough to justify its measured cost. There is no fixed multiplier from a thinking level to a bill.

For a single ordinary request, an output budget B gives an output-cost allowance of `B * U / 1,000,000`. Add estimated input costs separately. Tool-specific charges, where applicable, require their own budget and verification; they are not covered by this basic text formula.

## Conversations and continuation are different

A follow-up conversation sends earlier user and model turns as history. Those tokens become input to the new request. Store complete native content, including signatures, rather than recreating history from the visible answer alone. The [Python streaming tutorial](https://seedrouter.ai/blog/gemini-4-argon-api) demonstrates that flow.

Long decode instead resumes the same generation from an opaque continuation token. Google's [long-decode guide](https://ai.google.dev/gemini-api/docs/generate-content/long-decode) requires the original request and the latest token; partial output must not be appended as a new conversation turn. Each raw request has usage. Sum completed request records once, and do not add a combined SDK total on top of those same records.

SeedRouter's basic text streaming has passed a local end-to-end check. Long decode and advanced operations still require separate capability verification. This article explains the budget rules, not a claim that every operation has been exercised successfully.

## Budget questions

### Is Gemini 4 Argon free with Google AI Pro?

App access and API billing are separate. The [access guide](https://seedrouter.ai/blog/gemini-4-argon-release-date) distinguishes Gemini App, Antigravity and API access. A consumer subscription does not establish a free SeedRouter API allowance.

### Does a cache hit make the whole request cheaper?

It reduces the charge for the cached input portion. New input and generated output keep their own rates. Check the actual cached-token count; repeating text alone is not evidence of a hit.

### Why does the bill exceed the visible answer's token cost?

Thinking is billed as output, and the prompt is billed too. Compare all usage counters with the rate table before treating the difference as a billing error.

## Build the budget from usage

For Gemini 4 Argon pricing, keep the rate snapshot, ordinary input, cached input and total output together. Estimate with explicit token assumptions, then replace those assumptions with completed-request usage. Use the [Playground](https://seedrouter.ai/models/gemini-4-argon#playground) for your own task and compare models with the [Opus 5.5 guide](https://seedrouter.ai/blog/gemini-4-argon-vs-claude-opus-5-5) when choosing where to spend the budget.