> ## Documentation Index
> Fetch the complete documentation index at: https://docs.laozhang.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Gemini 4 Neon API: Price, Examples, vs Carbon

> Gemini 4 Neon API at $3 input and $15 output per 1M tokens, same as Google: curl and Python examples, thinking levels, and Neon vs Carbon or Hydrogen.

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

| Item | Details |
| - | - |
| Model ID | `gemini-4-neon` |
| Google release | November 18, 2026 (GA) |
| Available on LaoZhang API | November 22, 2026 |
| OpenAI-compatible endpoint | `POST https://api.laozhang.ai/v1/chat/completions` |
| Native Gemini endpoint | `https://api.laozhang.ai/v1beta/models/gemini-4-neon:generateContent` |
| Native streaming | `:streamGenerateContent?alt=sse` |
| Token group and billing | `default` group, billed by tokens |
| Price | \$3 input, \$15 output per 1M tokens (thinking included), same as Google |
| Context window (Google) | 1,048,576 tokens, shared by input and output |
| Max output per request (Google) | 65,536 tokens by default |
| Thinking levels | `low`, `medium`, `high` (default), `xhigh` |
| Works with | Function calling, structured output, image input, streaming, multi-turn chat with system instructions |

## Pricing

US dollars per 1M tokens, checked November 22, 2026:

| Item | LaoZhang API | Google (paid tier) |
| - | -: | -: |
| Input | \$3 | \$3 |
| Output (thinking tokens included) | \$15 | \$15 |

* **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](https://api.laozhang.ai/log). Current prices for all models are in the [model catalog](https://docs.laozhang.ai/en/models.md#vendor-google-text).

## Gemini 4 Neon vs Gemini 4 Carbon and Hydrogen

| | `gemini-4-neon` | `gemini-4-carbon` | `gemini-4-hydrogen` |
| - | - | - | - |
| Google price through Nov 30, 2026 (input / output) | \$3 / \$15 | \$2 / \$10 | \$1.5 / \$7.5 |
| Google price from Dec 1, 2026 (input / output) | \$3 / \$15 | \$4 / \$20 | \$1.5 / \$7.5 |
| Default thinking level | `high` | `medium` | `high` |
| Highest thinking level | `xhigh` | `high` | `xhigh` |
| Intelligence Index (Artificial Analysis) | 59.6 at `high`, 54.9 at `medium` | 60.0 at `high` | 53.9 at `xhigh` |

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](https://api.laozhang.ai/log).

## Request examples

1. Create an API key under [Tokens](https://api.laozhang.ai/token). Choose the `default` group and set billing to "Usage first" (recommended) or "Usage-based".

2. Store the key in an environment variable:

   ```bash theme={null}
   export LAOZHANG_API_KEY="your-laozhang-api-key"
   ```

3. Send a request. The Python example needs the OpenAI SDK: `pip install openai`.

> [tab] OpenAI-compatible (curl)
>
> ```bash theme={null}
> curl https://api.laozhang.ai/v1/chat/completions \
>   -H "Authorization: Bearer $LAOZHANG_API_KEY" \
>   -H "Content-Type: application/json" \
>   -d '{
>     "model": "gemini-4-neon",
>     "messages": [
>       {"role": "user", "content": "Write a SQL query that returns the five customers with the highest total order value from an orders table."}
>     ]
>   }'
> ```

> [tab] Native Gemini (curl)
>
> ```bash theme={null}
> curl "https://api.laozhang.ai/v1beta/models/gemini-4-neon:generateContent" \
>   -H "Authorization: Bearer $LAOZHANG_API_KEY" \
>   -H "Content-Type: application/json" \
>   -d '{
>     "contents": [
>       {"role": "user", "parts": [{"text": "Write a SQL query that returns the five customers with the highest total order value from an orders table."}]}
>     ],
>     "generationConfig": {
>       "thinkingConfig": {"thinkingLevel": "low"}
>     }
>   }'
> ```

> [tab] Python (openai SDK)
>
> ```python theme={null}
> import os
> from openai import OpenAI
>
> client = OpenAI(
>     api_key=os.environ["LAOZHANG_API_KEY"],
>     base_url="https://api.laozhang.ai/v1",
>     timeout=600.0,
> )
>
> response = client.chat.completions.create(
>     model="gemini-4-neon",
>     messages=[
>         {"role": "user", "content": "Write a SQL query that returns the five customers with the highest total order value from an orders table."}
>     ],
> )
> print(response.choices[0].message.content)
> print(response.usage)
> ```

* **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](https://docs.laozhang.ai/en/api-capabilities/function-calling.md), [image understanding](https://docs.laozhang.ai/en/api-capabilities/vision-understanding.md), and the [Gemini protocol](https://docs.laozhang.ai/en/api-reference/gemini.md).

## 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`.

## Sources and related pages

**Google and third-party sources**

* [Google: Gemini 4 Neon model page](https://aistudio.google.com/docs/models/gemini-4-neon): model ID and specifications.
* [Google: What's new in Gemini 4 Neon](https://aistudio.google.com/docs/whats-new-gemini-4-neon): Google's launch notes for the model.
* [Google: Gemini API pricing](https://aistudio.google.com/docs/pricing): list prices for Neon, Carbon, Argon, and Hydrogen.
* [Artificial Analysis](https://artificialanalysis.ai): Intelligence Index scores and per-task time.

**LaoZhang API**

* [Model catalog](https://docs.laozhang.ai/en/models.md#vendor-google-text): current prices.
* [Tokens](https://api.laozhang.ai/token) and [usage logs](https://api.laozhang.ai/log) in the console.
* [Gemini 4 Carbon launch announcement](https://docs.laozhang.ai/en/announcements/gemini-4-carbon-2026-11.md)
* [Gemini 4 Hydrogen launch announcement](https://docs.laozhang.ai/en/announcements/gemini-4-hydrogen-2026-11.md)
* [Text generation API: protocols and popular models](https://docs.laozhang.ai/en/api-capabilities/text-generation.md)
* [Gemini protocol: generateContent](https://docs.laozhang.ai/en/api-reference/gemini.md)
* [LaoZhang API announcements](https://docs.laozhang.ai/en/changelog.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.