Gemini 4 Neon API Pricing, Thinking Levels, Cursor and Copilot
Set up Gemini 4 Neon in the Gemini API, Cursor, or GitHub Copilot. Compare official token prices, cached input charges, thinking levels, CursorBench 4.1 results, and migration changes from Hydrogen, Carbon, Gemini 3.1 Pro Preview, and Gemini 3.8 Flash.
Contents

If you want to use Gemini 4 Neon for coding, start with the model ID gemini-4-neon. Google released it on November 18, 2026, as a generally available model for paid Gemini API projects. You can also select it in Cursor and GitHub Copilot, although both tools apply their own access and billing rules.
The standard API price is $3 per million input tokens and $15 per million output tokens. Cached input costs $0.15 per million tokens. Neon defaults to high thinking, unlike Carbon’s medium default.
This guide covers how to connect Neon, choose a thinking level, estimate costs, and migrate an existing Gemini integration.
1. Where can you use Gemini 4 Neon?
The official model ID is gemini-4-neon. Google announced general availability on November 18, 2026.
Neon sits between Gemini 4 Hydrogen and Gemini 4 Carbon. It targets complex software engineering, multi-file debugging, repository-level refactoring, knowledge work, and scientific reasoning.
Its availability depends on the product and subscription.
| Product | Availability | Access requirements |
|---|---|---|
| Gemini API | Generally available | Paid API tier |
| Google AI Studio | Available | Paid API access; Google AI Pro and Ultra subscribers can also try Neon |
| Android Studio | Available through Gemini API | Paid API tier |
| Google Antigravity | Rolling out | Google AI Pro or Ultra subscription |
| Gemini app | Rolling out | Google AI Pro or Ultra subscription |
| Gemini for business | Available through API and model selector | Eligible business access |
| GitHub Copilot | Generally available, gradual rollout | Pro+, Max, Business, Enterprise |
| Cursor | Available | Eligible plan and third-party model billing |
Google also announced access for eligible Fairwind Program members over the following days. This is a separate, eligibility-based cybersecurity access route.
There is an important distinction between the Gemini API and Google Cloud’s Gemini Enterprise Agent Platform. The latter documents access for verified enterprise customers in selected regions. That restriction should not be interpreted as a global restriction on the public Gemini Developer API.
See Google’s launch announcement and Gemini API release notes.
GitHub Copilot access
GitHub announced Neon availability on November 18.
You can select it from the model picker in:
- Visual Studio Code and Visual Studio
- Copilot CLI
- GitHub Copilot coding agent
- GitHub Copilot app and github.com
- GitHub Mobile
- JetBrains IDEs
- Xcode and Eclipse
Copilot Pro+, Max, Business, and Enterprise are eligible plans.
The model uses usage-based billing at the provider’s list price. Do not assume that selecting Neon consumes only your normal included subscription allowance.
Business and Enterprise administrators can control access through the model policy in Copilot settings. If Neon does not appear, check the rollout status and your organization’s model policy before changing accounts.
See the official GitHub Copilot announcement.
Cursor access and billing
Cursor lists the exact model ID gemini-4-neon.
To select it, open the model selector in your chat or Agent panel and choose Gemini 4 Neon. You can also press Cmd Ctrl + / to cycle through available models. The selected model persists across conversations until you change it.
Cursor’s current documentation lists third-party model access for Premium and above, Teams, Enterprise, and legacy Pro, Pro+, and Ultra plans. Free and Plus plans include only Cursor’s first-party models.
After selecting Neon, check the model picker at the top of the chat panel. It displays the active model. If you use Auto instead, the router may choose a different model for individual requests.
Neon is a third-party model. It does not come from the usage included with Cursor plans.
Cursor documents two billing arrangements:
- The X Subscription: Neon usage is deducted from prepaid credit.
- Legacy Cursor plans: Usage comes from the Other Models pool.
The documented rates per million tokens are:
| Token type | Price |
|---|---|
| Input | $3.00 |
| Cache write | Not listed |
| Cache read | $0.15 |
| Output | $15.00 |
Check your current Cursor plan before using Neon. Cursor’s third-party model access and included usage are separate entitlements.
Cursor also lists a 200K context window and a 1M maximum context for Neon. These are Cursor’s documented model limits. Do not confuse them with Google’s unified 1,048,576-token API context window.
See Cursor’s Gemini 4 Neon documentation and its model selection instructions.
2. How much does Gemini 4 Neon cost?
As of November 19, 2026, Google’s Standard Gemini API pricing is:
| Billing item | Price per 1M tokens |
|---|---|
| Input | $3.00 |
| Output, including thinking tokens | $15.00 |
| Implicit cached input | $0.15 |
| Explicit context caching | Unsupported |
There is no Neon Free tier.
Google charges for every token the model processes. This includes thinking tokens and internal tool system instructions and function declarations when using grounding.
The $0.15 cached-input price represents a 95% discount from the standard input rate. However, it applies to qualifying implicit cache hits, not to manually created explicit caches.
How does Neon compare with Carbon and Hydrogen?
The three models serve different workloads.
| Model | Input / 1M | Output / 1M | Default thinking |
|---|---|---|---|
| Gemini 4 Hydrogen | $1.50 | $7.50 | high |
| Gemini 4 Neon | $3.00 | $15.00 | high |
| Gemini 4 Carbon | $2.00 until Nov 30; $4.00 from Dec 1 | $10.00 until Nov 30; $20.00 from Dec 1 | medium |
All figures are Standard paid-tier prices.
Carbon’s introductory pricing ends on November 30, 2026. Its standard pricing takes effect on December 1. Neon has no introductory price.
Hydrogen remains the cheaper choice for routine coding. Neon costs more but offers deeper reasoning for complex, repeated engineering tasks. Carbon remains the option for the hardest architectural, scientific, debugging, and security problems.
For a deeper Carbon cost breakdown, see Gemini 4 Carbon API pricing and migration.
Example: estimate the cost of a coding request
Assume one request consumes:
- 100,000 uncached input tokens
- 20,000 output tokens, including thinking
- No additional grounding charges
The Standard API calculation is:
| Item | Calculation | Cost |
|---|---|---|
| Input | 0.1 × $3 | $0.30 |
| Output | 0.02 × $15 | $0.30 |
| Total | $0.30 + $0.30 | $0.60 |
If 80,000 of the input tokens qualify as cached tokens, the input charge becomes:
- 20,000 uncached tokens: $0.06
- 80,000 cached tokens: $0.012
- Output: $0.30
The estimated total becomes $0.372.
These are illustrative estimates, not fixed per-request prices. Actual usage depends on prompt length, reasoning depth, tool calls, cache hits, and generated output.
Google also publishes separate Batch and Flex pricing. Their execution conditions differ from standard synchronous requests. Check the current Gemini API pricing page for the applicable rates before choosing either mode.
Which model should you choose?
Use Hydrogen for routine coding, interactive applications, and cost-sensitive agent execution.
Choose Neon when Hydrogen struggles with multi-file changes or complex reasoning. Its high default is a reasonable starting point for these tasks.
Choose Carbon when a difficult task needs additional verification, especially in architecture, security, or scientific work.
The Carbon introductory price makes it less expensive than Neon through November 30. Recalculate the comparison after December 1, when Carbon’s standard rates take effect.
3. Which thinking level should you use?
Neon supports four values:
lowmediumhighxhigh
The default is high.
Thinking level controls reasoning depth, latency, and token consumption. It is not a subscription tier or a separate model ID.
| Level | Typical use | Trade-off |
|---|---|---|
low | High-throughput processing and fast chat | Lowest token use and latency |
medium | Interactive coding, UI prototyping, responsive tool calls | Faster responses and lower token use |
high | Complex coding, agents, tool calls, multimodal analysis | Recommended default |
xhigh | Difficult multi-step engineering, mathematical and scientific analysis | Deepest reasoning, higher latency and token use |
Start with high for complex coding work.
Use medium when an interactive agent needs faster responses. Try low for repetitive, cost-sensitive tasks.
Move to xhigh when high falls short on a difficult task. It is particularly useful for multi-file architectural changes, complex debugging, and scientific reasoning.
Do not use xhigh for every request. More reasoning tokens increase the bill and can increase response time.
Why is Neon different from Carbon?
Carbon defaults to medium and supports low, medium, and high.
Neon defaults to high and adds xhigh.
This matters when replacing a Carbon model ID without changing the rest of your application. The same request can consume more thinking tokens after migration because Neon starts at a higher reasoning level.
If your Carbon integration explicitly used medium, set Neon to medium to preserve that thinking-level choice. Measure Neon’s actual latency and token consumption separately.
Google recommends evaluating the different levels against your own tasks and choosing the lowest level that meets your quality requirements.
See Google’s thinking-level documentation.
4. Connect Gemini 4 Neon through the API
You can make your first API request using Google’s official Gen AI SDK and the Interactions API.
You need:
- A Google account with access to Google AI Studio.
- A Gemini API key.
- A project with paid Gemini API access.
- The Google Gen AI Python SDK.
Create an API key in Google AI Studio. Configure paid billing for the project because Neon is unavailable on the Free tier.
In Bash, enter your key without displaying it:
read -rs GEMINI_API_KEY && export GEMINI_API_KEY
Install the Python SDK:
pip install --upgrade google-genai
Run this minimal request:
from google import genai
client = genai.Client()
interaction = client.interactions.create(
model="gemini-4-neon",
input="Build an interactive single-file HTML token bucket rate-limiter simulator with live sliders for burst size and request traffic."
)
print(interaction.output_text)
The SDK reads your API key from the environment. The request specifies gemini-4-neon and returns the generated text through interaction.output_text.
A successful response confirms that the key, project, endpoint, and model ID work together.
For a more demanding engineering task, explicitly set the thinking level:
from google import genai
client = genai.Client()
interaction = client.interactions.create(
model="gemini-4-neon",
input="Audit this payment retry queue for race conditions and rewrite the lock acquisition logic.",
generation_config={
"thinking_level": "xhigh"
}
)
print(interaction.output_text)
The first request is your connection check. The second demonstrates how to increase reasoning depth.
What if the response is truncated?
Neon’s unified context window is 1,048,576 tokens. Input, thinking, and output tokens share that budget.
The default synchronous output limit is 65,536 tokens. This is separate from the total context limit.
The max_output_tokens field limits combined thinking and generated output. If an existing application sets a low cap, review it before migration.
For standard tasks, keep the default or omit the field. If an application previously used an 8,192-token cap, Google recommends removing that hardcoded limit or raising it to 65,536.
For outputs beyond 65,536 tokens, Google’s documented approach is background execution with background=True and a higher max_output_tokens. The maximum is 1,048,576 minus the input tokens.
Google’s long-decode documentation recommends the latest Google GenAI SDKs for client-side continuation. It does not specify a minimum SDK version in the Neon guide, so check the current SDK documentation rather than relying on an assumed version.
The Interactions API REST examples use v1beta. Keep that API version when following the documented REST examples.
See Google’s long-decode instructions.
5. What does CursorBench 4.1 say about Neon?
Cursor’s November 18, 2026, CursorBench 4.1 results put Neon near the top of its tested models.
| Model and effort | Score | Average cost per task |
|---|---|---|
| Neon Extra High | 65.4% | $10.67 |
| Neon High | 63.7% | $6.54 |
| Carbon High | 61.5% | $8.52 |
| Hydrogen Extra High | 61.4% | $8.09 |
| Fable 5.2 Max | 61.3% | $48.11 |
| Carbon Medium | 60.4% | $7.22 |
| Neon Medium | 57.7% | $3.07 |
| Hydrogen High | 57.3% | $4.57 |
These figures describe Cursor’s agent evaluation, not a standalone model benchmark.
CursorBench evaluates agents on ambiguous, multi-file tasks from real Cursor sessions. Its score measures task performance, while cost per task applies published token rates to the tokens consumed.
Cursor updated the benchmark on November 18. It modified instruction-following problems and increased the agent time limit.
This matters when comparing results with older CursorBench versions.
How should you interpret the scores?
Neon High scored 63.7%, compared with 57.3% for Hydrogen High.
That is a 6.4 percentage-point difference in this benchmark.
Neon Extra High reached 65.4%, but its average task cost was $10.67. Neon High scored 63.7% at $6.54 per task.
The extra reasoning therefore produced a higher benchmark score, but also increased the measured task cost.
Neon High also scored above Carbon High in this particular evaluation while costing less per task. That does not establish that Neon will outperform Carbon on every repository or architecture task.
Cursor explicitly warns that results have variance and small score differences may not be statistically meaningful.
Use the results to choose an initial configuration, then run your own repository tasks. Measure completion quality, unnecessary edits, test results, latency, and actual usage.
For a broader comparison of coding-agent evaluations and reasoning effort, see Coding Agent Index v2.1: Fable 5.2 vs Opus 5.5 Effort.
See the CursorBench 4.1 leaderboard.
6. Migrate from Hydrogen, Carbon, or Gemini 3
Google documents a relatively simple migration from Gemini 4 models. The main change is the model ID.
However, migrations from Gemini 3 need additional request cleanup.
From Gemini 4 Hydrogen or Carbon
If your application already uses a Gemini 4 model, start with:
model="gemini-4-neon"
The request schema does not require changes for a basic Gemini 4 migration.
Check your thinking configuration:
- Hydrogen defaults to
high. - Carbon defaults to
medium. - Neon defaults to
high.
If your Carbon application relied on its default, explicitly set medium during the first migration test.
Then compare the results against high.
Do not assume that identical prompts produce identical usage or latency.
For a more detailed comparison of Hydrogen’s cost and migration behavior, see Gemini 4 Hydrogen API pricing and migration.
From Gemini 3.1 Pro Preview or Gemini 3.8 Flash
Google recommends gemini-4-neon as the upgrade from gemini-3.1-pro-preview. Use Carbon for the hardest problems.
When migrating from gemini-3.8-flash or earlier Gemini 3 models, check these changes.
1. Replace the model ID.
model="gemini-4-neon"
2. Replace the old thinking configuration.
Neon accepts:
thinking_level="low"
thinking_level="medium"
thinking_level="high"
thinking_level="xhigh"
The default changes to high.
The old minimal value is rejected. Remove thinking_budget and use thinking_level instead.
3. Review the context and output limits.
Gemini 3.8 Flash separates its 1M input and 64K output budgets. Neon shares one 1,048,576-token window across input, thinking, and output.
Neon retains a 65,536-token single-request output limit. Review hardcoded max_output_tokens caps and adjust them to the documented limit when necessary.
4. Remove explicit context caching.
Neon does not support explicit context caching through cachedContents or caches.create.
Remove cached_content fields from your requests.
Instead, use implicit caching. Google applies it automatically to shared prompt prefixes of at least 4,096 tokens. Qualifying cache hits receive the 95% input-price discount.
Place static instructions, repository context, and reusable documentation at the beginning of your prompt. This gives repeated requests a better chance of sharing a cacheable prefix.
5. Remove sampling parameters.
Remove these parameters:
temperature
top_p
top_k
Neon ignores custom in-range values for these fields. Out-of-range values return a 400 validation error.
Do not keep these settings merely because your previous Gemini 3 integration used them.
6. Preserve conversation state and tool signatures.
For multi-turn sessions using the Interactions API, use previous_interaction_id to preserve conversation state.
If your application manages generateContent history itself, return previous model turns and thought signatures unchanged across turns. Do not copy a thought signature across parallel functionCall parts.
For tool-calling applications, declare tools through native function calling rather than asking the model to produce custom raw-text JSON tool calls without declared tools. Google’s migration guide documents MALFORMED_FUNCTION_CALL as a possible failure in that situation.
Review these changes before deploying an existing agent.
The complete instructions are in Google’s Gemini 4 Neon migration checklist.
7. Which access route should you choose?
Your choice depends on whether you need Google’s native API, an existing coding tool, or a different billing arrangement.
| Route | What you need | Choose it when |
|---|---|---|
| Google Gemini API | Google account, API key, paid project | You control the application and want direct API access |
| Google AI Studio | Eligible Google AI Pro or Ultra access for Neon testing | You want to compare prompts before integrating |
| Cursor | Eligible third-party model plan and applicable prepaid credit or usage pool | You already work inside Cursor |
| GitHub Copilot | Pro+, Max, Business, or Enterprise | Your coding workflow already uses Copilot |
| Other pay-as-you-go API gateways | A listed model ID and documented endpoint compatibility | You want a separate model-access and billing layer |
A gateway such as BetterToken is a separate API access option for models in its catalogue. Verify the exact model ID and tool compatibility before changing your endpoint. Do not assume a gateway provides every newly released model.
If you need the exact Neon model and want to control its thinking level, caching, and API request configuration, Google’s paid Gemini API is the most direct route.
If you want to avoid managing API requests yourself, start with Cursor or Copilot, then check their separate third-party model billing.
Final setup checklist
Before using Neon in a production coding agent, confirm:
- The model ID is
gemini-4-neon. - Your Gemini API project uses the paid tier.
- Your API key is available to the application.
- Your initial thinking level is
highor an explicitly selected alternative. - Your budget includes thinking tokens at the output rate.
- Your application no longer depends on explicit context caching.
- You removed unsupported or ignored generation parameters.
- Your synchronous output limit accounts for thinking tokens.
- Your multi-turn tool calls preserve the required conversation state and signatures.
- Your actual task quality and token usage meet your deployment requirements.
Neon is a practical starting point when Hydrogen struggles with complex coding work and Carbon’s deeper reasoning is unnecessary. Start with high, measure your own tasks, and reserve xhigh for cases where the additional reasoning improves the result.