Skip to main content
Gemini 4 Neon (gemini-4-neon) is available on LaoZhang API from November 22, 2026, at $3 input and $15 output per 1M tokens, the same as Google’s list price. Call it with any default-group API key through the OpenAI-compatible endpoint or the native Gemini endpoint.
  • Published: November 22, 2026
  • Last checked: November 22, 2026
  • Status: Live in the default group

Key facts

Pricing

US dollars per 1M tokens, checked November 22, 2026:
  • One price across the whole context window. There is no long-context tier, and Google has not announced any price change for Neon.
  • No free tier. Google does not offer Gemini 4 Neon on its Free tier, so every call is billed.
  • Thinking tokens are billed as output. Neon always thinks before it answers, even on simple questions.
Two real charges show how thinking tokens add up:
  • Short answer: 46 input tokens and 179 output tokens, 176 of them thinking, cost about $0.0028.
  • Longer reasoning: 67 input tokens and 2,136 output tokens, 1,407 of them thinking, cost about $0.032.
Token counts and the charge for every request are in your usage logs. Current prices for all models are in the model catalog.

Gemini 4 Neon vs Gemini 4 Carbon and Hydrogen

Prices in the table are Google’s list prices per 1M tokens. Gemini 4 Argon follows the same schedule as Carbon.
  • Neon or Carbon: in Artificial Analysis’s Intelligence Index, Neon at high scores 59.6 against Carbon’s 60.0, and at their default levels Neon finishes each task in about half the time. Until November 30, Carbon costs less per token. From December 1, Carbon moves to $4 / $20 and Neon becomes the cheaper of the two.
  • Neon or Hydrogen: Hydrogen costs half as much per token. Neon at medium (54.9) already scores above Hydrogen at its highest level, xhigh (53.9), so pick Neon when quality matters more than token price.
  • Try before you switch. All three models are called the same way, so only model (or the model name in the native URL) changes. Run your own prompts and compare results, latency, and token usage in your usage logs.

Request examples

  1. Create an API key under Tokens. Choose the default group and set billing to “Usage first” (recommended) or “Usage-based”.
  2. Store the key in an environment variable:
  3. Send a request. The Python example needs the OpenAI SDK: pip install openai.
  • OpenAI-compatible response: the answer is in choices[0].message.content, and the thinking token count is in usage.completion_tokens_details.reasoning_tokens.
  • Native response: the answer is in candidates[0].content.parts[].text, the thinking token count is in usageMetadata.thoughtsTokenCount, and modelVersion reads gemini-4-neon.
  • Coming from Carbon or Hydrogen: replace the model name in model or the URL. The API key and the rest of the request stay the same.
  • Native authentication: the native endpoint also accepts the key in an x-goog-api-key header instead of Authorization: Bearer.
Both endpoints handle function calling (including sending tool results back for a final answer), structured output, image input, streaming, and multi-turn chat with systemInstruction. For the request formats, see function calling, image understanding, and the Gemini protocol.

Thinking levels

Set the thinking level on the native API with generationConfig.thinkingConfig.thinkingLevel. Neon accepts four levels, from least to most thinking:
  • low
  • medium
  • high (default)
  • xhigh
How the levels behave:
  • The default is high. Without a level, Neon thinks at high, the same default as Hydrogen and one step above Carbon’s medium.
  • The lowest level is low. If you send minimal, LaoZhang API treats it as low.
  • The level changes cost and latency a lot. On the same math problem, low used about 860 thinking tokens and took about 16 seconds, while xhigh used about 6,300 thinking tokens and took about 70 seconds.
  • Use the native API to control thinking. On the OpenAI-compatible endpoint, reasoning_effort does not noticeably change how much Neon thinks: every value from low to xhigh lands at roughly 1,200 to 1,600 thinking tokens.
  • Sampling settings have no effect. Google ignores temperature, top_p, and top_k within their valid ranges and rejects out-of-range values with a 400 error.

Who this affects

  • Affected: projects on Gemini 4 Carbon that want similar quality with faster answers, especially once Carbon’s price rises on December 1, and projects on Gemini 4 Hydrogen that need a stronger model. Any default-group key billed by usage can call Neon now.
  • Not affected: this launch changes no existing model. gemini-4-carbon, gemini-4-argon, gemini-4-hydrogen, gemini-3.8-flash, and the other Gemini models work as before, and current integrations need no changes.

FAQ

What is the Gemini 4 Neon model ID?

gemini-4-neon. Google published only this GA ID, with no -preview or dated version. Put it in the model field on the OpenAI-compatible endpoint, or in the URL path on the native endpoint.

Is there a free tier for the Gemini 4 Neon API?

No. Google does not offer Gemini 4 Neon on its Free tier. On LaoZhang API you pay per token from your balance at Google’s paid-tier price, $3 input and $15 output per 1M tokens, using a LaoZhang API key instead of a Google account.

Is Gemini 4 Neon cheaper than Gemini 4 Carbon?

Not until December 1, 2026. Through November 30, Carbon is $2 / $10 per 1M tokens against Neon’s $3 / $15. From December 1, Carbon moves to $4 / $20 and Neon becomes cheaper per token. What a request costs also depends on thinking tokens, which you can cut with a lower thinking level.

Does reasoning_effort work with Gemini 4 Neon?

Not reliably. On the OpenAI-compatible endpoint, reasoning_effort does not noticeably change how much Neon thinks. To set the level, call the native endpoint with generationConfig.thinkingConfig.thinkingLevel, as in the native example above.

Why does Gemini 4 Neon use so many output tokens?

Output tokens include thinking tokens, and Neon thinks at high by default, even on simple questions. The thinking part is reported in usage.completion_tokens_details.reasoning_tokens (usageMetadata.thoughtsTokenCount on the native API). Send thinkingLevel: "low" on the native endpoint when a short answer is enough.

How do I keep long Gemini 4 Neon requests from timing out?

Simple questions take about 5–8 seconds. Reasoning tasks take about 20 seconds at high, and xhigh can run past 60 seconds. Set your client timeout to about 600 seconds and stream the response:
  • OpenAI-compatible endpoint: add "stream": true to the request.
  • Native endpoint: call :streamGenerateContent?alt=sse instead of :generateContent.
Google and third-party sources LaoZhang API