Introduction
Google's middle-to-frontier Gemini 4 tier built for sustained engineering and analytical workloads.
| Field | Value |
|---|---|
| Input | Text |
| Output | Text |
| Publisher | |
| Model ID | google/gemini-4-neon/chat |
| Official announcement | 18 November 2026 |
| API format | OpenAI-compatible /v1/chat/completions (synchronous and SSE streaming) |
| Context window | 1,048,576 tokens shared across prompts, images, thinking, and replies |
| Output ceiling | 65,536 tokens per turn (internal thinking included; default 4,096) |
| Thinking effort | low, medium, high (default), xhigh; low, medium, and high verified live |
| Modalities | Text and |
| Current SpicyAPI rates | $2.10 / 1M input · $0.105 / 1M cached input · $10.50 / 1M output |
| Content policy | Standard Google moderation applies; not in the unrestricted tier; refused calls cost $0 |
Key features & highlights
Deeper synthesis above Gemini 4 Hydrogen
Google positions Gemini 4 Neon above Hydrogen for tasks that outgrow rapid daily loops, including cross-service refactoring, long-manuscript continuity checks, and dense analytical memos inside a single 1,048,576-token window.
Adjustable thinking depth on one endpoint
Tune reasoning_effort from low for brisk triage up through medium, high, and xhigh when multi-constraint logic or intricate debugging calls for longer internal deliberation, without changing your client URL or model slug.
Native JSON Schema and function calling
Pair strict response_format JSON Schema constraints with up to 128 tool definitions in tools so downstream parsers, agent orchestrators, and creative-production trackers receive predictable payloads alongside live tool workflows.
Inspect layouts and reference stills beside code
Attach image_url frames directly inside user messages to review dark-mode UI captures, storyboards, or system diagrams alongside source files, specifications, and editorial guidelines in one turn.
Request parameters
| Parameter | Required | Description |
|---|---|---|
messages | Yes | FRONTIER WORKHORSE REASONING API: ordered conversation turns supporting text and |
max_tokens | No | Maximum output tokens per reply (1 to 65,536, default 4,096), including internal thinking tokens. |
reasoning_effort | No | Thinking depth for Gemini 4 Neon: low, medium, high (default), or xhigh. |
stop | No | Up to 4 stop sequences that halt generation early. at least 1 characters · at least 1 items · at most 4 items |
temperature | No | Optional sampling temperature (0 to 2); Gemini 4 reasoning tiers largely ignore sampling tweaks. |
top_p | No | Optional nucleus sampling threshold (0.01 to 1). |
tools | No | Optional function declarations (up to 128 tools) that Gemini 4 Neon can invoke. at most 128 items |
parallel_tool_calls | No | Allow multiple tool invocations in one assistant turn (default true). Default: |
tool_choice | No | Controls tool execution mode: auto, none, required, or a specific function. |
response_format | No | Optional JSON object or strict JSON Schema constraint for structured replies. |
Pricing
Input $2.10 / Output $10.50 per 1 million tokens
Use cases
Cross-service refactoring and migration audits
Load TypeScript interfaces, database migrations, and failing integration logs into the 1M-token context to generate ordered rollout steps and edge-case warnings.
Visual UI and art-direction critique
Send landing-page captures or mood-board frames via image_url alongside design tokens to verify contrast ratios, focal composition, and atmospheric consistency.
Strict JSON extraction from long briefs
Convert sprawling campaign treatments, legal memos, or technical RFCs into schema-validated JSON records through response_format without fragile regex cleanup.
Multi-step agent and studio tool loops
Declare up to 128 functions in tools so Neon can inspect continuity ledgers, issue database lookups, or flag production mismatches while your backend executes each approved step.
Long-horizon narrative and dialogue revision
Keep full episode bibles, wardrobe rules, and character voice sheets in the opening messages so Neon tightens dramatic tension and pacing across chapters while benefiting from cached-input pricing.
Prompt guide & pro tips
Send OpenAI-compatible chat payloads
POST to /v1/chat/completions with model set to google/gemini-4-neon/chat, passing ordered system, developer, user, assistant, or tool messages and optional SSE streaming.
Size
max_tokensfor thinking overheadBecause Gemini 4 counts internal reasoning inside
max_tokensand bills it at the output rate, keepmax_tokenswell above your desired visible length—start at 2,048 or higher on medium and high.Front-load stable prompt prefixes
Place static instructions, schemas, style bibles, and repository context at the start of messages so repeat turns qualify for the $0.105 / 1M cached-input rate.
Use schemas instead of temperature
Google documents that Gemini 4 ignores custom temperature and
top_ptweaks, so enforce predictable structure throughresponse_formatJSON Schema and dialreasoning_effortto match task complexity.
Overview
Google Gemini 4 Neon (google/gemini-4-neon/chat) is Google's mid-to-frontier reasoning tier announced on 18 November 2026, positioned above Gemini 4 Hydrogen for multi-file software engineering, dense analytical synthesis, visual layout inspection, and structured agent workflows. Calls run through SpicyAPI's OpenAI-compatible /v1/chat/completions endpoint with both synchronous JSON responses and SSE streaming.
In live verification on 19 November 2026, this endpoint passed system prompts, function calling (tools), strict JSON Schema output (response_format), and configurable reasoning_effort (low, medium, high).
Parameters
| Parameter | Type | Default | Range / Notes |
|---|---|---|---|
messages | array (required) | — | 1–256 ordered turns (system, developer, user, assistant, tool); user messages accept plain text or mixed text and image_url parts. |
max_tokens | integer | 4096 | 1–65536. Shared between internal thinking tokens and visible output; keep ≥ 2048 on medium or high. |
reasoning_effort | string | "high" | "low", "medium", "high", or "xhigh". Controls thinking depth before answering; low, medium, and high verified live. |
response_format | object | — | Request {"type":"json_object"} or strict {"type":"json_schema","json_schema":{...}} output. |
tools | array | — | Up to 128 OpenAI function definitions callable by the model. |
tool_choice | string / object | "auto" | "auto", "none", "required", or a specific named function object. |
parallel_tool_calls | boolean | true | Permit multiple tool requests in a single turn. |
stop | string / array | — | Optional stop sequence or up to 4 strings (max 32 characters each). |
temperature | number | — | 0–2 accepted for SDK compatibility; Google documents that Gemini 4 ignores sampling overrides. |
top_p | number | — | 0.01–1 accepted for SDK compatibility; Google documents that Gemini 4 ignores nucleus overrides. |
Pricing and Cost Examples
SpicyAPI bills measured tokens after each completed call at 30% below Google's official list rates:
| Token type | SpicyAPI rate (per 1M) | Google official list (per 1M) |
|---|---|---|
| Standard input | $2.10 | $3.00 |
| Cached input | $0.105 | $0.15 |
| Output (reply + thinking) | $10.50 | $15.00 |
Worked Cost Examples
- Uncached architecture review: 40,000 input tokens + 4,000 output tokens (including thinking) =
$0.084 + $0.042= $0.126. - Cached multi-turn session: 120,000 cached prefix tokens + 3,000 fresh input tokens + 2,500 output tokens =
$0.0126 + $0.0063 + $0.02625= $0.04515. - Short structured extraction (
reasoning_effort: "low"): 6,000 input tokens + 600 output tokens =$0.0126 + $0.0063= $0.0189.
Internal reasoning tokens bill as output. Failed or moderated refusals incur $0.
Tools, JSON Schema, and Prompt Caching
- Strict JSON output: Pass a
json_schemaobject inresponse_formatinstead of relying ontemperature=0. Always validate parsed payloads in application code before writing to storage. - Function calling loop: Declare schemas in
tools, inspect returnedtool_calls, execute approved actions locally, and send backrole: "tool"messages with matchingtool_call_idfields. - Maximizing cache hits: Google relies on implicit context caching. Keep unchanging system instructions, schemas, style bibles, and repository snapshots strictly at the front of
messagesso follow-up turns drop from$2.10to$0.105per 1M input tokens.
Choosing Between Neon, Hydrogen, and Claude Fable 5.2
| Model | Context / Max Output | Thinking Controls | Structured JSON | Primary Fit |
|---|---|---|---|---|
| Gemini 4 Neon | 1,048,576 / 65,536 | low, medium, high, xhigh | Native response_format + tools | Multi-file refactors, visual audits, strict JSON extraction, mid-to-frontier reasoning at $2.10 / $10.50 per 1M. |
| Gemini 4 Hydrogen | 1,048,576 / 65,536 | low, medium, high, xhigh | Native response_format + tools | High-frequency everyday patches and rapid agent steps; Google lists Hydrogen at half Neon's list price (see model page for live SpicyAPI rates). |
| Claude Fable 5.2 | 1,000,000 / 128,000 | low, medium, high, xhigh, max | Via tools + tool_choice | Single-turn outputs beyond 64K tokens and five-tier adaptive reasoning (check model page for live SpicyAPI rates). |
Limits and Content Policy
- Direct modalities: Accepts text and
image_urlparts directly; extract text or render page images before sending PDFs, audio, or video. - Turn cap: Replies terminate at 65,536 combined thinking and visible tokens; Google's background long-decode continuation mode is not exposed here.
- Moderation: Gemini 4 Neon is not in SpicyAPI's unrestricted tier. Google's standard publisher moderation applies to all prompts, and declined requests are never billed.
API quick start
curl --fail-with-body -sN https://api.spicyapi.ai/v1/chat/completions \
-H "Authorization: Bearer $SPICY_API_KEY" \
-H "Content-Type: application/json" \
-H "Idempotency-Key: $(uuidgen)" \
-d '{
"model": "google/gemini-4-neon/chat",
"messages": [
{
"role": "user",
"content": "Summarise the following release notes into three bullet points."
}
],
"stream": true
}' \
| jq --unbuffered -Rrj 'select(startswith("data: ")) | .[6:] | select(. != "[DONE]") | fromjson | if .error then "\n[error] \(.error.message)\n" else (.choices[0].delta.content? // empty) end'
See the API reference for authentication, the complete schema, polling, and error handling.













