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
Gemini 4 Neon API Pricing, Thinking Levels, Cursor and Copilot

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.

ProductAvailabilityAccess requirements
Gemini APIGenerally availablePaid API tier
Google AI StudioAvailablePaid API access; Google AI Pro and Ultra subscribers can also try Neon
Android StudioAvailable through Gemini APIPaid API tier
Google AntigravityRolling outGoogle AI Pro or Ultra subscription
Gemini appRolling outGoogle AI Pro or Ultra subscription
Gemini for businessAvailable through API and model selectorEligible business access
GitHub CopilotGenerally available, gradual rolloutPro+, Max, Business, Enterprise
CursorAvailableEligible 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 typePrice
Input$3.00
Cache writeNot 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 itemPrice per 1M tokens
Input$3.00
Output, including thinking tokens$15.00
Implicit cached input$0.15
Explicit context cachingUnsupported

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.

ModelInput / 1MOutput / 1MDefault thinking
Gemini 4 Hydrogen$1.50$7.50high
Gemini 4 Neon$3.00$15.00high
Gemini 4 Carbon$2.00 until Nov 30; $4.00 from Dec 1$10.00 until Nov 30; $20.00 from Dec 1medium

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:

ItemCalculationCost
Input0.1 × $3$0.30
Output0.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:

  • low
  • medium
  • high
  • xhigh

The default is high.

Thinking level controls reasoning depth, latency, and token consumption. It is not a subscription tier or a separate model ID.

LevelTypical useTrade-off
lowHigh-throughput processing and fast chatLowest token use and latency
mediumInteractive coding, UI prototyping, responsive tool callsFaster responses and lower token use
highComplex coding, agents, tool calls, multimodal analysisRecommended default
xhighDifficult multi-step engineering, mathematical and scientific analysisDeepest 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:

  1. A Google account with access to Google AI Studio.
  2. A Gemini API key.
  3. A project with paid Gemini API access.
  4. 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 effortScoreAverage cost per task
Neon Extra High65.4%$10.67
Neon High63.7%$6.54
Carbon High61.5%$8.52
Hydrogen Extra High61.4%$8.09
Fable 5.2 Max61.3%$48.11
Carbon Medium60.4%$7.22
Neon Medium57.7%$3.07
Hydrogen High57.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.

RouteWhat you needChoose it when
Google Gemini APIGoogle account, API key, paid projectYou control the application and want direct API access
Google AI StudioEligible Google AI Pro or Ultra access for Neon testingYou want to compare prompts before integrating
CursorEligible third-party model plan and applicable prepaid credit or usage poolYou already work inside Cursor
GitHub CopilotPro+, Max, Business, or EnterpriseYour coding workflow already uses Copilot
Other pay-as-you-go API gatewaysA listed model ID and documented endpoint compatibilityYou 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 high or 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.

Ready to optimize your LLM workflow?

Join thousands of developers building faster, smarter, and more cost-effective AI applications with BetterToken.

Get Started for Free