Claude Opus 5.5 is live on SeedRouter

Text

Gemini 4 Neon

View Markdown

Native Gemini requests, four thinking levels, long decode with continuation tokens, tools, multimodal input and streaming. Includes model limits and verification status.

Use gemini-4-neon with the native Gemini format. The model page includes the Playground and current prices. Gemini 4 Neon sits between Gemini 4 Hydrogen and Gemini 4 Carbon and uses the same native generateContent request format; Google's migration guide says moving between Gemini 4 models requires no request schema changes.

Model ID

Model IDContext windowDefault effort
gemini-4-neon1,048,576 tokens, shared by input, thinking and outputhigh

Use gemini-4-neon for the Default tier, or select an explicit gemini-4-neon:GROUP_NAME tier returned by model discovery. Check your available tiers before sending requests.

Quick example

curl https://api.seedrouter.ai/v1beta/models/gemini-4-neon:generateContent \
  -H "Authorization: Bearer $SEEDROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"contents":[{"role":"user","parts":[{"text":"Audit this payment retry queue for race conditions and propose lock acquisition steps."}]}],"generationConfig":{"thinkingConfig":{"thinkingLevel":"high"},"maxOutputTokens":65536}}'

The model belongs in the URL. contents is required. An answer includes native candidates, finishReason and usageMetadata; retain complete content parts, including thoughtSignature, for conversation history. Hard prompts can run for several minutes. Google recommends a 20-minute client timeout. Use streaming to receive output as it becomes available.

Endpoints

OperationEndpoint
JSON responsePOST /v1beta/models/gemini-4-neon:generateContent
Server-sent eventsPOST /v1beta/models/gemini-4-neon:streamGenerateContent?alt=sse

The OpenAPI specification includes every nested request and response schema. Optional fields use API defaults when omitted. The public native API preserves the submitted body for Gemini validation. The Playground also checks documented constraints before submission and enforces its safety settings.

Request parameters

The URL fixes the model to gemini-4-neon. The request contract contains 11 top-level fields. Fields are optional unless marked required; omission differs from JSON null. Nullable arbitrary JSON is preserved where the official schema permits it.

FieldTypeRequiredDefault and constraints
contentsobject[]YesNonempty conversation; each content has nonempty parts
systemInstructionobjectNoText-only parts; no automatic user identity is inserted
generationConfigobjectNoGeneration parameters in the next table
toolsobject[]NoFunction declarations and built-in tool configurations
toolConfigobjectNoFunction selection and retrieval configuration
safetySettingsobject[]NoOne setting per category; no duplicate categories
serviceTierstringNounspecified, standard, flex, priority; ordinary processing is standard
continuationTokenstringNoToken returned with finishReason: CONTINUATION or MAX_TOKENS; resend the same request with it to continue a long answer
labelsobjectNoString values; lowercase keys/values, maximum 63 Unicode codepoints each
modelstringNoOptional resource name; the URL determines the actual model
storebooleanNoGeneric request storage preference; model-specific effect unverified

Explicit context caching (cachedContent and cachedContents resources) is not supported on Gemini 4 Neon. Implicit caching is on by default for prompts of at least 4,096 tokens.

Generation parameters

Field in generationConfigTypeDefault and constraints
maxOutputTokensintegerDefault 65,536, including thinking. Up to 1,048,576 minus input with continuation. Each streaming or non-streaming response supports up to 65,536 tokens; use continuation for longer output
thinkingConfigobjectthinkingLevel: low, medium, high, xhigh (default high); uppercase spellings accepted. includeThoughts: boolean, default false. Use thinkingLevel; the deprecated thinkingBudget maps to a level when supplied alone with a warning, and cannot be combined with thinkingLevel
stopSequencesstring[]Maximum five sequences
responseMimeTypestringDefault text/plain; legacy JSON schema output requires application/json
responseSchemaobjectOfficial schema dialect; mutually exclusive with responseJsonSchema
responseJsonSchemaJSONJSON Schema; mutually exclusive with responseSchema
responseFormatobjectText format configuration; text.mimeType and optional text.schema. Schema requires JSON MIME type
responseModalitiesstring[]Text only: TEXT; empty means text
mediaResolutionenumMEDIA_RESOLUTION_UNSPECIFIED, LOW, MEDIUM, HIGH with the MEDIA_RESOLUTION_ prefix
seedintegerSigned 32-bit value; model-specific deterministic behavior unverified
presencePenaltynumberGeneric field; model-specific effect/range unverified
frequencyPenaltynumberGeneric field; model-specific effect/range unverified
responseLogprobsbooleanGeneric field; model-specific availability unverified
logprobsinteger0–20; requires responseLogprobs: true; model support unverified
enableEnhancedCivicAnswersbooleanGeneric field; model support unverified
enableAffectiveDialogbooleanGeneric field; model support unverified
audioTranscriptionConfigobjectGeneric field; model-specific options unverified
translationConfigobjectGeneric field; model-specific options unverified

The OpenAPI document lists nested types, enums, required properties and documented bounds for every message, including audioMetadata, documentMetadata, spreadsheetMetadata and videoMetadata.contentLayers from the v1beta discovery specification. The schemas describe official parameters; they are not a SeedRouter request allowlist. Caller-supplied fields and values are preserved. A field accepted by the schema is not proof of support for every account. minimal thinking is not a listed level. Google says temperature, topP, topK and candidateCount are deprecated and should be removed; in-range custom sampling values are ignored and out-of-range values return 400. If submitted in native JSON, they still pass through unchanged for the Gemini API to handle.

Long decode

One Gemini 4 Neon response returns up to 65,536 tokens when streaming and up to 65,536 tokens without streaming. To go further, set maxOutputTokens above 65,536 and continue the answer yourself:

  1. Send the request. If the response ends with finishReason: "CONTINUATION", read candidates[0].continuationToken.
  2. Send the same request again with that value in the top-level continuationToken field. Do not append the partial output to contents; the token carries the model's state, including its thinking.
  3. Repeat until finishReason is STOP or MAX_TOKENS. If a call hits MAX_TOKENS and returns a continuationToken, you can resume only by increasing maxOutputTokens; repeating the same cap returns 400 INVALID_ARGUMENT.
{
  "contents": [{"role": "user", "parts": [{"text": "Generate a complete multi-module migration specification and verification checklist for this payment service."}]}],
  "generationConfig": {"thinkingConfig": {"thinkingLevel": "high"}, "maxOutputTokens": 262144},
  "continuationToken": "TOKEN_FROM_THE_PREVIOUS_RESPONSE"
}

A hop spent entirely on thinking can return empty text with CONTINUATION; that is normal progress. Each hop sends your prompt plus everything generated so far back to the model, so input tokens are counted again in every later hop (with repeated prefixes eligible for implicit caching). SeedRouter bills each hop as its own request. The Interactions API's server-side background mode is not part of this endpoint.

Structured output

{
  "contents": [{"parts": [{"text": "Return a JSON object with ok set to true."}]}],
  "generationConfig": {
    "thinkingConfig": {"thinkingLevel": "low"},
    "maxOutputTokens": 65536,
    "responseMimeType": "application/json",
    "responseJsonSchema": {
      "type": "object",
      "properties": {"ok": {"type": "boolean"}},
      "required": ["ok"]
    }
  }
}

The legacy responseSchema and responseJsonSchema fields cannot be used together. Both require responseMimeType: "application/json". The newer responseFormat.text schema must likewise specify JSON. Use REST enum spellings (APPLICATION_JSON and TEXT_PLAIN) in that message. Requests pass through unchanged; media MIME types and arbitrary function JSON are not rewritten.

Functions and built-in tools

Use tools[].functionDeclarations with a name and either parameters or parametersJsonSchema, not both. Function selection lives in toolConfig.functionCallingConfig; allowedFunctionNames requires ANY or VALIDATED and declared names. Do not ask the model via system instructions to emit raw-text JSON tool calls without declared tools, which can return MALFORMED_FUNCTION_CALL.

Your application executes returned functions and supplies their results in the next conversation turn. Preserve each original thoughtSignature, function call and function response. Do not copy a thought signature across parallel functionCall parts, and do not round numeric identifiers when serializing opaque function arguments.

Google lists Search, Maps, code execution, URL context, File Search and Computer Use for Gemini 4 Neon. File Search resources require access under the credentials serving the request. Native MCP configuration appears in the generic schema, but its availability for this model is not established. Check the official restrictions for each tool before combining it with media. With grounding, Google counts internal tool instructions and function declarations as input tokens. The Playground does not execute your custom functions.

Multimodal input and safety

A contents[].parts[] item contains exactly one payload: text, inline media, a file reference, a function call/response, or an execution part. It may also carry a signature or media metadata (videoMetadata, audioMetadata, documentMetadata, spreadsheetMetadata, mediaResolution, mediaProcessing). Input supports text, images, audio, video and PDFs; output is text only. The model has no image or audio generation and no Live API.

For inline bytes, use inlineData.mimeType and base64 data. For file references, use fileData.mimeType and fileUri. A syntactically valid URL is not proof the model can retrieve it. Video metadata can specify startOffset, endOffset, a positive fps no greater than 24, and contentLayers. Agentic video understanding is selected per part with mediaProcessing: "AGENTIC" next to the video's fileData or inlineData; static processing is the default.

Safety settings use the official native format and pass through the API unchanged. In the Playground, all four categories must be set to BLOCK_MEDIUM_AND_ABOVE or stricter; lower thresholds are available through the API only.

JSON responses and streaming

generateContent returns native JSON. streamGenerateContent?alt=sse emits native JSON in SSE data: events. Important fields include candidates[].content.parts, finishReason, continuationToken, safetyRatings, groundingMetadata, promptFeedback, modelVersion, responseId and usageMetadata.

Retain complete native content in conversation history. Thinking summaries are not the same as thought signatures. A disconnect does not prove generation failed or completed; inspect the partial result and account record before sending another request. Stream usage is cumulative, so use the latest counters instead of summing every chunk.

Usage and pricing

promptTokenCount includes cached input. cachedContentTokenCount is charged at the cached-input rate, rather than charged again as uncached input. Billable output includes candidatesTokenCount plus thoughtsTokenCount. Gemini 4 Neon defaults to high thinking. Set the level explicitly when comparing its usage with another model.

There is no context-length price step for this model. Current SeedRouter prices use Standard token rates; Flex discounts and Priority surcharges have not been configured for this integration. Support for those processing tiers still requires verification. Google Search grounding can add per-query charges beyond token usage; check tool pricing before enabling it. Failed requests are not charged. See the live pricing table.

Account groups

The Default tier uses the bare gemini-4-neon model ID. Additional tiers use gemini-4-neon:GROUP_NAME in the URL. The Playground selects an available tier; the API also accepts an explicit header:

X-SeedRouter-Group: GROUP_NAME

The chosen group determines the price and available capacity; an explicit selection does not silently switch to another group. Omit the header or use auto to keep the API key's default behavior.

Check your API key's available groups without generating a response:

curl "https://api.seedrouter.ai/api/seedrouter/llm/groups?model=gemini-4-neon" \
  -H "Authorization: Bearer YOUR_SEEDROUTER_KEY"

Verification status

Official documentation and REST discovery revision 20261119 were checked on November 20, 2026. On that date, read-only model discovery (GET /v1/models), group discovery (GET /api/seedrouter/llm/groups?model=gemini-4-neon) and public pricing (GET /v1/pricing) confirmed both the Default gemini-4-neon tier and the explicit gemini-4-neon:googlellm-vertext tier. Three single-attempt paid smoke calls through api.seedrouter.ai also completed with HTTP 200: JSON generation with low thinking on Default (54 prompt, 28 output, 39 thinking tokens), SSE streaming with xhigh thinking on Default (50 prompt, 13 output, 207 thinking tokens), and a declared functionCall with low thinking on gemini-4-neon:googlellm-vertext (95 prompt, 22 output, 49 thinking tokens, returning thoughtSignature). Native body pass-through and response-field allowlisting require deploying the updated backend build. Media understanding, grounding, Computer Use, continuation/long decode, other generic fields and processing tiers remain unverified, and these checks do not establish comparative quality or latency.

References