The Gemini 4 Argon API is live: the model ID is gemini-4-argon, a stable model Google made generally available on October 13, 2026. It runs on the paid tier of the Gemini API only (there’s no free tier) and costs $2 per 1M input tokens and $10 per 1M output tokens through November 30, 2026, then $4 and $20 from December 1. Google’s developer guide calls it through the Interactions API, with a unified 1,048,576-token context window and thinking levels low, medium (default) and high.
This guide covers the specs that matter for an integration, your first request in curl and Python, long outputs in background mode, and a cost assertion in Apidog that keeps the December price change from surprising you. For the model itself, start with what Gemini 4 Argon is; for the rollout timeline, see the Gemini 4 Argon release date guide.
Gemini 4 Argon API at a glance
As of October 15, 2026, from Google’s Argon model page, pricing page and Argon developer guide:
| Item | Detail |
|---|---|
| Model ID | gemini-4-argon (stable, no -preview suffix) |
| Access | Paid tier of the Gemini API; no free tier |
| Recommended API | Interactions API (/v1beta/interactions) |
| Context window | 1,048,576 tokens, shared by input, thinking and output |
| Output | 65,536 by default; up to 1,048,576 minus input with long decode |
| Thinking levels | low, medium (default), high; no minimal |
| Sampling parameters | temperature, top_p, top_k are ignored |
| Caching | Implicit only, 95% off hits on prompts of 4,096+ tokens |
| Input price | $2 per 1M through Nov 30, 2026; $4 from Dec 1 |
| Output price (incl. thinking) | $10 per 1M through Nov 30; $20 from Dec 1 |
| Batch / Flex | Half the standard rates |
| Per-model rate limits | Not in the docs; AI Studio shows them for your project |
Two rows deserve a closer look. Inputs can be text, image, video, audio or PDF, but output is text only, and the Live API isn’t supported. The output row matters most: a normal synchronous call stops at 65,536 tokens by default, and the million-token ceiling needs long decode, covered in Step 3. Our 1M output tokens guide goes deeper on timeouts and storage.
On price, one example is enough here. A request with a 20,000-token prompt and 5,000 output tokens costs 20,000 x $2/1M + 5,000 x $10/1M = $0.04 + $0.05 = $0.09 through November 30, and $0.18 from December 1. Argon’s $10 output rate sits below Gemini 3.1 Pro Preview’s $12, and its December rate matches Claude Opus 5.5 exactly. The Gemini 4 Argon pricing breakdown runs full scenarios, including Batch, Priority and a maxed-out long decode.
Use the official model ID, and keep it in a variable
During the Fairwind-only launch window, placeholder IDs circulated on benchmark sites and aggregators. You don’t need them now. Google’s models page lists one version, the stable gemini-4-argon, labelled “New Stable,” and the October 13 changelog entry uses the same string. If you route through a wrapper or gateway, check that it passes that exact ID through.
Keep it in configuration anyway. In every example below, the model comes from a GEMINI_MODEL environment variable that defaults to gemini-4-argon. That lets you run the same request against gemini-3.8-flash for a cost comparison, or fall back to Flash when Argon spend hits a limit, without a deploy.
Send your first Argon request
Your key lives in GEMINI_API_KEY; never paste it into code. It must belong to a project on a paid tier, since Argon isn’t on the free tier. Key and SDK setup work the same way as in our Gemini 3.8 Flash API guide.
Step 1: Send an Interactions API request
The Interactions API is Google’s primary API and the path its Argon guide uses. Keep both the model and the thinking level in variables.
MODEL="${GEMINI_MODEL:-gemini-4-argon}"
THINKING="${GEMINI_THINKING:-medium}"
curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H "Content-Type: application/json" \
-d "{
\"model\": \"${MODEL}\",
\"input\": \"List the retry rules a REST client should follow for HTTP 429.\",
\"generation_config\": {\"thinking_level\": \"${THINKING}\"}
}"
The Python SDK needs google-genai 2.3.0 or later for the Interactions API:
# pip install "google-genai>=2.3.0"
import os
from google import genai
MODEL = os.environ.get("GEMINI_MODEL", "gemini-4-argon")
THINKING = os.environ.get("GEMINI_THINKING", "medium")
client = genai.Client() # reads GEMINI_API_KEY from the environment
interaction = client.interactions.create(
model=MODEL,
input="List the retry rules a REST client should follow for HTTP 429.",
generation_config={"thinking_level": THINKING},
)
print(interaction.output_text)
Argon accepts low, medium (the default) and high. Don’t send temperature, top_p or top_k: Argon ignores them, so they only add noise to your config. Our thinking levels guide explains the trade-offs on 3.8 Flash, which uses the same three levels. For multi-turn and function-calling work, pass the previous response’s ID as previous_interaction_id.
Step 2: Keep the generateContent path working
Most existing code calls the legacy generateContent endpoint, which Google says remains fully supported. Google’s Argon guide leads with Interactions and names generateContent as an option for client-side continuation of long outputs. Here’s the same request:
curl -s "https://generativelanguage.googleapis.com/v1beta/models/${MODEL}:generateContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H "Content-Type: application/json" \
-d "{
\"contents\": [{\"parts\": [{\"text\": \"List the retry rules a REST client should follow for HTTP 429.\"}]}],
\"generationConfig\": {\"thinkingConfig\": {\"thinkingLevel\": \"${THINKING}\"}}
}"
Note where thinking lives: generation_config.thinking_level on Interactions, generationConfig.thinkingConfig.thinkingLevel here. If your client wraps both, route Argon through Interactions by default. Tool definitions need the same care; see Gemini 3.8 Flash function calling.
Step 3: Run long outputs in background mode
A synchronous call returns up to 65,536 output tokens by default. For more, Google’s long-decode path uses the Interactions API with background=True and max_output_tokens above 65,536, up to 1,048,576 minus your input tokens. The model works in hops of up to 64K, the server runs the continuation hops, and each hop adds a model_output step, so you join the text from all of them. This is Google’s example, with the model moved into a variable:
import os, time
from google import genai
MODEL = os.environ.get("GEMINI_MODEL", "gemini-4-argon")
client = genai.Client()
interaction = client.interactions.create(
model=MODEL,
input="Write a complete, rigorous proof of the prime number theorem.",
background=True,
generation_config={"max_output_tokens": 262144, "thinking_level": "high"},
)
while interaction.status in ("in_progress", "queued"):
time.sleep(5)
interaction = client.interactions.get(id=interaction.id)
text = "".join(
c.text
for s in interaction.steps if s.type == "model_output"
for c in s.content if c.type == "text"
)
print(text)
Three rules from Google’s guide: background=True without max_output_tokens stops at 64K; keep the 65,536 default for standard tasks and reserve 131,072 or 262,144 for complex reasoning and coding; and if you call synchronously, set HTTP timeouts to at least 15 minutes. Watch spend too. A maxed long decode of about 1M output tokens costs about $10 through November 30, a Tier 1 project’s entire $10 spend limit for a rolling 10-minute window. From December 1 it’s about $20, more than that window allows.
Step 4: Mock the response so the client doesn’t burn tokens
You don’t need to spend Argon tokens every time your front end reloads. Save the Step 2 request in Apidog with GEMINI_API_KEY and GEMINI_MODEL as environment variables, send it once, and extract the real response into the endpoint as a response example. Apidog’s default Smart Mock generates data from the schema, so set the project’s default mock method to “Response example first” (Project Settings, Feature Settings, Mock Settings). The mock URL then returns your saved Argon response, so your front end, queue workers and parsers can run against it at no token cost.
To rehearse a heavy reply, edit the example’s usageMetadata to large counts and confirm your billing and alerting code reacts.
Step 5: Assert on usageMetadata and a cost ceiling
Every generateContent response includes usageMetadata. Add a post-processor script in Apidog that prices each response at Argon’s December 1 rates, so your tests already reflect the higher price:
// Apidog post-processor: price this response at Gemini 4 Argon's rates from Dec 1, 2026
const u = pm.response.json().usageMetadata;
const IN = 4 / 1e6; // USD per input token from Dec 1 ($2 per 1M through Nov 30)
const OUT = 20 / 1e6; // USD per output token, thinking included ($10 per 1M through Nov 30)
const out = (u.candidatesTokenCount || 0) + (u.thoughtsTokenCount || 0);
const cost = u.promptTokenCount * IN + out * OUT;
pm.test("usageMetadata is present", () => pm.expect(u).to.be.an("object"));
pm.test("cost under $0.10 at Argon rates", () => pm.expect(cost).to.be.below(0.10));
Pick the ceiling per request; $0.10 suits a short prompt like this one. Google’s pricing page lists Argon’s output price as including thinking tokens, so the script counts both. Run the same saved request against gemini-3.8-flash too: the gap in tokens and cost is your regression comparison, and Argon vs Gemini 3.8 Flash helps you read it.
Migrating Gemini 3.x code and planning for rate limits
Google’s migration checklist for Argon is short:
- Remove explicit caching:
cachedContents,caches.createandcached_contentaren’t supported. Implicit caching is on by default. - Remove
temperature,top_pandtop_k. - Use
previous_interaction_idfor multi-turn and function-calling flows. - Review
max_output_tokens. Apps capped under 32K should raise the cap to at least 32,768, because thinking eats the budget; lower the thinking level instead of the cap. - Raise client timeouts.
Per-model RPM, TPM and RPD aren’t in the docs; AI Studio shows them for your project. The rate limits page does publish a spend-based limit per rolling 10-minute window: $10 on Tier 1, $50 on Tier 2 and $200 on Tier 3. Tier 1 means linked billing, Tier 2 needs $100 of cumulative Google Cloud spend, and Tier 3 needs $1,000.
FAQ
Is the Gemini 4 Argon API available? Yes. It’s been generally available on the paid tier of the Gemini API since October 13, 2026. There’s no free tier.
What is the Gemini 4 Argon model ID? gemini-4-argon. It’s the stable version, with no -preview suffix.
How much does the Gemini 4 Argon API cost? $2 input and $10 output per 1M tokens through November 30, 2026, then $4 and $20 from December 1. Cached input is 95% off, and Batch and Flex run at half price. See Gemini 4 Argon pricing.
Does Argon work with generateContent? Google’s guide uses the Interactions API and lists generateContent as an option for client-side continuation. Build new code on Interactions and keep generateContent for existing clients.
Does Google AI Pro or Ultra give me API access? No. Those consumer plans include Argon in the Gemini app and Search, plus Antigravity for Ultra. The API needs a paid-tier key.
Your next step
Set GEMINI_MODEL=gemini-4-argon in each environment, strip sampling parameters and explicit caching from any 3.x code you port, and save the Interactions and generateContent requests with the cost assertion attached. Download Apidog to keep those requests, mocks and tests in one workspace, and rerun them before December 1 so the new rate doesn’t surprise you.



