Gemini 4 Argon API

Gemini 4 Argon combines multimodal inputs with reasoning for coding, mathematics and multi-step agents. This default variant follows the official medium thinking level.

MODALITIES

TextText

Available

INPUT / OUTPUT70% OFF

$1.2/ 1M

$6/ 1M

USD per million tokens

CACHED INPUT

$0.06/ 1M

Platform price · USD

CONTEXT WINDOW

1,048,576tokens

Max output: 65,536 tokens

Gemini 4 Argon

API Usage Get API access

API Usage Examples

API documentation ↗

POSTGet API Key ↗

curl 'https://newrouters.com/v1beta/models/gemini-4-argon:generateContent' \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $MODEL_API_KEY" \
  --data '{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Explain how an HTTP request works in three concise steps."
        }
      ]
    }
  ],
  "generationConfig": {
    "maxOutputTokens": 1024
  }
}'

const apiKey = process.env.MODEL_API_KEY;

const response = await fetch("https://newrouters.com/v1beta/models/gemini-4-argon:generateContent", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-goog-api-key": apiKey
  },
  body: JSON.stringify({
    "contents": [
      {
        "role": "user",
        "parts": [
          {
            "text": "Explain how an HTTP request works in three concise steps."
          }
        ]
      }
    ],
    "generationConfig": {
      "maxOutputTokens": 1024
    }
  })
});

if (!response.ok) throw new Error(await response.text());
console.log(await response.text());

import os
import json
import requests

response = requests.post(
    "https://newrouters.com/v1beta/models/gemini-4-argon:generateContent",
    headers={
        "Content-Type": "application/json",
        "x-goog-api-key": os.environ["MODEL_API_KEY"]
    },
    json=json.loads("{\"contents\":[{\"role\":\"user\",\"parts\":[{\"text\":\"Explain how an HTTP request works in three concise steps.\"}]}],\"generationConfig\":{\"maxOutputTokens\":1024}}"),
    timeout=300,
)
response.raise_for_status()
print(response.text)

curl 'https://newrouters.com/v1beta/models/gemini-4-argon:streamGenerateContent?alt=sse' \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $MODEL_API_KEY" \
  --data '{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Explain how an HTTP request works in three concise steps."
        }
      ]
    }
  ],
  "generationConfig": {
    "maxOutputTokens": 1024
  }
}'

const apiKey = process.env.MODEL_API_KEY;

const response = await fetch("https://newrouters.com/v1beta/models/gemini-4-argon:streamGenerateContent?alt=sse", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-goog-api-key": apiKey
  },
  body: JSON.stringify({
    "contents": [
      {
        "role": "user",
        "parts": [
          {
            "text": "Explain how an HTTP request works in three concise steps."
          }
        ]
      }
    ],
    "generationConfig": {
      "maxOutputTokens": 1024
    }
  })
});

if (!response.ok) throw new Error(await response.text());
console.log(await response.text());

import os
import json
import requests

response = requests.post(
    "https://newrouters.com/v1beta/models/gemini-4-argon:streamGenerateContent?alt=sse",
    headers={
        "Content-Type": "application/json",
        "x-goog-api-key": os.environ["MODEL_API_KEY"]
    },
    json=json.loads("{\"contents\":[{\"role\":\"user\",\"parts\":[{\"text\":\"Explain how an HTTP request works in three concise steps.\"}]}],\"generationConfig\":{\"maxOutputTokens\":1024}}"),
    timeout=300,
)
response.raise_for_status()
print(response.text)

curl 'https://newrouters.com/v1/interactions' \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $MODEL_API_KEY" \
  --data '{
  "model": "gemini-4-argon",
  "input": "Explain how an HTTP request works in three concise steps.",
  "stream": false
}'

const apiKey = process.env.MODEL_API_KEY;

const response = await fetch("https://newrouters.com/v1/interactions", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-goog-api-key": apiKey
  },
  body: JSON.stringify({
    "model": "gemini-4-argon",
    "input": "Explain how an HTTP request works in three concise steps.",
    "stream": false
  })
});

if (!response.ok) throw new Error(await response.text());
console.log(await response.text());

import os
import json
import requests

response = requests.post(
    "https://newrouters.com/v1/interactions",
    headers={
        "Content-Type": "application/json",
        "x-goog-api-key": os.environ["MODEL_API_KEY"]
    },
    json=json.loads("{\"model\":\"gemini-4-argon\",\"input\":\"Explain how an HTTP request works in three concise steps.\",\"stream\":false}"),
    timeout=300,
)
response.raise_for_status()
print(response.text)

curl 'https://newrouters.com/v1beta/interactions' \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $MODEL_API_KEY" \
  --data '{
  "model": "gemini-4-argon",
  "input": "Explain how an HTTP request works in three concise steps.",
  "stream": false
}'

const apiKey = process.env.MODEL_API_KEY;

const response = await fetch("https://newrouters.com/v1beta/interactions", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-goog-api-key": apiKey
  },
  body: JSON.stringify({
    "model": "gemini-4-argon",
    "input": "Explain how an HTTP request works in three concise steps.",
    "stream": false
  })
});

if (!response.ok) throw new Error(await response.text());
console.log(await response.text());

import os
import json
import requests

response = requests.post(
    "https://newrouters.com/v1beta/interactions",
    headers={
        "Content-Type": "application/json",
        "x-goog-api-key": os.environ["MODEL_API_KEY"]
    },
    json=json.loads("{\"model\":\"gemini-4-argon\",\"input\":\"Explain how an HTTP request works in three concise steps.\",\"stream\":false}"),
    timeout=300,
)
response.raise_for_status()
print(response.text)

Set MODEL_API_KEY in your server environment. Requests use this model’s native API and your account pricing.

Docs: authentication and keys · Error handling

Gemini 4 Argon pricing

Estimate one request, then choose a budget for your workflow.

Usage	Quantity	Rate	Cost
Input	tokens	$1.2/ 1M	$0.0012
Cached input	tokens	$0.06/ 1M	$0
Output	tokens	$6/ 1M	$0.003
Reasoning	tokens	$6/ 1M	$0

Cost per request$0.0042

Public USD estimate. Your account rate and final recorded usage determine the actual charge.

Model pricing details

Specification	Our price	Official reference
Input	$1.2 / 1M tokens	$4 About 70% less than official
Cached input	$0.06 / 1M tokens	$0.2 About 70% less than official
Output	$6 / 1M tokens	$20 About 70% less than official
Reasoning	$6 / 1M tokens	$20 About 70% less than official

Related Models

All Models ↗

Model	Input / output	Cached input	Context	Input → output
Gemini 4 ArgonCurrentGoogle	$1.2 / $6per 1M tokens	$0.06per 1M tokens	1,048,576	TextText
Gemini 4 Argon HighSame gemini protocolSame billing unitsGoogle	$1.2 / $6per 1M tokens	$0.06per 1M tokens	1,048,576	TextText
Gemini 3.1 Pro PreviewSame gemini protocolSame billing unitsGoogle	$0.4 / $2.4per 1M tokens	$0.04per 1M tokens	128,000	TextText
Gemini 3.5 FlashSame gemini protocolSame billing unitsGoogle	$0.3 / $1.8per 1M tokens	$0.03per 1M tokens	128,000	TextText
Claude Fable 5Same billing unitsAnthropic	$3 / $15per 1M tokens	$0.3per 1M tokens	1,000,000	TextText
Claude Fable 5.1Same billing unitsAnthropic	$3 / $15per 1M tokens	$0.075per 1M tokens	1,000,000	TextText

Gemini 4 Argon API · Examples

Original prompts adapted to documented capabilities; these are not vendor-generated outputs.

Official source ↗ · 2026-10-15

EXAMPLE PROMPT

Analyze this material. Separate supported conclusions, conflicting evidence and unanswered questions. Cite the relevant passages: [material]

USER MESSAGE

Evidence-based analysis

Verify claims against the supplied evidence.

EXAMPLE PROMPT

Extract entities and events from this text into a JSON structure. Use null for missing facts and do not infer identities: [text]

USER MESSAGE

Structured extraction

Constrain the output and handle missing information explicitly.

EXAMPLE PROMPT

Plan a tool-assisted workflow for this task. State the inputs for each call, when to ask for clarification, and how to verify completion: [task]

USER MESSAGE

Tool workflow design

Make the workflow and stopping conditions explicit.

EXAMPLE PROMPT

Review this function for empty inputs, duplicate calls and concurrency races. Propose a minimal fix and focused verification: [code]

USER MESSAGE

Boundary-case review

Assess a concrete implementation with checkable cases.

What Is Gemini 4 Argon?

Gemini 4 Argon combines multimodal inputs with reasoning for coding, mathematics and multi-step agents. This default variant follows the official medium thinking level.

Official model information ↗ · 2026-10-15

Official model specifications

Official model ID	gemini-4-argon
Platform thinking route	medium
Official thinking levels	low / medium / high; default medium
Unified context window	1,048,576 tokens
Synchronous output	65,536 tokens
Official inputs / output	Text, image, video, audio, PDF → text
Explicit caching	Not supported
Implicit cache minimum	4,096 tokens

Reasoning model and workloads

Gemini 4 Argon targets difficult coding, mathematics, science and autonomous multi-step workflows. Provide acceptance criteria and relevant source material; evaluate the result against those criteria rather than assuming a reasoning model is always correct.

Thinking levels and this model ID

The official model has low, medium and high thinking levels; medium is the default. This public model ID selects the upstream medium route, matching the vendor default. Use gemini-4-argon-high to select the separate high route. High may use more reasoning tokens and increase first-token latency.

Unified context and output budgets

Input, reasoning and final output share a 1,048,576-token window. The normal synchronous output limit is 65,536 tokens. max_output_tokens includes reasoning and the visible answer; a small limit can end the response before the answer is complete.

Long decode is a separate workflow

The vendor supports generation beyond 64k through background execution or client-managed continuation, up to the remaining unified context budget. That does not make a normal synchronous gateway request a 1M-token output endpoint. Use only the continuation or background endpoints explicitly documented by the platform.

Inputs, structured output and tools

The official model accepts text, images, video, audio and PDF and outputs text. Official documentation lists function calling, structured output, search grounding and code execution. Vendor-hosted tools may incur extra charges and are subject to upstream availability; they are not equivalent to client-side function calls.

Implicit caching only

Explicit cachedContents creation and cached_content references are not supported. Implicit caching is enabled for prompts of at least 4,096 tokens; matching cached prefixes receive the documented cache-read discount. A sufficiently long prompt is not a guarantee of a cache hit.

Pricing and scheduled change

Google currently lists discounted Standard rates of USD 2 input, 10 output including thinking, and 0.10 cached input through November 30, 2026; its undiscounted list rates are USD 4, 20, and 0.20, scheduled from December 1. This service follows the requested undiscounted list-price basis now and applies a 0.3 multiplier to both medium and high; current charges come from the live price table and account receipt.

Native integration and migration

Use the public model ID in the native generateContent or streamGenerateContent path and authenticate with x-goog-api-key. Google recommends medium for most tasks and enough output budget for reasoning. The official model ignores temperature, top_p and top_k; avoid treating these as effective tuning controls. Keep tool-call state and thought signatures when the native response requires them.

Official references

Reviewed on 2026-10-15

Gemini 4 Argon Platform specifications

Specification	Gemini 4 Argon
Model ID	gemini-4-argon
Provider	Google
API	/v1beta/models/{model}:generateContent · /v1beta/models/{model}:streamGenerateContent · /v1/interactions · /v1beta/interactions
Context window	1,048,576 tokens
Maximum output	65,536 tokens
Declared capabilities	Tools · Streaming · Reasoning · Structured output

Protocol & capability details

Protocol & capabilities

gemini · gemini-4-argon

Context limit: 1048576
Maximum output: 65536

tools · stream · reasoning · structured_output

Compare Gemini 4 Argon with related models

Specification	Gemini 4 Argon	Gemini 4 Argon High	Gemini 3.1 Pro Preview
Provider	Google	Google	Google
Input → output	TextText	TextText	TextText
Selection basis	Current model	Same gemini protocol · Same billing units	Same gemini protocol · Same billing units
Context / max output	1,048,576 / 65,536	1,048,576 / 65,536	128,000 / 16,384
Starting price	$1.2 / 1M tokens	$1.2 / 1M tokens	$0.4 / 1M tokens

Choose by the input types, output settings and billing unit your workflow needs. Try the same prompt across models to compare results for your own use case.

Integrate Gemini 4 Argon into your app

Keep the native request format and point your application to the platform API. Prepare a key with model access, then review status and charges in your usage records.

View API examples

Gemini 4 Argon API · Common Questions

Everything you need to know about API access, pricing and model capabilities.

Are medium and high separate Google models?

No. Both use the official Gemini 4 Argon model. The platform exposes a separate -high ID to select the upstream high-thinking route.

Can a single synchronous request output 1M tokens?

The normal synchronous limit is 65,536. The vendor’s longer generation requires background execution or continuation and is not implied by a 1M context window.

Can I create an explicit cache?

No. Argon supports implicit caching only. Do not send cached_content or create cachedContents for this model.

How is Gemini 4 Argon billed?

Charges depend on the recorded token usage and your account rates. Input, output and supported cache or reasoning categories are listed separately in the pricing table. The calculator uses public USD prices; the final usage receipt determines the charge.

How do I get an API key?

Choose “Get API access” to open the integration guide. Sign in to your NewRouters account, prepare a key with access to this model and copy an API example.

Which API endpoints can I use?

Supported endpoints: /v1beta/models/{model}:generateContent、/v1beta/models/{model}:streamGenerateContent、/v1/interactions、/v1beta/interactions. Choose an endpoint in the API examples to see its native request format.

Does the model support streaming?

The current model route declares streaming support. Use the native endpoint’s streaming option and consume its events. Usage already completed may still be billed if the connection is interrupted.

Can I use tools or structured output?

Tools: supported. Structured output: supported. Request fields follow the selected native endpoint.

Where can I check usage and charges?

Keep the request ID and open your account’s LLM usage records to inspect request status, token counts and charges. Prompt and answer content are not a conversation history in this view.

Explore LLM Use Cases

All LLM models ↗

Integration topics / Documentation

All documentation ↗

QUICK STARTHello, API.

Docs: Make your first API request

Prepare a key, choose a model and send a minimal request.

View docs section ↗

NATIVE API{ messages: [...] }

Docs: Use the native API

Explore request formats for OpenAI, Claude and Gemini.

View docs section ↗

INTEGRATIONbuild(something)

Docs: Choose your first request endpoint

Configure requests, handle responses and review usage.

View docs section ↗