Claude Opus 5.5 is live on SeedRouter

Gemini 4 Neon vs Carbon vs Hydrogen: Which One to Pick?

Compare Gemini 4 Neon, Carbon, and Hydrogen: thinking defaults, REST hop caps, the December 1 price shift, live API rates, and three Neon integration checks.

Read as Markdown

Start high-volume extraction, chat, and fast subagent loops on Gemini 4 Hydrogen. Move multi-file coding agents, spreadsheet and document analysis, and recurring production workflows to Gemini 4 Neon. Keep Gemini 4 Carbon for the hardest architecture, root-cause debugging, and security audit tasks where extra verification per turn actually fixes failures the other two miss.

Almost every comparison published before November 18, 2026 only covers Hydrogen, Carbon, and Argon. Two changes make those older guides incomplete: Google shipped gemini-4-neon as the balanced middle tier between Hydrogen and Carbon, and Carbon's introductory API rate ends on November 30, 2026. Choosing among the three models now depends on three concrete details: the API contract differences you can hit on day one, the December 1 pricing crossover, and how thinking tokens inflate output bills.

How Gemini 4 Neon, Carbon, and Hydrogen differ on paper

All three models accept the same native Gemini generateContent and streamGenerateContent request format. Google's Gemini 4 Neon migration guide states that switching from Carbon, Argon, or Hydrogen requires no request schema changes. That makes swapping model strings easy, which is also how teams walk straight into silent behavioral changes if they skip the parameter defaults.

The table below reflects Google's model documentation and the 20261119 Gemini API discovery specification, checked on November 20, 2026:

Contract field or limitGemini 4 HydrogenGemini 4 NeonGemini 4 Carbon
Stable model IDgemini-4-hydrogengemini-4-neongemini-4-carbon
Unified context window1,048,576 tokens (shared input + thinking + output)SameSame
Thinking levelslow, medium, high, xhighlow, medium, high, xhighlow, medium, high
Default thinking levelhighhighmedium
Synchronous streaming hop65,536 tokens65,536 tokens65,536 tokens
Direct non-streaming REST hop65,536 tokens65,536 tokens32,768 tokens
Long decodeUp to 1M shared budget via continuationTokenSameSame
Input modalitiesText, image, audio, video, PDFSameSame
Output modalityText onlyText onlyText only
Explicit cachedContentUnsupported (implicit caching from 4,096 tokens, 95% hit discount)SameSame
Google API free tierRate-limited free tier listedPaid tier onlyPaid tier only

Three contract details catch teams off guard during a swap:

Thinking defaults do not match. Leaving thinkingConfig.thinkingLevel unset gives you high on Neon and Hydrogen, but medium on Carbon. Going the other direction is worse: sending xhigh to Carbon fails validation because Carbon only accepts low, medium, and high. Sending minimal returns HTTP 400 on all three models, and combining deprecated thinkingBudget with thinkingLevel also returns HTTP 400.

Non-streaming REST hop limits diverge. Neon and Hydrogen return up to 65,536 tokens on both streaming and non-streaming REST calls. Carbon allows 65,536 tokens over streaming or SDK helpers, but caps direct non-streaming REST hops at 32,768 tokens. If an older job writes long reports without streaming, Neon and Hydrogen need half as many continuation hops as Carbon.

Sampling knobs are deprecated. All three models fix sampling behavior and ignore custom temperature, topP, and topK values inside the valid range (while out-of-range values still fail with HTTP 400). None of them supports explicit cachedContent; repeated prompts rely on automatic implicit caching starting at 4,096 tokens. In the 20261119 discovery spec, Google also added structured media slicing fields (Part.audioMetadata, Part.documentMetadata, Part.spreadsheetMetadata, and VideoMetadata.contentLayers), which let clients scope pages, sheet ranges, or audio/video tracks directly in native requests.

What about Gemini 4 Argon? Argon was the first Gemini 4 model released in October 2026. It shares Carbon's medium default, three thinking levels, and 32,768-token non-streaming REST hop, as well as Carbon's introductory pricing schedule. With Neon now filling the balanced slot between Hydrogen and Carbon, Argon no longer sits alone in the middle; teams still pinned to gemini-4-argon should treat Neon as the direct candidate to evaluate against it.

The December 1 pricing crossover and why token rates mislead

A flat rate table looks simple until you look at the calendar. Google's official Standard paid-tier list prices per 1M tokens (flat across the full 1M context window, checked on November 20, 2026 on Google's pricing page) reverse order between Neon and Carbon on December 1, 2026:

Per 1M tokens (Google Standard list)HydrogenNeonCarbon (through Nov 30, 2026)Carbon (from Dec 1, 2026)
Input$1.50$3.00$2.00$4.00
Output (including thinking tokens)$7.50$15.00$10.00$20.00
Cached input (implicit 95% discount)$0.075$0.15$0.10$0.20

For an identical 100,000 uncached input tokens and 10,000 billed output tokens on Google's list schedule:

  • Hydrogen costs $0.225.
  • Neon costs $0.450.
  • Carbon costs $0.300 through November 30, 2026, then jumps to $0.600 on December 1, 2026.

That eleven-day window creates an awkward quirk: until November 30, Carbon's promotional sticker price is lower per token than Neon's standard rate; from December 1 onward, Neon is 25% cheaper per token than Carbon and exactly 2× Hydrogen's rate. If you are building a Q4 or 2027 budget today, pricing against Carbon's $2 / $10 introductory rate without modeling the December 1 doubling will blow up your forecast two weeks after launch.

Current live per-token rates on SeedRouter for all three models load directly below:

Gemini 4 Neon

USD per 1M tokens

Itemgooglellm-vertextgooglellm
Input$2.40$1.65
Output, including thinking$12.00$8.25
Cached input$0.12$0.0825

Current token rates. Cached input is billed once at its own rate; thinking counts as output. Check tool and processing-tier availability before using them.

Gemini 4 Hydrogen

USD per 1M tokens

Itemgooglellm-vertextgooglellm
Input$1.20$0.825
Output, including thinking$6.00$4.125
Cached input$0.06$0.04125

Current token rates. Cached input is billed once at its own rate; thinking counts as output. Check tool and processing-tier availability before using them.

Gemini 4 Carbon

USD per 1M tokens

Itemgooglellmgooglellm-vertext
Input$1.10$1.60
Output, including thinking$5.50$8.00
Cached input$0.055$0.08

Standard processing rates, with no context-length price step. Cached input is billed once at the cached rate. Search and Maps grounding are billed separately from these token rates.

Even with accurate unit prices, per-token comparisons still mislead for one structural reason: thinking tokens are billed as output tokens. Output costs 5× input across the entire Gemini 4 family. A model with a cheaper output rate that burns twice as many reasoning tokens—or needs a retry after a failed unit test—can easily cost more per finished task than a model with a higher list rate.

When you budget a workflow, measure the entire loop: uncached input, cached input hits (verified from usageMetadata, never assumed just because a prompt exceeds 4,096 tokens), visible answer tokens, thoughtsTokenCount, and every failed attempt before acceptance. Also keep consumer plans and API spend separate. Google AI Pro or Ultra subscriptions cover the Gemini app and Antigravity editor limits, not pay-as-you-go API traffic, and Hydrogen's rate-limited Google free tier does not carry over to paid API platforms.

Which model to pick by workload (and when to pair them)

Neither Google's marketing labels nor an aggregate leaderboard score tells you which model passes your own acceptance checks at the lowest total cost. Start with the failure cost of the task and the concrete workloads below:

WorkloadFirst model to evaluateWhy start thereWhen to move up or down
High-volume classification, short summaries, fast chatHydrogen (low or medium)Lowest token price and fast turnaround when deep verification adds little valueEscalate to Neon if field extraction drops edge cases or requires rework
Parallel subagents, repo file reads, routine test loopsHydrogen (medium or high)Built for rapid tool batches; keeps parallel worker spend predictableHand planning or tricky diffs to Neon when worker retries climb
Multi-file coding agents, refactoring, tool-heavy pipelinesNeon (high default)Balances reasoning depth with 65,536-token hops and xhigh headroom when a fix stallsDrop to Hydrogen for boilerplate steps; try Carbon if Neon loops on root causes
Dense PDFs, spreadsheets, charts, mixed audio/video analysisNeon (high)Supports the full multimodal input stack and 20261119 page/sheet/layer metadataCompare against Carbon on high-stakes financial or legal review with human verification
Hard system architecture, subtle multi-layer bugs, security auditsCarbon (medium or high)Designed for longer verification per turn on high-consequence technical workMove recurring subtasks down to Neon once you confirm Neon matches acceptance quality

Pairing models beats forcing one tier onto every call. The pattern that holds up best in real agent harnesses is a two-tier split: use Neon (or Carbon for security-critical architecture) to inspect the problem, write the implementation plan, and review final diffs, while delegating repetitive file edits, log parsing, and parallel read/search steps to Hydrogen.

Only add conditional escalation (start on Hydrogen, escalate to Neon or Carbon on failure) when you have an objective, automated failure signal—such as a schema validation error, a failing test suite, or a missing citation check. Escalating on vague self-reported uncertainty wastes both latency and money, and if more than a third of a task class escalates, direct routing to Neon is usually cheaper and faster end to end.

What three live Gemini 4 Neon API checks showed

On November 20, 2026, we ran three bounded, single-attempt paid API calls against gemini-4-neon through SeedRouter's native Gemini endpoints (generateContent and streamGenerateContent?alt=sse) with zero retries. These were integration smoke checks with small deterministic prompts, not a quality benchmark across Neon, Carbon, and Hydrogen.

CheckEndpoint & tierThinking levelResult observedPrompt / answer / thinking tokensElapsed time
Structured JSONgemini-4-neon:generateContent (Default)lowHTTP 200; returned JSON object (ok: true, model: "gemini-4-neon") + thoughtSignature54 / 28 / 397.71 s
SSE streaminggemini-4-neon:streamGenerateContent?alt=sse (Default)xhighHTTP 200; 2 SSE events; answered 17 times 23 equals 391.50 / 13 / 2076.42 s
Declared function callgemini-4-neon:googlellm-vertext:generateContent (Explicit tier)lowHTTP 200; emitted functionCall get_status({"service":"billing"}) + thoughtSignature95 / 22 / 495.39 s

Two practical details stood out immediately from the raw token counts:

  1. Thinking tokens dominate output even on trivial math. On the streaming prompt (17 × 23), xhigh generated 13 visible answer tokens and 207 thinking tokens—nearly 16× as many hidden reasoning tokens as visible text. Even at low, thinking tokens outnumbered visible output tokens on both the JSON and function-calling requests (39 vs 28 and 49 vs 22). Leaving xhigh enabled globally on simple prompts is the fastest way to overpay for Gemini 4.
  2. Every response carried a thoughtSignature. Multi-turn function-calling loops require passing the returned thoughtSignature back unmodified in subsequent turns, or reasoning continuity breaks across tool calls.

Keep the evidence boundary clear: these three calls verify endpoint reachability, SSE streaming, function-call generation, and thoughtSignature delivery on gemini-4-neon. They do not measure paired accuracy or throughput against Carbon or Hydrogen, and they did not exercise multimodal video/audio/PDF uploads, Google Search or Maps grounding, Computer Use, implicit cache hits, or long-decode continuation. Always run your own 10-to-20-task evaluation set on real prompts before switching production traffic.

Switching between Neon, Carbon, and Hydrogen in code

Because the native request envelope is shared, you can run side-by-side evaluations across all three models by changing only the model ID in the URL path. First inspect which model IDs your API key can access via the read-only model list:

curl "https://api.seedrouter.ai/v1/models" \
  -H "Authorization: Bearer $SEEDROUTER_API_KEY"

Then point a native streaming request at gemini-4-neon, gemini-4-carbon, or gemini-4-hydrogen with an explicit shared thinkingLevel:

MODEL_ID="gemini-4-neon"

curl "https://api.seedrouter.ai/v1beta/models/${MODEL_ID}:streamGenerateContent?alt=sse" \
  -H "Authorization: Bearer $SEEDROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [
      {
        "role": "user",
        "parts": [
          {
            "text": "Review this SQL migration for locking risks and propose a zero-downtime alternative."
          }
        ]
      }
    ],
    "generationConfig": {
      "thinkingConfig": {
        "thinkingLevel": "high"
      },
      "maxOutputTokens": 32768
    }
  }'

Before moving a script from one Gemini 4 model to another, check four things:

  1. Pin thinkingLevel explicitly. Do not rely on defaults if you compare Carbon (medium) against Neon or Hydrogen (high), and strip xhigh before falling back to Carbon.
  2. Leave headroom in maxOutputTokens. Because thinking tokens count against maxOutputTokens, a tight cap like 2,048 or 4,096 can cut off visible output before the final answer finishes—especially at high or xhigh.
  3. Prefer streaming for long tasks. Streaming avoids edge timeouts on slow reasoning turns and removes the 32,768-token direct non-streaming REST cap on Carbon.
  4. Preserve thoughtSignature in tool loops. Echo the exact model parts returned in each turn when sending functionResponse messages back to the API.

You can test prompts interactively on the Gemini 4 Neon model page, compare specs on the Gemini 4 Hydrogen page and Gemini 4 Carbon page, or inspect the full request schema in the Gemini 4 Neon API docs.

FAQ

What is the best Gemini model for coding?

For most multi-file coding agents and day-to-day repository refactoring, start with Gemini 4 Neon at its default high thinking level and step up to xhigh only when a patch fails tests. Use Gemini 4 Hydrogen for fast interactive edits and parallel worker loops, and reserve Gemini 4 Carbon for subtle root-cause debugging, security audits, or multi-step architecture reviews where Neon misses edge cases.

Is Gemini 4 Argon still relevant now that Neon is out?

Gemini 4 Argon was the first Gemini 4 release in October 2026 and remains callable as gemini-4-argon, with the same three thinking levels (low, medium default, high) and pricing schedule as Carbon. Because Neon now sits directly between Hydrogen and Carbon with four thinking levels and a 65,536-token non-streaming REST hop, new projects generally evaluate Neon, Carbon, and Hydrogen first unless they already have a benchmarked Argon baseline.

Why is Gemini 4 Carbon cheaper per token than Neon until November 30?

Google launched Carbon with a temporary introductory rate ($2 input / $10 output per 1M tokens) that expires on November 30, 2026, while Neon launched directly at its standard rate ($3 / $15). On December 1, 2026, Google's standard Carbon rate doubles to $4 / $20, making Neon 25% cheaper per token than Carbon. Even before November 30, actual per-task spend depends on how many thinking tokens each model consumes.

Is Gemini 4 Neon free to use?

No. Google's official pricing table lists paid tiers only (Standard, Batch, Flex, and Priority) for Gemini 4 Neon and Gemini 4 Carbon, with no free API tier. Only Gemini 4 Hydrogen lists a rate-limited free API tier on Google's direct platform. Consumer access in the Gemini app or Antigravity requires a paid AI Pro or Ultra plan and does not include pay-as-you-go API credits.

Can I switch between Neon, Carbon, and Hydrogen without changing my request schema?

Yes, for standard native requests—the endpoint structure, contents, tools, systemInstruction, and continuationToken fields match across all three. You only need to guard two model-specific differences: Carbon does not accept thinkingLevel: "xhigh", and direct non-streaming REST hops cap at 32,768 tokens on Carbon versus 65,536 on Neon and Hydrogen.

Should teams pick Gemini 4 or ChatGPT models for API workloads?

Pick by workload and total task cost rather than brand loyalty. Gemini 4 models give you a unified 1,048,576-token multimodal context window (text, images, audio, video, and PDF) and long-decode continuation across one shared schema, though high thinking levels can consume more output tokens than lower-verbosity models. Run your own ten-task eval set across Gemini 4 Neon and your current GPT baseline, then compare accepted output quality, end-to-end latency, and total spend per passing task.

Related guides