Gemini 4 Neon Pricing: What a Task Costs at Each Thinking Level
Gemini 4 Neon API pricing explained: $3/$15 per 1M tokens, cache, Batch and Priority rates, Search fees, and per-task cost from low to xhigh thinking, with a tested calculator.
Gemini 4 Neon costs $3.00 per million input tokens, $0.15 per million cached input tokens and $15.00 per million output tokens on Google’s Standard paid tier, with thinking tokens billed as output. There is no free tier. The thinking level decides most of what a task actually costs: on Artificial Analysis’s benchmark tasks, Neon averaged about $0.75 per task at low, $1.90 at medium, $3.74 at the default high and $6.44 at xhigh. The per-token price is the same at every level. What changes is how many tokens the model reads and writes before it finishes.
This guide covers every Neon rate Google publishes, explains why a per-token price is not a per-task price, and gives a small Python calculator with three worked workloads priced against Gemini 4 Hydrogen and Gemini 4 Carbon (before and after Carbon’s December 1 increase).
Ofox publishes this article. All prices are Google Gemini Developer API list prices in USD, checked against Google’s live pricing page on November 19, 2026. Gemini 4 Neon is not available through Ofox as of that date (our authenticated GET /v1/models check returned google/gemini-4-argon and google/gemini-4-hydrogen, but no Neon or Carbon). Nothing here is an Ofox price. We did not call Neon for this article: the per-task figures come from Artificial Analysis, and the workload examples are our own calculations on synthetic token counts.
Gemini 4 Neon API prices by service tier
Google’s Neon pricing table lists four inference tiers. Every rate is USD per 1,000,000 tokens.
| Service tier | Input | Cached input | Output (including thinking) |
|---|---|---|---|
| Standard | $3.00 | $0.15 | $15.00 |
| Batch | $1.50 | $0.075 | $7.50 |
| Flex | $1.50 | $0.075 | $7.50 |
| Priority | $5.40 | $0.27 | $27.00 |
A few conditions sit next to these numbers on Google’s pages:
- No free tier. The pricing page marks every Neon row “Not available” for the Free tier, and the Neon developer guide says the model is on the paid tier of the Gemini API only. You need a billing-enabled project.
- Flat across the context window. Google describes Neon as using “flat pricing across the full 1M context window.” There is no higher rate for prompts above 200k tokens, which some earlier Gemini models had. The window is 1,048,576 tokens, shared by input, thinking and output.
- Thinking is output. The output row is labelled “including thinking tokens.” A response with 2,000 visible tokens and 30,000 thinking tokens is billed as 32,000 output tokens.
- Hidden input is still input. Google counts “internal tool system instructions and function declarations when using grounding” as billable tokens. Your own prompt is not the whole input.
- Cached input is implicit only. Explicit caching (
cachedContents,caches.create) is not supported on Neon, so there is no cache-storage fee to add. The $0.15 rate applies only to tokens that actually hit the implicit cache.
Batch and Flex halve all three token rates. Priority costs 1.8 times Standard. Those are the only differences the price table shows. It does not tell you the turnaround time of Batch, how often Flex requests are shed, or how much latency Priority saves for your traffic; check Google’s optimization guide before moving a time-sensitive workload.
Tool charges that sit on top of tokens
| Tool | How Google bills it for Neon |
|---|---|
| Grounding with Google Search | 5,000 free search requests per month, shared across all Gemini 3 and newer models, then $14 per 1,000. Each individual search query the model runs is charged, and one of your requests can trigger several. Default cap of 1,500 grounded requests per day per project on the Gemini Developer API. |
| Grounding with Google Maps | 5,000 requests per month free (same sharing rule), then $14 per 1,000 queries |
| Code execution | No separate fee. Generated code and results are billed as output when created and as input when the model reads them back |
| URL context | Charged as input tokens |
| File search | Embedding charges plus retrieved tokens at Neon’s token rates |
The Search and Maps rows appear in Neon’s Standard and Priority tables. The Batch and Flex tables list no Search price, so the calculator below refuses to price billable searches on those tiers rather than guess.
Why the price per token is not the price per task
A task is everything the model processes until you have an accepted result. For one request:
request_cost = (uncached_input × input_rate
+ cached_input × cached_rate
+ output_incl_thinking × output_rate) / 1,000,000
task_cost = sum(request_cost for every request in the task)
+ billable_search_queries × $0.014
uncached_input is total input minus the cache-hit portion, so cached tokens are never charged twice. “Every request in the task” includes agent turns, tool round trips and retries that failed your acceptance check.
Two things make this sum much larger than the per-token price suggests.
Thinking multiplies output. Google’s guide describes low as “fewest tokens, lowest latency” and xhigh as “most tokens, deepest reasoning.” On Artificial Analysis’s tasks (table below), Neon averaged about 21,700 output tokens per task at low and 141,600 at xhigh. Same price per token, 6.5 times the tokens.
Agents re-read their context. Every turn of an agent loop sends the conversation so far as input. Artificial Analysis’s per-task cost breakdown for Neon at xhigh implies roughly 12 million input tokens per task, of which about 11 million were cache hits. On that workload, input cost more than output even though the output rate is five times higher.
Cost per task at low, medium, high and xhigh
Artificial Analysis runs its Intelligence Index evaluations at each Neon thinking level and reports cost per task at Google’s list prices (for Neon, the current $3/$15 rate; the Carbon caveat is in the next section). We checked the page on November 19, 2026. Its visible text states the xhigh figure ($6.44); the other levels come from the cost-breakdown data the same page uses for its charts. We saved the extracted values with the article’s research files.
| Neon thinking level | AA Intelligence Index | Cost per task | Input share of cost | Output tokens per task | Time per task |
|---|---|---|---|---|---|
low | 44.1 | $0.75 | 56% | ~21,700 | 3.7 min |
medium | 54.9 | $1.90 | 61% | ~50,000 | 8.3 min |
high (default) | 59.6 | $3.74 | 64% | ~90,200 | 14.8 min |
xhigh | 61.4 | $6.44 | 67% | ~141,600 | 21.5 min |
Source: Artificial Analysis, checked 2026-11-19. Third-party benchmark averages, not Google figures and not our measurements.
What the table says, read narrowly:
- Low to xhigh is an 8.6× cost range at one per-token price. Model choice is only half of a Neon budget; the thinking setting is the other half.
- High to xhigh is the expensive step. It adds about 72% to cost per task ($3.74 to $6.44) and about 45% to time, for 1.8 index points. Google’s own guidance matches this: start at
highand reservexhighfor hard multi-step problems wherehighfalls short. - Medium to high roughly doubles cost for 4.8 index points. If your task passes at
medium, that saving is real. - Low is cheap but much weaker on this index (44.1 versus 59.6 at
high). A cheaper attempt that fails and has to be rerun at a higher level costs both attempts. - Input dominates in agentic work. Between 56% and 67% of each task’s cost was input. By token count most of that input was cache hits, but by cost the larger part was input billed at the full $3 rate: Artificial Analysis’s breakdown at
xhighshows $2.59 under its “cache write” label (new prompt tokens, which Neon bills at the ordinary input rate), $1.66 for cache reads and $0.06 for other uncached input. A chat app with short prompts and long answers will look very different: there, output and thinking dominate.
The last point is the main limit of these numbers. The Intelligence Index is a mix of reasoning, knowledge and agentic tasks. Your workload has its own input-to-output ratio, cache-hit rate and acceptance bar. Use the table to see how the levels scale relative to each other, then measure your own tasks.
Neon vs Hydrogen vs Carbon on the same arithmetic
Comparing list prices alone gives a misleading answer, because the models consume different numbers of tokens for the same task. A fairer basis is to take each model’s per-task token profile from Artificial Analysis and price it at Google’s current rates.
One detail matters here. Artificial Analysis priced Carbon at $4/$20 (the rate that starts December 1) but Argon at $2/$10 (the current rate). Through November 30, Google charges $2/$10 for both. Because every Gemini 4 token rate scales linearly, we recovered the token counts from Artificial Analysis’s cost components and repriced them for both periods. The test suite checks that this recovery reproduces Artificial Analysis’s own totals.
| Model and level | AA Index | Cost per task through Nov 30 | Cost per task from Dec 1 |
|---|---|---|---|
Neon low | 44.1 | $0.75 | $0.75 |
Neon medium | 54.9 | $1.90 | $1.90 |
Neon high | 59.6 | $3.74 | $3.74 |
Neon xhigh | 61.4 | $6.44 | $6.44 |
Hydrogen high | 50.8 | $1.87 | $1.87 |
Hydrogen xhigh | 53.9 | $3.16 | $3.16 |
Carbon low | 54.2 | $3.59 | $7.19 |
Carbon medium (default) | 58.3 | $3.29 | $6.59 |
Carbon high | 60.0 | $3.88 | $7.76 |
Argon high | 50.4 | $4.97 | $9.95 |
Token profiles: Artificial Analysis, 2026-11-19. Prices: Google Standard rates. Repricing: our calculation.
Through November 30, Neon high and Carbon high cost about the same per task ($3.74 versus $3.88) with similar index scores, and Carbon’s default medium is slightly cheaper than Neon high. From December 1, Carbon’s per-task cost doubles while Neon’s does not move, so Neon high becomes roughly half the price of Carbon high. Hydrogen xhigh costs less than Neon high but scores 5.7 points lower on this index.
Google’s Neon announcement states that at high, Neon has “a 32% lower cost per task than Carbon.” We could not reproduce 32% from Artificial Analysis’s current data: the gap is about 52% against Carbon high and 43% against Carbon medium at December prices, and Neon is slightly more expensive than Carbon medium at November prices. Against Carbon high at November prices, Neon high is only about 3.5% cheaper ($3.74 versus $3.88). No Carbon level in either price period gives 32%. Google ties the figure to the Artificial Analysis Intelligence Index but does not say which Carbon thinking level, which price period or which data snapshot it used, and Artificial Analysis’s numbers may have changed since the announcement. Treat 32% as Google’s claim rather than a number you can recompute today. For the December change in detail, see our Carbon and Argon December price-change guide, and for task-level model choice, Gemini 4 Neon vs Carbon.
A small calculator you can rerun
The calculator below uses only the Python standard library and Decimal, so results are exact until you round for display. It takes token counts you already know (from a usage record or an explicit forecast), not prompts. It does not call any API.
from decimal import Decimal as D
PER_M = D(1_000_000)
# USD per 1M tokens: (input, cached input, output incl. thinking). Checked 2026-11-19.
RATES = {
"gemini-4-neon/standard": ("3.00", "0.15", "15.00"),
"gemini-4-neon/batch": ("1.50", "0.075", "7.50"),
"gemini-4-neon/flex": ("1.50", "0.075", "7.50"),
"gemini-4-neon/priority": ("5.40", "0.27", "27.00"),
"gemini-4-hydrogen/standard": ("1.50", "0.075", "7.50"),
"gemini-4-carbon/standard@2026-11": ("2.00", "0.10", "10.00"),
"gemini-4-carbon/standard@2026-12": ("4.00", "0.20", "20.00"),
}
SEARCH_USD_PER_QUERY = D("14") / D("1000") # after the shared 5,000/month allowance
SEARCH_TIERS = {"standard", "priority"}
def rates(key):
if key not in RATES:
raise KeyError(f"no rate for {key!r}")
return tuple(D(x) for x in RATES[key])
def call_cost(key, input_tokens, cached_tokens, output_tokens):
"""input_tokens includes the cached subset; output_tokens includes thinking."""
for n in (input_tokens, cached_tokens, output_tokens):
if not isinstance(n, int) or n < 0:
raise ValueError("token counts must be non-negative integers")
if cached_tokens > input_tokens:
raise ValueError("cached_tokens is a subset of input_tokens")
r_in, r_cache, r_out = rates(key)
return ((input_tokens - cached_tokens) * r_in
+ cached_tokens * r_cache
+ output_tokens * r_out) / PER_M
def task_cost(key, calls, search_queries=0, free_searches_left=0):
"""calls: list of (input_tokens, cached_tokens, output_tokens)."""
if not calls:
raise ValueError("a task needs at least one call")
tokens = sum((call_cost(key, *c) for c in calls), D(0))
billable = max(0, search_queries - free_searches_left)
if billable and key.split("/")[1].split("@")[0] not in SEARCH_TIERS:
raise ValueError(f"no Search grounding price listed for {key}")
search = billable * SEARCH_USD_PER_QUERY
return {"tokens_usd": tokens, "search_usd": search, "total_usd": tokens + search}
print(task_cost("gemini-4-neon/standard", [(100_000, 80_000, 5_000)]))
# {'tokens_usd': Decimal('0.147'), 'search_usd': Decimal('0.000'), 'total_usd': Decimal('0.147')}
Carbon keys carry an explicit period because its price changes on December 1. The calculator refuses to guess which one you meant. It also rejects cached tokens larger than total input, negative or fractional counts, and an empty task. An empty ledger is not evidence that a task cost zero.
Our full version adds Argon rates, a function that recovers token counts from Artificial Analysis cost breakdowns, and a 19-test unittest suite. The tests cover the rate table (cache at 5% of input on every tier, Batch and Flex at half of Standard, Priority at 1.8×), exact totals for the three workloads below, search allowance handling, and the repricing check described in the previous section. All 19 pass offline. They prove the arithmetic matches Google’s published rates; they do not prove that Google’s invoice for your project will match, which depends on how you normalize the usage record.
Three worked workloads
The token counts below are synthetic assumptions, chosen to show different cost shapes. They are not measured Neon runs. Each table prices the same token counts on every model, which isolates the rate difference. Real tasks on different models use different token counts, which is why the previous section exists.
1. A coding agent with a long shared prefix
Twenty-five agent turns that together send 1,500,000 input tokens, of which 1,275,000 are implicit cache hits (85%), and produce 70,000 output tokens including thinking.
- Uncached input: 225,000 × $3 / 1M = $0.675
- Cached input: 1,275,000 × $0.15 / 1M = $0.191
- Output: 70,000 × $15 / 1M = $1.050
- Total on Neon Standard: $1.916
Output is 55% of the bill even though it is under 5% of the tokens. If the same task needed 140,000 output tokens (roughly what moving from high to xhigh did on Artificial Analysis’s tasks), the total would rise to $2.97.
2. Repeated questions over one large document
A 400,000-token contract bundle. The first question has no cache hit and produces 6,000 output tokens. Nineteen follow-ups each send 402,000 tokens, of which the 400,000-token document prefix hits the cache, and each produces 3,000 output tokens.
- Uncached input: 400,000 + 19 × 2,000 = 438,000 tokens → $1.314
- Cached input: 19 × 400,000 = 7,600,000 tokens → $1.140
- Output: 6,000 + 19 × 3,000 = 63,000 tokens → $0.945
- Total on Neon Standard: $3.399
With no cache hits at all, the same 20 questions would cost $25.06. This is the workload where caching decides the budget.
3. A grounded research brief
Three calls of 20,000 input tokens each (no cache hits), 4,000 output tokens each, and 8 Google Search queries after the monthly free allowance is used up.
- Input: 60,000 × $3 / 1M = $0.180
- Output: 12,000 × $15 / 1M = $0.180
- Search: 8 × $0.014 = $0.112
- Total on Neon Standard: $0.472
Search is 24% of this task. Its price does not change with the model, so cheaper models feel it more.
Same token counts, four price lists
| Workload | Neon | Hydrogen | Carbon (to Nov 30) | Carbon (from Dec 1) |
|---|---|---|---|---|
| Coding agent | $1.916 | $0.958 | $1.278 | $2.555 |
| Document Q&A | $3.399 | $1.700 | $2.266 | $4.532 |
| Grounded brief | $0.472 | $0.292 | $0.352 | $0.592 |
Hydrogen’s three token rates are exactly half of Neon’s, so with identical tokens it costs half. Carbon is two-thirds of Neon through November 30 and four-thirds from December 1. The Search line in the third row stays at $0.112 on every model, which is why that row does not follow the same ratios. The calculation does not tell you which model would pass your acceptance test; the Gemini 4 model selection guide covers fit.
Hydrogen is also the only one of these with a free tier, and it is the one you can call through Ofox today as google/gemini-4-hydrogen (its model page shows the current Ofox price).
When implicit caching pays off
Neon’s cached rate is 95% below its input rate. Three rules from Google’s caching guide decide whether you get it:
- Minimum size. Implicit caching applies to prompts of at least 4,096 tokens on Neon. A 3,000-token prompt never gets the discount.
- Matching prefix, close in time. Hits come from a repeated prefix. Google recommends putting large, shared content (system instructions, tool definitions, reference documents) at the start and sending similar requests within a short time. A timestamp or user ID near the top of the prompt breaks the prefix.
- The 2,050-token rule for multi-turn and agent loops. On Gemini 4, the full previous request is cached only if the new request adds at least 2,050 tokens (model output, thinking and function results all count). With smaller additions, the last 2,050 tokens of the previous request are reprocessed at the standard input rate. Google notes that most agent turns exceed this threshold.
Eligibility does not guarantee a hit. Read the actual count from usage.total_cached_tokens in the response and put that number in your ledger, not the size of the prefix you hoped would be cached. Because there is no explicit cache, there is also no storage fee and no cache-write surcharge: tokens that create the cache are billed at the ordinary input rate.
Caching pays most when a large prefix is reused many times: document Q&A, agents with big tool schemas, batch classification with a long fixed instruction. It does little for one-shot requests, short prompts or chat where every message starts differently. Our cache-hit math guide works through hit-rate sensitivity across providers.
Batch, Flex or Priority?
Moving a task from Standard to Batch or Flex halves the token cost: the coding-agent workload above drops from $1.916 to $0.958. The trade-off is execution behavior, not price. Google positions Batch and Flex for offline evaluations, dataset processing and non-urgent agent runs, and Priority for user-facing traffic that needs consistent latency under peak load.
Two practical notes. First, the Batch and Flex tables do not list a Google Search price, so check the tool documentation before running grounded work there. Second, Priority at $5.40/$27.00 makes Neon more expensive per token than Carbon Standard even after December 1 ($4/$20). Pay for Priority only when you have measured that Standard latency is the problem.
Keeping a Neon task inside budget
max_output_tokenscaps thinking plus output for one response. Neon’s default synchronous limit is 65,536 tokens per hop. It is not a task budget: input, tool calls, retries and further turns are outside it. Google recommends lowering the thinking level rather than setting a low cap, because a low cap can cut answers off and force a retry.- Long decode raises the ceiling. With
background: trueandmax_output_tokensabove 65,536, the server continues in 64K hops up to 1,048,576 minus your input, and every one of those tokens is billed as output. A 262,144-token cap on Standard can spend up to $3.93 in output alone, whatever the thinking level. Set the cap from what the task really needs, not from the maximum. - Pick the lowest level that passes. Google’s own advice is to evaluate at all four levels with a high
max_output_tokens, then choose the lowestthinking_levelthat meets your quality bar. Count failed attempts in cost per accepted task. Our Gemini 4 thinking levels guide walks through that test. - Treat errors as accounting questions. A timeout does not prove the server did no work, and a missing usage block does not prove zero cost. Our Gemini 4 API error guide (Argon examples, same Gemini 4 API) helps separate quota, parameter and transient failures before you retry. Symptoms specific to Carbon, Neon and Hydrogen are in our Gemini 4 Carbon, Neon and Hydrogen error guide. For retry design in general, see the Ofox error-handling guide.
For a full per-attempt ledger format with retry and continuation edge cases, the Carbon task-cost guide covers the same Gemini 4 billing model in more depth; the Argon pricing guide has monthly budgeting worksheets.
Where you can call Neon
As of November 19, 2026, Neon is available on the paid tier of Google’s Gemini API (both generateContent and the Interactions API) and in Google AI Studio for Google AI Pro and Ultra plans. It is not in Ofox’s model list, so you cannot call it through Ofox, and this article has no Ofox Neon price. To set up a request with Google’s own SDK, see our Gemini 4 Neon API guide.
If you want a Gemini 4 model through Ofox today, the available IDs are google/gemini-4-hydrogen and google/gemini-4-argon. The Ofox Gemini API reference shows the request format, and each model page lists its current price.


