API429 / gemini-4-argon

Gemini 4 Argon API: pricing, context and response budgets

Gemini 4 Argon through API429 costs $0.60 per 1M input and $3 per 1M output tokens — 70% below the official Google rate of $2 / $10.

Gemini 4 Argon: shared-window planning and accepted solutions. Plan a small control task, retain input and accepted results, and verify access under your key. Manufacturer specifications and the client request contract are separate checks.

Gemini 4 Argon API by Google: access through API429
Gemini 4 Argon (gemini-4-argon) is a text model by Google, available through the OpenAI-compatible API429 with one key.

Read in Russian

Published: · Updated:

Exact ID: gemini-4-argon. Models available to your key: GET /v1/models.

Family selection and setup: Google API through API429.

Gemini 4 Argon API pricing

API429 priceOfficial Google price (Standard)
$0.030000000000 / 1,000,000 cached input tokens
$0.600000000000 / 1,000,000 input tokens
$3.000000000000 / 1,000,000 output tokens
$2 / $10 per 1M ordinary input / output tokens

Standard; text; output includes thinking; checked 2026-10-24; introductory rates through 2026-11-30; $4/$20 from December 1

Manufacturer sourceChecked: Oct 24, 2026. Cache, tools and special modes are excluded from this rate pair.

API429 prices as of the catalog dated .

Cost calculator for Gemini 4 Argon

API429$2.7
Manufacturer$9
Difference from manufacturer price70%API429 costs less for this workload

Ordinary input and output are counted, excluding cache, tools, fees and repeated calls. This estimates spending; it does not validate whether a request is accepted. RUB results use only your entered rate; they are neither a bank quote nor a top-up amount.

Context and capabilities of Gemini 4 Argon

The manufacturer specifies a shared context window of 1,048,576 and a maximum output of 65,536 tokens for its own API (specification: Google, checked Oct 24, 2026). These are manufacturer limits, not verified effective API429 limits: test very long contexts on your own request.

API429 capabilities published for this exact ID: chat function_calling reasoning structured_output vision . Test any mode missing from this list on your own request.

Complex reasoning: check the solution and useful outcome

Google introduced Gemini 4 Argon for complex programming, mathematics, science and multistep agent work. A practical first comparison is analyzing a logical claim with an explicit counterexample or finding a bug in a short algorithm. Ask a verifiable question and record what counts as a correct answer in advance. For programming, this might be a specific edge case and passing test; for document analysis, an exact reference to the original condition. Confidence and a long answer do not establish correctness. The example below is a text task without command execution. Afterward, compare Argon with Flash on the same data: is the explanation sufficient, how many retries were needed and which assumptions remain unchecked? The manufacturer description sets an evaluation direction but does not promise superiority in every scenario. Such comparisons are more useful than an overall model score without a clear criterion.

Shared context: leave room for reasoning and the response

According to Google documentation reviewed on 2026-10-23, the manufacturer’s Argon window combines input, thinking and output, with a shared limit of 1,048,576 tokens. Large source material therefore reduces the space left for generation. Google’s ordinary synchronous output limit is 65,536 tokens. This page’s examples set max_tokens to 32768: a selected upper budget, rather than an expected text length or an amount charged in advance. Google recommends a larger Argon budget because reasoning may use a substantial portion of output before useful visible text appears. Even that value does not guarantee completion of every task. API429’s public Chat Completions schema allows a positive integer max_tokens but does not set the effective limit for a specific model or key. Verify support for the required volume separately. If an answer is cut off, first identify the completion reason, then reduce input, clarify the task or revise the budget.

Client migration: verify native modes separately

According to Google documentation reviewed on 2026-10-23, in the direct Gemini API, Argon supports low, medium and high reasoning levels; medium is the default. The manufacturer also describes long output through background execution and sequential continuations. This is a separate native Google mechanism: a catalog entry in API429 does not itself establish background jobs or million-token generation through Chat Completions. The minimal example uses only model, messages, max_tokens and stream. Do not transfer background, previous_interaction_id or thinking_level without checking the client contract. According to Google documentation reviewed on 2026-10-23, another manufacturer difference is implicit caching only, without the former explicit cache creation. If your application previously retained a cache reference, review migration separately. Start with a short independent request, then test conversation history and required settings individually. This makes it easier to identify which change affects the result and error handling.

Solution cost: count actual usage and retries

A monetary estimate needs confirmed current API429 input and output rows; manufacturer comparisons have a separate source-review period. According to Google documentation reviewed on 2026-10-23, the manufacturer’s introductory Argon promotion runs through November 30, 2026; the subsequent change concerns official Google rates and does not determine API429 pricing. Measure real usage after a small request and compare with the estimate. max_tokens is a generation ceiling, so multiplying it by the rate does not show the exact charge for a short answer. Multistep processes add history, new instructions and retries. Cache and tools need separate accounting. Assess the cost of an accepted solution: an answer requiring complete rechecking or regeneration may change the total economics. When a timeout leaves the outcome unknown, establish the previous attempt’s status before resubmitting.

Speed and errors of Gemini 4 Argon over 24 hours

Over the last 24 hours: mean successful response time — 42 s; service error rate — 0.0%. Data as of .

Source: public 24-hour statistics. The mean is neither a median nor a response time guarantee.

How to connect Gemini 4 Argon: curl, Python, JavaScript

Create a key, check your balance and set API429_API_KEY on the server. The request is paid from your balance; Python and JavaScript first check that the model is available to your key.

curl

Before generation, check the exact ID in the response from GET https://gateway.api429.com/v1/models using the same Bearer key.

curl --fail-with-body https://gateway.api429.com/v1/chat/completions \
  -H "Authorization: Bearer $API429_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gemini-4-argon","messages":[{"role":"user","content":"Check this reasoning: if all A are B and some B are C, must some A be C? Give a brief counterexample."}],"max_tokens":32768,"stream":false}'

Python 3

import json
import os
import urllib.request

key = os.environ["API429_API_KEY"]
base = "https://gateway.api429.com/v1"
headers = {"Authorization": "Bearer " + key, "Content-Type": "application/json"}
models_request = urllib.request.Request(base + "/models", headers=headers)
with urllib.request.urlopen(models_request, timeout=30) as response:
    available = {item["id"] for item in json.load(response)["data"]}
model = "gemini-4-argon"
if model not in available:
    raise ValueError("Model is unavailable to this key")
payload = json.loads("{\"model\":\"gemini-4-argon\",\"messages\":[{\"role\":\"user\",\"content\":\"Check this reasoning: if all A are B and some B are C, must some A be C? Give a brief counterexample.\"}],\"max_tokens\":32768,\"stream\":false}")
request = urllib.request.Request(base + "/chat/completions",
    data=json.dumps(payload).encode("utf-8"), headers=headers, method="POST")
with urllib.request.urlopen(request, timeout=60) as response:
    result = json.load(response)
choice = result["choices"][0]
if choice.get("finish_reason") != "stop" or not choice.get("message", {}).get("content"):
    raise ValueError("Incomplete or empty response")
print(choice["message"]["content"])
print(result.get("usage"))

JavaScript: Node.js 18+

const key = process.env.API429_API_KEY;
if (!key) throw new Error("Set API429_API_KEY");
const base = "https://gateway.api429.com/v1";
const headers = { Authorization: "Bearer " + key, "Content-Type": "application/json" };
const model = "gemini-4-argon";
const available = await fetch(base + "/models", { headers, signal: AbortSignal.timeout(30000) });
if (!available.ok) throw new Error("Models HTTP " + available.status);
if (!(await available.json()).data.some(item => item.id === model)) throw new Error("Model unavailable to this key");
const response = await fetch(base + "/chat/completions", {
  method: "POST", headers, signal: AbortSignal.timeout(60000),
  body: JSON.stringify({"model":"gemini-4-argon","messages":[{"role":"user","content":"Check this reasoning: if all A are B and some B are C, must some A be C? Give a brief counterexample."}],"max_tokens":32768,"stream":false})
});
if (!response.ok) throw new Error("Generation HTTP " + response.status);
const result = await response.json();
const choice = result.choices?.[0];
if (choice?.finish_reason !== "stop" || !choice?.message?.content) throw new Error("Incomplete or empty response");
console.log(choice.message.content);
console.log(result.usage);

The examples use basic fields from the published API contract.

Gemini 4 Argon in n8n: HTTP Request

  1. Create an HTTP Request with method POST and URL https://gateway.api429.com/v1/chat/completions.
  2. Store the Bearer key in credentials; add Content-Type: application/json. Do not put the key in an exported workflow example.
  3. Send the JSON from curl: the exact model gemini-4-argon, messages, max_tokens and stream=false.
  4. After the HTTP node, check choices, finish_reason and the response content before writing the result to your production system.

HTTP Request documentation.

Alternatives to Gemini 4 Argon: similar models and prices

Compare them on the same task. Prices apply to a short text request; see the catalog for full pricing.

ModelAPI429: input / output per 1M tokens
Gemini 3.8 Flashgemini-3.8-flash$0.225 / $1.125
Gemini 3.5 Flash Litegemini-3.5-flash-lite$0.09 / $0.75
Grok 4.7grok-4.7$0.6 / $1.8

Version and release date

Manufacturer API release date, Google: . The exact predecessor has not been established in the reviewed sources.

Payment and a $10 test

  • Russian bank card. Top up your balance in the account.
  • Invoice for companies. Bank transfer with closing documents.
  • USDT and TON. Top up in crypto.

$10 test credit. Subscribe to our Telegram channel through the bot and get $10 on your balance for the first requests. Get $10 in the bot

Frequently asked questions

Are a million output tokens available in the API429 example?

This page’s example uses ordinary Chat Completions. Google documentation reviewed on 2026-10-23 describes the million-token shared window and a separate long-output mode. This example does not establish support for that native mode through API429. Check effective request and response limits separately under your key.

Why set max_tokens to 32768 for a short task?

According to Google documentation reviewed on 2026-10-23, Google recommends accounting for Argon’s increased reasoning usage. This value is an upper budget, rather than mandatory usage or visible text length. It does not guarantee completion; the outcome depends on the task, actual usage and effective service limits.

Can I reuse the previous model’s cache settings?

According to Google documentation reviewed on 2026-10-23, in the direct Google API, Argon has no explicit caching. Review application migration if it creates a cache or passes its identifier. API429 caching capabilities and request parameters are established separately by its client documentation.

When should I compare Argon with Gemini 3.8 Flash?

Use both models on a complex task with predefined validation criteria. Compare correctness, corrections and actual billable tokens. Deeper reasoning may be unnecessary for a simple answer; a universal winner is not established without this evaluation.

Sources and review

Editorial review: . Pricing and general calculator · Getting started · Compare the family: Gemini

Telegram