Gemini 4 Argon API: Model ID, Pricing, and Your First Request

The Gemini 4 Argon API is live: model ID gemini-4-argon, paid tier only, $2/$10 per 1M tokens through November 30, then $4/$20. Here are the specs, curl and Python requests, long decode in background mode, and a cost assertion in Apidog.

Ashley Innocent

Ashley Innocent

15 October 2026

Gemini 4 Argon API: Model ID, Pricing, and Your First Request

Apidog for Enterprise

On-Premises Deploy

SSO & RBAC

SOC 2 Compliant

Explore Apidog Enterprise

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:

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.

Explore more

How to Normalize Data From 84 APIs Into One Schema (And Contract-Test It)

How to Normalize Data From 84 APIs Into One Schema (And Contract-Test It)

Normalizing reviews from 84 platforms, 59 with an official API and 25 without: one schema, stable IDs, deduplication and contract tests against an OpenAPI spec.

16 November 2026

How to Use Qwen4-Max for Free: 1M API Tokens and 3 Other Routes

How to Use Qwen4-Max for Free: 1M API Tokens and 3 Other Routes

Qwen4-Max has a 1M-token free quota on QwenCloud's Singapore API. Here's how to claim it without surprise charges, how far it goes, the softer free routes (Qoder, QwenWork, QwenStudio) and when the paid API is cheaper.

16 November 2026

Qwen Live Delivery Plugin: How to Run Long Agent Tasks You Can Steer

Qwen Live Delivery Plugin: How to Run Long Agent Tasks You Can Steer

Qwen's open-source Live Delivery Plugin turns a long Codex task into a series of usable versions you can steer from a browser workbench. Here's what's inside, how to install it, budgets, the sandbox warning, and how to test every version with Apidog CLI.

16 November 2026

Practice API Design-first in Apidog

Discover an easier way to build and use APIs

Gemini 4 Argon API: Model ID, Pricing, and Your First Request