DEV Community: Hassann

How to Use Gemini 4 Hydrogen at $0 Today

Hassann — Fri, 13 Nov 2026 07:38:50 +0000

Yes, Gemini 4 Hydrogen is free to use. Google put gemini-4-hydrogen on the free tier of the Gemini API and in Google AI Studio on November 12, 2026, so you can call it with a free API key at $0, within rate limits. Free Gemini app users get it only through auto model selection, and Google Search uses it for everyone.

Try Apidog today

What isn't free: Hydrogen in Google Antigravity, the new Orchestrator, Gemini in Sheets and the paid API tier. Below: each free route, its catches, and how to stretch the quota.

Is Gemini 4 Hydrogen free?

Gemini 4 Hydrogen is free on the Gemini API free tier and in Google AI Studio. Google's pricing page lists input, output and context caching as "Free of charge" on the free tier, rate-limited. The paid tier costs $1.50 per 1M input tokens and $7.50 per 1M output tokens, flat across the 1M-token context window.

That makes Hydrogen the first Gemini 4 model with a free tier: Argon's entry says it "is not available on the Free tier," and our Gemini 4 Carbon free guide covers Carbon. For the full model rundown, start with what is Gemini 4 Hydrogen.

Here's what Google published:

Item	Free tier	Paid tier	Source
Model ID	`gemini-4-hydrogen`	`gemini-4-hydrogen`	AI Studio what's new
Input price	Free of charge	$1.50 / 1M tokens	Pricing page
Output price (incl. thinking)	Free of charge	$7.50 / 1M tokens	Pricing page
Cached input (implicit only)	Free of charge	$0.075 / 1M tokens	Pricing page
Grounding with Google Search	Not available	5,000 free requests/month, then $14 per 1,000	Pricing page
Content used to improve products	Yes	No	Pricing page
Context window	1,048,576 tokens, shared by input, thinking and output	Same	Model page
Thinking levels	`low`, `medium`, `high` (default), `xhigh`	Same	AI Studio what's new

Every free Gemini 4 Hydrogen route

Three routes cost $0 today. Each one gives you a different slice of Hydrogen:

Route	Cost	How you get Hydrogen	Pick the model yourself?	Card needed?
Gemini API free tier	$0	Call `gemini-4-hydrogen` with a free key	Yes	Not listed; Google lists an active project
Google AI Studio	$0	Chat with `model=gemini-4-hydrogen`	Yes	Same as above
Gemini app, no Google AI plan	$0	Auto model selection may route a prompt to Hydrogen	No	No
Google Search	$0	Powers Search's AI responses for all users	No	No

Route 1: The Gemini API free tier

This is the route for developers. Create a key in Google AI Studio and send requests to gemini-4-hydrogen. Google's rate limits page lists the free tier's qualification as an "Active project or free trial", with verification for some projects. It doesn't mention a payment method. Tier 1 is where billing starts.

Here's a first call through the generateContent endpoint. Hydrogen defaults to high thinking, so set low or medium when you want fewer tokens per request:

curl -s "https://generativelanguage.googleapis.com/v1beta/models/gemini-4-hydrogen:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{"parts": [{"text": "Write three test cases for a token-bucket rate limiter."}]}],
    "generationConfig": {"thinkingConfig": {"thinkingLevel": "medium"}}
  }'

The SDKs use the Interactions API instead; our Gemini 4 Hydrogen API guide covers both, plus long decode and tool calls.

Route 2: Google AI Studio

AI Studio is the zero-code route: chat with Hydrogen, test each thinking level, then copy the code. The pricing page says "Google AI Studio usage is free of charge in all available regions." AI Studio is also where you see your own rate limits, because Google doesn't publish a fixed free-tier table for Hydrogen.

Route 3: The Gemini app, free plan

Free users can get Hydrogen in the Gemini app, but they can't choose it. The Gemini Apps help page lists "Auto or Flash-Lite" for accounts with no Google AI plan: "Prompts that require more reasoning may use Hydrogen. If auto model selection is turned off, all responses will use Flash-Lite." Keep auto on, and expect Hydrogen on harder prompts only.

Route 4: Google Search

Google's Search post says Hydrogen "is now available globally in Google Search for all users." No plan or key is needed, but you can't control the model or build on it.

What isn't free

Google's launch post and the Antigravity blog put these behind a paid plan:

Google Antigravity. Hydrogen "is rolling out across paid Google AI Pro and Ultra subscribers." There's no free Antigravity route to Hydrogen.
Orchestrator. Ultra gets Orchestrator (Carbon) and Orchestrator (Argon); paid Pro gets Orchestrator (Argon). Our Gemini 4 Hydrogen Orchestrator guide explains how it hands work between Carbon and Hydrogen.
Gemini in Google Sheets. It starts with Google AI Pro and Ultra subscribers.
Search grounding on the API. Grounding with Google Search shows "Not available" on the free tier.
Private data handling. On the free tier, content is "used to improve our products." Only the paid tier says no.
Batch API. Google lists it, at a 50% discount, under the Paid plan.

Third-party "free Hydrogen API" sites aren't Google routes; keep your keys off them.

Gemini 4 Hydrogen free tier limits

Google hasn't published fixed free-tier numbers for Hydrogen; limits "can be viewed in Google AI Studio." Here's what Google confirms:

Limits are per project, not per API key. Extra keys in the same project don't add quota.
Requests per day reset at midnight Pacific time.
Limits cover requests per minute, tokens per minute and requests per day. Cross any one and you get HTTP 429.
Free to Tier 1 typically takes effect instantly once you link a billing account.

How to stretch the free quota

Thinking tokens count too. Five habits make the free tier last:

Start at medium thinking. high is the default; low uses the fewest tokens. Google suggests picking the lowest level that meets your quality bar.
Save xhigh for hard problems. Google warns it raises latency and token use and "can cause overthinking on simpler prompts."
Reuse long prompts. Implicit caching runs on prompts of at least 4,096 tokens. Explicit caching isn't supported on Hydrogen.
Route easy jobs elsewhere. Google keeps Gemini 3.5 Flash-Lite for high-volume classification and routing.
Back off on 429s with exponential delay, not a tight loop.

A minimal retry wrapper looks like this:

for attempt in 1 2 3 4 5; do
  code=$(curl -s -o out.json -w "%{http_code}" \
    "https://generativelanguage.googleapis.com/v1beta/models/gemini-4-hydrogen:generateContent" \
    -H "x-goog-api-key: $GEMINI_API_KEY" -H "Content-Type: application/json" \
    -d '{"contents":[{"parts":[{"text":"Summarize this changelog."}]}],
         "generationConfig":{"thinkingConfig":{"thinkingLevel":"low"}}}')
  [ "$code" != "429" ] && break
  sleep $((2 ** attempt))   # 2, 4, 8, 16, 32 seconds
done
echo "HTTP $code"

HTTP 429 Too Many Requests explains the status code. When the free tier stops being enough, our Gemini 4 Hydrogen pricing guide does the per-call math, and you can compare it with Gemini 4 Carbon pricing and Gemini 4 Argon pricing.

Moving from Gemini 3.8 Flash for free

If you're on the free Gemini 3.8 Flash route, Google calls Hydrogen the "recommended upgrade," and both sit on the free tier. Change the model string, drop minimal thinking (Hydrogen rejects it), remove temperature, top_p, top_k and cached_content, and raise low max_output_tokens caps to 65,536. Google reports Hydrogen is 2.5x faster than 3.8 Flash at high thinking; test your own prompts before switching.

Let your coding agent test it with Apidog CLI

Don't spend free quota on hand-written retries. Let your coding agent set up the Hydrogen request once, assert on the response and rerun it on demand. Apidog CLI gives Claude Code, Codex or Cursor the commands, and Apidog's Free plan covers up to 4 users.

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted

Then give your agent one prompt:

In Apidog project <id>, create an environment "gemini-free" with base URL
https://generativelanguage.googleapis.com/v1beta. Add a test case for
POST /models/gemini-4-hydrogen:generateContent with the key from
{{GEMINI_API_KEY}} and thinkingLevel "medium". Assert HTTP 200, a non-empty
candidates array and a usageMetadata object. Run it with a 2-second delay
between requests and summarize any failures, including 429s.

The agent creates the environment, reads the schema, validates its payload, writes the case and runs it:

apidog environment create gemini-free --project <id> \
  --base-url https://generativelanguage.googleapis.com/v1beta
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <id> --file case.json
apidog run --test-case <caseId> --project <id> -e <envId> \
  --env-var "GEMINI_API_KEY=$GEMINI_API_KEY" --delay-request 2000 -r cli,json

--delay-request (milliseconds) spaces requests under your per-minute limit, and --env-var passes the key from your shell instead of storing it in the project. The Apidog CLI in Claude Code guide covers agent setup, and Apidog CLI in CI/CD runs the same case on every push.

FAQ

Is Gemini 4 Hydrogen free? Yes, on the Gemini API free tier and in Google AI Studio, within rate limits. Free Gemini app users get it only through auto model selection, and Google Search uses it for all users.

Do I need a credit card for the Gemini 4 Hydrogen free tier? Google's rate limits page lists an active project or free trial as the free-tier requirement and doesn't mention a payment method. Billing starts at Tier 1.

What are the Gemini 4 Hydrogen free tier rate limits? Google doesn't publish a fixed table. You see your project's limits in Google AI Studio. Limits apply per project, and daily quotas reset at midnight Pacific time.

Can I choose Gemini 4 Hydrogen in the free Gemini app? No. With no Google AI plan, you get Auto or Flash-Lite. Auto may route harder prompts to Hydrogen; with auto off, every response uses Flash-Lite.

Is Gemini 4 Hydrogen free in Google Antigravity? No. Google is rolling it out to paid Google AI Pro and Ultra subscribers, and Orchestrator is limited to those plans too.

Start free, upgrade with one string

Gemini 4 Hydrogen is the first Gemini 4 model you can build on for $0: a free AI Studio key, gemini-4-hydrogen as the model, medium thinking and a 429 backoff. For the paid side, see Gemini 4 Carbon vs Argon and what is Gemini 4 Carbon. Download Apidog and let your agent keep the Hydrogen test green as you scale.

Gemini 4 Hydrogen Pricing: $1.50 Input, $7.50 Output, Flat to 1M Tokens

Hassann — Fri, 13 Nov 2026 07:36:50 +0000

Gemini 4 Hydrogen Pricing: Complete Cost Breakdown and Calculator

Gemini 4 Hydrogen pricing is $1.50 per 1M input tokens and $7.50 per 1M output tokens on the Gemini API's Standard paid tier, flat across the whole 1M-token context window. Thinking tokens bill at the output rate, cached input costs $0.075 per 1M, and Batch or Flex cut every rate in half.

Try Apidog today

Hydrogen, released November 12, 2026, is the fast member of the Gemini 4 family. Unlike Carbon and Argon, it has no introductory price that doubles later, and it's on the Free tier. Below: the price table, worked cost examples, how thinking levels move your bill, and how to measure your own cost. New to the model? Start with what Gemini 4 Hydrogen is.

How much does Gemini 4 Hydrogen cost per 1M tokens?

Gemini 4 Hydrogen (model ID gemini-4-hydrogen) has four paid tiers on Google's pricing page. All prices are per 1M tokens:

Tier	Input	Output incl. thinking	Cached input	Free tier
Standard	$1.50	$7.50	$0.075	Free of charge
Batch	$0.75	$3.75	$0.0375	Not available
Flex	$0.75	$3.75	$0.0375	Not available
Priority	$2.70	$13.50	$0.135	See pricing page

Three details on the same page shape your budget:

Thinking is billed. "Every token the model processes is counted and billed, including thinking tokens."
Implicit caching only. Explicit caching isn't supported; you get the cached rate when Google's implicit cache matches a repeated prompt prefix.
Grounding is extra. Google Search grounding includes 5,000 free requests a month, then $14 per 1,000.

Free tier usage is marked "Used to improve our products: Yes" on the page. Our Gemini 4 Hydrogen free guide walks through every $0 route.

What does "flat to 1M tokens" mean?

It means one price for every prompt size. Google's launch post says Hydrogen "is priced flat across its entire 1 million-token context window at $1.50 per million input tokens and $7.50 per million output tokens." A 5K-token prompt and a 900K-token prompt bill at the same per-token rate.

Not every Gemini model works this way: Gemini 3.1 Pro Preview charges $2.00/$12.00 per 1M up to 200K tokens and $4.00/$18.00 above it.

Two numbers make it concrete:

A 900K-token prompt (a large codebase or a stack of PDFs) costs $1.35 in input on Standard, or $0.0675 when the implicit cache hits.
The context window is unified: input, thinking and output share 1,048,576 tokens. A 900K prompt leaves about 148K tokens for thinking and answer combined.

Synchronous responses cap at 65,536 tokens. Longer output runs through long decode, still at $7.50 per 1M.

How do thinking levels change your Gemini 4 Hydrogen bill?

Hydrogen supports four thinking levels: low, medium, high (the default) and a new xhigh. You set it with generation_config.thinking_level. The per-token price never changes; the number of thinking tokens does, and those bill at the output rate.

Artificial Analysis ran its Intelligence Index at each level. Here's what it reported:

Thinking level	Index score	Tokens generated on the index	Cost per index task
low	27	20.3M	$0.29
medium	41	54.4M	$0.80
high (default)	51	110M	$1.87
xhigh	54	304M	$3.16

Read the table as ratios. Going from high to xhigh generated about 2.8x the tokens and raised the cost per task by about 1.7x, for 3 more index points. Dropping from high to low cut tokens to under a fifth.

Google's What's new in Gemini 4 Hydrogen page warns that xhigh "can cause overthinking on simpler prompts" and recommends picking "the lowest thinking_level that meets your quality bar." Note that max_output_tokens caps thinking and output combined.

What does one Gemini 4 Hydrogen call cost?

Every request follows one formula. Pull the token counts from the usage object in the response (total_input_tokens, total_cached_tokens, total_thought_tokens, total_output_tokens):

cost = (uncached_input x $1.50 / 1M)
     + (cached_input   x $0.075 / 1M)
     + ((thought + output) x $7.50 / 1M)

The two examples below use illustrative token counts, not measurements. Swap in your own.

Example 1: a chat call at high. 2,000 input tokens, 1,500 thinking tokens, 600 output tokens.

Line	Standard	Batch or Flex
Input (2,000)	$0.0030	$0.0015
Thinking + output (2,100)	$0.0158	$0.0079
Total per call	$0.0188	$0.0094
10,000 calls a month	$187.50	$93.75

Example 2: an agent loop. A coding agent runs 40 turns. It re-sends the conversation each turn, so it reads 1.2M input tokens in total, and 900K of those hit the implicit cache. It thinks for 200K tokens and writes 60K tokens of code and tool calls.

Line	Standard	Batch or Flex	Priority
Uncached input (300K)	$0.45	$0.23	$0.81
Cached input (900K)	$0.07	$0.03	$0.12
Thinking + output (260K)	$1.95	$0.98	$3.51
Total per run	$2.47	$1.23	$4.44

About 79% of the Standard bill is thinking and output, so the thinking level matters more than trimming your prompt. The request code for both examples is in our Gemini 4 Hydrogen API guide.

How does Hydrogen pricing compare with Carbon, Argon and Gemini 3.8 Flash?

Here are Standard paid-tier rates per 1M tokens from Google's pricing page, read November 13, 2026:

Model	Input	Output	Cached input	Free tier
Gemini 4 Hydrogen	$1.50	$7.50	$0.075	Yes
Gemini 4 Carbon (to Nov 30)	$2.00	$10.00	$0.10	No
Gemini 4 Carbon (from Dec 1)	$4.00	$20.00	$0.20	No
Gemini 4 Argon (to Nov 30)	$2.00	$10.00	$0.10	No
Gemini 4 Argon (from Dec 1)	$4.00	$20.00	$0.20	No
Gemini 3.8 Flash (to Dec 31)	$0.75	$3.75	$0.075	Yes
Gemini 3.8 Flash (from Jan 1, 2027)	$1.50	$7.50	$0.15	Yes

Run the Example 2 agent loop's token counts through each price and you get $2.47 on Hydrogen, $3.29 on Carbon or Argon this month and $6.58 from December 1, and $1.27 on Gemini 3.8 Flash until December 31. Once Flash's price rises on January 1, 2027, the same tokens cost $2.54 on Flash, slightly more than Hydrogen because Flash's cached rate doubles to $0.15. For the details on the frontier models' price change, see our Gemini 4 Carbon pricing and Gemini 4 Argon pricing guides.

Same tokens isn't the real comparison, though, because each model spends a different number of tokens per task. Artificial Analysis's Intelligence Index pages give one view:

Model (thinking level)	Index score	Tokens generated	Cost per index task
Gemini 4 Hydrogen (high)	51	110M	$1.87
Gemini 4 Hydrogen (xhigh)	54	304M	$3.16
Gemini 4 Argon (high)	50	113M	$4.97
Gemini 4 Carbon (high)	60	205M	$5.48
Gemini 3.8 Flash (high)	31	126M	not compared here

On this benchmark, Hydrogen at its default matched Argon's score at about 38% of Argon's cost per task, while Carbon scored highest. Treat it as one benchmark's view. Google also says Hydrogen finishes tasks 2.5x faster than Gemini 3.8 Flash at the high setting.

The practical split: Hydrogen for everyday coding and agents, Carbon for hard architecture, debugging and security reviews. In Antigravity, the Orchestrator option switches between Carbon and Hydrogen inside one run. Our Gemini 4 Carbon vs Argon comparison covers the frontier side.

How can you cut your Gemini 4 Hydrogen bill?

Use Batch or Flex for work that can wait. Both are half price.
Pick the lowest thinking level that passes your evals. medium used about half the tokens of high.
Save xhigh for the hard turns.
Keep a stable prompt prefix so implicit caching bills repeated input at $0.075 per 1M, a 95% discount.
Prototype on the Free tier.

Measure your real Gemini 4 Hydrogen cost with Apidog CLI

Your bill comes from your own prompts. The quickest way to get real numbers is to let your coding agent (Claude Code, Codex, Cursor) run your prompts at every thinking level through Apidog CLI and log the usage object for each run.

Set it up once:

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted

Put 5 to 10 of your real prompts in levels.csv, one row per prompt and thinking level, with columns prompt and thinking_level (low, medium, high, xhigh). Then give your agent one prompt:

In Apidog project <projectId>, create a test case for
POST https://generativelanguage.googleapis.com/v1beta/interactions
with the x-goog-api-key header read from GEMINI_API_KEY in environment
<envId>. Send model "gemini-4-hydrogen", input {{prompt}} and
generation_config.thinking_level {{thinking_level}}. Assert status 200,
status "completed", non-empty output, and a usage object that includes
total_input_tokens and total_output_tokens. In a post-processor, read
total_input_tokens, total_cached_tokens, total_thought_tokens and
total_output_tokens, compute cost at $1.50 input, $0.075 cached and
$7.50 output per 1M, and log it. Run every row of levels.csv and give me
a table of tokens and cost per prompt and thinking level.

The agent checks the payload shape before it writes anything, then runs every row:

apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <projectId> --file case.json
apidog run --test-case <caseId> --project <projectId> -e <envId> \
  -d levels.csv -r cli,json --out-file hydrogen-cost-{GENERATE_TIME}

The JSON report shows what each thinking level costs on your workload. Add -r junit and the same command runs in CI, where a token-budget assertion can fail the build. The Apidog CLI CI/CD guide shows the pipeline, and Apidog CLI in Claude Code covers the agent setup. Apidog's Free plan covers up to 4 users.

A shortcut: tell your agent "Read https://apidog.com/apidog-cli-installation-guide.md and set up Apidog CLI."

FAQ

Is Gemini 4 Hydrogen free? On the API, yes, within Free tier rate limits: Google lists Standard input and output as "Free of charge" on the Free tier. Batch, Flex and Search grounding need a paid key. See our Gemini 4 Hydrogen free guide.

Will Gemini 4 Hydrogen's price go up like Carbon's? Google's pricing page lists a single $1.50/$7.50 rate for Hydrogen, with no introductory period or end date. Carbon and Argon carry dated intro prices; Hydrogen doesn't.

Are thinking tokens billed for Gemini 4 Hydrogen? Yes, at the output rate of $7.50 per 1M on Standard. The response's usage object reports them separately as total_thought_tokens.

Is Gemini 4 Hydrogen cheaper than Gemini 3.8 Flash? Not this year: Flash costs $0.75/$3.75 until December 31, 2026. From January 1, 2027, Flash rises to $1.50/$7.50, the same per-token rate as Hydrogen, and Hydrogen scored 51 to Flash's 31 on Artificial Analysis's index.

Gemini 4 Hydrogen Orchestrator: How Carbon Plans and Hydrogen Executes

Hassann — Fri, 13 Nov 2026 07:35:58 +0000

Gemini 4 Hydrogen Orchestrator: How Google's Planner/Executor Split Works

Gemini 4 Hydrogen Orchestrator is a model option in Google Antigravity that pairs a planner (Gemini 4 Carbon or Argon) with Gemini 4 Hydrogen inside one task. The planner explores and writes the plan, Hydrogen edits code and runs tests, and control passes back to the planner whenever Hydrogen hits friction. Google says it reaches near-Carbon success with 24% less quota.

Try Apidog today

Below: how the hand-off loop works, what the 24% and 19% numbers mean, which plans get it, and how to build the same split with the Gemini API. For the model basics, read what Gemini 4 Hydrogen is.

What is Gemini 4 Hydrogen Orchestrator?

Orchestrator is an entry in Antigravity's model selector, not a separate model. Pick Orchestrator (Carbon) and Gemini 4 Carbon plans while Gemini 4 Hydrogen implements. Pick Orchestrator (Argon) and Gemini 4 Argon plans instead. Switches happen automatically within each response, inside one conversation.

Google launched it on November 12, 2026. The Antigravity announcement names the problem: running a frontier reasoning model on "every step of every routine task slows down your loop and burns frontier quota."

Three facts to keep straight:

It's Antigravity only. There's no Orchestrator endpoint in the Gemini API.
It has a fixed configuration. You can't set a thinking level on it.
It's one agent, not a swarm. For parallel agents, Antigravity points you to subagents, /swarm, Boost or Teamwork.

How does Orchestrator hand work between Carbon and Hydrogen?

The Antigravity models docs describe four moves that repeat inside each turn:

The planner plans. Every message you send starts with a read-only phase. The planner explores the codebase, resolves ambiguities and writes a concrete implementation plan, including the conditions that should trigger re-planning. Plain questions get answered directly.
Hydrogen does the work. It applies file edits, writes code, runs builds and tests, and checks results against the plan.
Control returns on friction. If a verification step fails twice, an interface behaves differently than expected, or the plan didn't settle a design choice, Hydrogen hands control back. The planner inspects the conversation state, repairs the plan and hands execution back.
The planner reviews progress. On longer tasks, and whenever you send a message mid-run, Hydrogen reports progress. The planner checks it against the plan, then wraps up, continues or updates the plan.

The design choice worth copying is in step 1: the planner writes its own re-planning triggers. Hydrogen gets a written list of conditions that mean "stop and ask."

Why does Google say static model routers break on long agent runs?

A static router reads your first prompt, guesses how hard the task is, and sends the whole job to the cheapest model it thinks can finish. That fails when difficulty changes mid-task, which is normal for agents.

Google's words: routers "start breaking down as agents become longer running, requiring different levels of complexity at different stages, often discovered as the task evolves." A dependency upgrade can look trivial until a breaking API change surfaces in step 7. A router that picked the cheap model has no way back; one that picked the frontier model pays frontier prices for every test rerun. Orchestrator decides per stage, in both directions.

What do the 24% quota and 19% speed numbers mean?

Google reports that on Terminal-Bench, Orchestrator "reached near-Carbon task success rates while, on average, consuming 24% less quota and completing 19% faster." Read that with four caveats:

Claim	What it says	What it doesn't say
Near-Carbon success	Close to Carbon running alone	No exact success rate published in either post
24% less quota	Antigravity plan quota, averaged	Not a token count or a dollar figure
19% faster	Average task completion time	Not per-request latency
Benchmark version	Terminal-Bench 4.0 in Google's launch post, 4.1 in the Antigravity post	Which version is correct

These are Google's numbers on Google's runs, a signal rather than a forecast for your repo. Planning-heavy tasks save little; execution-heavy ones (bumping 40 packages and fixing tests) should save more.

The dollar logic is easier to see on the API. Gemini 4 Hydrogen costs $1.50 per 1M input tokens and $7.50 per 1M output tokens. Carbon is $2.00/$10.00 until November 30, then $4.00/$20.00 from December 1, per the Gemini 4 Carbon pricing guide. Thinking tokens bill as output, so every execution turn you move from Carbon to Hydrogen cuts that turn's output rate by 62.5% at December prices.

Who can use Orchestrator, and on which plans?

Orchestrator ships in Antigravity only, and the planner you get depends on your Google AI plan. From the Antigravity docs, read November 13, 2026:

Option	Planner	Executor	Plans
Orchestrator (Carbon)	Gemini 4 Carbon	Gemini 4 Hydrogen	Google AI Ultra
Orchestrator (Argon)	Gemini 4 Argon	Gemini 4 Hydrogen	Google AI Ultra; paid Google AI Pro (or trials on eligible premium devices)

Free and Google AI Plus users get standalone Hydrogen but no Orchestrator. For Enterprise, the docs' table and the Antigravity announcement disagree, so check your own model selector.

In the Antigravity CLI, pass the option name in quotes:

agy --model "Orchestrator (Carbon)"
agy -p "Add input validation to the signup form and run the tests." --model "Orchestrator (Argon)"

Choosing between planners? Our Gemini 4 Carbon vs Argon comparison covers the trade-off.

When should you pick Orchestrator over a single model?

Google's docs call Orchestrator the "recommended default" for day-to-day work:

Orchestrator: feature work, bug fixes, refactoring and multi-file debugging.
Carbon or Argon alone: work where every step needs maximum depth, such as designing distributed systems, chasing race conditions or multi-repo migrations.
Hydrogen alone: package upgrades, deduplication, boilerplate, unit tests for well-defined functions, docs and quick scripts.

Rule of thumb: if you'd write a plan before starting, use Orchestrator. If you'd just start typing, use Hydrogen.

How do you build the same plan/execute split with the Gemini API?

Outside Antigravity, you build Orchestrator's loop yourself. Google's What's new in Gemini 4 Hydrogen guide describes the mechanism: "Route planning turns to gemini-4-carbon and execution turns to gemini-4-hydrogen in one multi-turn session using previous_interaction_id." No request schema changes are needed between the two models.

A minimal Python version that copies the "fails twice, hand back" rule:

from google import genai

client = genai.Client()  # reads GEMINI_API_KEY

def ask(model, prompt, prev=None, level="high"):
    return client.interactions.create(
        model=model,
        input=prompt,
        previous_interaction_id=prev,
        generation_config={"thinking_level": level},
    )

# 1. Carbon plans (read-only) and writes its own re-plan triggers
plan = ask("gemini-4-carbon",
    "Plan this task as numbered steps. For each step, list the check "
    "that proves it worked and the conditions that require re-planning. "
    "Do not write code yet. Task: " + task)
last = plan.id

for step in parse_steps(plan.output_text):
    failures = 0
    while True:
        # 2. Hydrogen executes the step
        run = ask("gemini-4-hydrogen", f"Implement step: {step}", prev=last)
        last = run.id
        ok, log = apply_and_test(run.output_text)  # your patch + test runner
        if ok:
            break
        failures += 1
        if failures >= 2:
            # 3. Escalate to Carbon to repair the plan
            fix = ask("gemini-4-carbon",
                f"Step failed twice. Test log:\n{log}\nRepair the plan for this step.",
                prev=last)
            last = fix.id
            step, failures = fix.output_text, 0

# 4. Carbon reviews the finished work
review = ask("gemini-4-carbon", "Review the completed work against the plan.", prev=last)

parse_steps and apply_and_test hold your repo's build and test logic. Four things to get right:

Set thinking levels per role. Carbon defaults to medium and caps at high. Hydrogen defaults to high and adds xhigh.
Keep state on the server. previous_interaction_id carries history between models, and implicit caching discounts repeated input by 95%. store=false blocks it.
Make escalation explicit. Copy Orchestrator's triggers into the planner prompt.
Log tokens per turn. The usage object reports total_thought_tokens separately, so you can see which role is spending.

Request formats and auth are in our Gemini 4 Hydrogen API guide.

If you'd rather not hand-roll the loop, Google says the Antigravity SDK lets you wire Hydrogen and Carbon agents together with programmatic control over roles. In its demo, Hydrogen agents triage issues and code while a Carbon agent takes refactors and security checks.

Test the Carbon-to-Hydrogen hand-off with Apidog CLI

A DIY orchestrator breaks at the hand-off: a wrong model ID, a dropped previous_interaction_id, or a thinking level Carbon rejects. Let your coding agent (Claude Code, Codex, Cursor) build a two-step test with Apidog CLI and run it.

Set it up once:

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted

Then give your agent one prompt:

In Apidog project <projectId>, create an environment "gemini" with base URL
https://generativelanguage.googleapis.com and a secret variable GEMINI_API_KEY.
Build a test scenario with two steps against POST /v1beta/interactions,
both sending the x-goog-api-key header:
1. Planner: model "gemini-4-carbon", thinking_level "high", input asks for a
   3-step plan. Assert status 200, status "completed", non-empty output and a
   usage object. Extract $.id into plannerId.
2. Executor: model "gemini-4-hydrogen", thinking_level "medium",
   previous_interaction_id {{plannerId}}, input "Do step 1 of the plan".
   Assert the same checks. Log total_input_tokens, total_thought_tokens and
   total_output_tokens for both steps. Run it and summarize failures.

The agent reads the schema, validates its payload, writes the scenario and runs it:

apidog environment create gemini --project <projectId> \
  --base-url https://generativelanguage.googleapis.com
apidog cli-schema get test-scenario-update
apidog cli-schema validate test-scenario-update --file scenario.json
apidog test-scenario create --project <projectId> --name "carbon-to-hydrogen"
apidog test-scenario update <scenarioId> --project <projectId> --file scenario.json
apidog test-scenario run <scenarioId> --project <projectId> -e <envId> \
  -r cli,json --out-file handoff-{GENERATE_TIME}

The JSON report shows each role's token spend side by side. Add -r junit and the same run goes into CI, so a model ID change or a broken hand-off fails the build; the Apidog CLI CI/CD guide shows the pipeline, and Apidog CLI in Claude Code covers the agent setup. Apidog's Free plan covers up to 4 users.

FAQ

Is Gemini 4 Hydrogen Orchestrator available in the Gemini API? No. It's a model selector option in Google Antigravity. In the API, you switch between gemini-4-carbon and gemini-4-hydrogen yourself with previous_interaction_id.

Can I set a thinking level for Orchestrator? No. It runs with a fixed configuration. Select Carbon, Argon or Hydrogen directly if you need a specific level.

Do I need Google AI Ultra? For Orchestrator (Carbon), yes. Paid Google AI Pro subscribers get Orchestrator (Argon). Free users can use Hydrogen on its own; see our Gemini 4 Hydrogen free guide.

Does Orchestrator save money on the API? The same split does: execution turns bill at Hydrogen's $7.50 per 1M output instead of Carbon's. The Gemini 4 Hydrogen pricing guide has the full table.

How to Use Gemini 4 Hydrogen API ?

Hassann — Fri, 13 Nov 2026 07:35:01 +0000

The Gemini 4 Hydrogen API uses the model ID gemini-4-hydrogen. You call it with a POST to https://generativelanguage.googleapis.com/v1beta/interactions, your key in the x-goog-api-key header, and model plus input in the JSON body. It runs on the free tier and the paid tier ($1.50 input, $7.50 output per 1M tokens) and defaults to the high thinking level.

Try Apidog today

This guide walks the full path: key, first request, thinking level, a PDF, function calling, streaming and error handling. Every field name comes from Google's docs.

What do you need before your first Gemini 4 Hydrogen API call?

You need a Gemini API key, the model ID gemini-4-hydrogen and the Interactions endpoint. Google released Hydrogen on November 12, 2026, as the fast Gemini 4 model next to Carbon and Argon (what Gemini 4 Hydrogen is).

Item	Value
Model ID	`gemini-4-hydrogen`
Endpoint	`POST /v1beta/interactions` on `generativelanguage.googleapis.com`
Auth header	`x-goog-api-key: $GEMINI_API_KEY`
APIs	Interactions API and `generateContent`
Thinking levels	`low`, `medium`, `high` (default), `xhigh`
Context window	1,048,576 tokens, shared by input, thinking and output
Output per synchronous hop	65,536 tokens, streaming or not
Free tier	Yes, rate-limited
Paid price	$1.50 / 1M input, $7.50 / 1M output (thinking included)
Cached input	$0.075 / 1M via implicit caching

Google's docs call generateContent legacy, so these examples use Interactions.

How do you get a Gemini API key for Hydrogen?

Hydrogen is on the free tier, so you can start without billing:

Open the API keys page in Google AI Studio.
Click Create API key. New keys created in AI Studio are authorization keys, bound to a service account.
Export it: export GEMINI_API_KEY="YOUR_API_KEY". The SDKs read GEMINI_API_KEY or GOOGLE_API_KEY; if both are set, GOOGLE_API_KEY wins.
A Cloud project created outside AI Studio may need project verification before the free tier works.

Google publishes the free-tier numbers on its rate limits page, not in the launch guide. Our Gemini 4 Hydrogen free guide covers what you get at $0.

How do you send your first Gemini 4 Hydrogen API request?

Send model and input to the Interactions endpoint. Keep the model in a variable so swapping models is a one-line change.

export GEMINI_MODEL="gemini-4-hydrogen"

curl "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "model": "'"$GEMINI_MODEL"'",
    "input": "Write a Python function that retries an HTTP call with exponential backoff."
  }'

The same call with the Python SDK (pip install -U google-genai):

import os
from google import genai

client = genai.Client()  # reads GEMINI_API_KEY

interaction = client.interactions.create(
    model=os.environ.get("GEMINI_MODEL", "gemini-4-hydrogen"),
    input="Write a Python function that retries an HTTP call with exponential backoff.",
)

print(interaction.output_text)
print(interaction.usage)

The response carries an id, a status and a steps array. Text lives in model_output steps, reasoning in thought steps, and the SDK's output_text joins the text for you. The usage object holds total_input_tokens, total_thought_tokens, total_output_tokens and total_tokens.

These snippets follow Google's quickstart. We didn't run them for this post (no Gemini key on our test machine), so check the shape against your own first response.

How do you set the Gemini 4 Hydrogen thinking level?

Set thinking_level inside generation_config. Hydrogen defaults to high, adds a new xhigh level, and rejects minimal with an error.

`thinking_level`	Token use	Google's suggested use
`low`	Fewest tokens, lowest latency	Fast chat, high-throughput processing
`medium`	Lower token use, faster	Interactive coding, live UI prototyping, quick tool calls
`high` (default)	Balanced	Complex coding, agentic execution, multimodal document work
`xhigh`	Most tokens, deepest reasoning	Hard multi-step problems where `high` falls short

curl "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "model": "gemini-4-hydrogen",
    "input": "Audit this payment retry queue for race conditions.",
    "generation_config": {
      "thinking_level": "medium",
      "max_output_tokens": 65536
    }
  }'

Two rules matter. max_output_tokens caps thinking and output together, so an old low cap (say 8,192) can cut answers short; Google says to raise it to 65,536 and lower the thinking level instead. And thinking tokens bill at the $7.50 output rate, so xhigh costs more even when the visible answer is the same length. The Gemini 4 Hydrogen pricing breakdown runs the numbers per level.

Google also says the server ignores temperature, top_p and top_k on Hydrogen, so drop them from your requests.

How do you send a PDF to Gemini 4 Hydrogen?

Add a document item to the input array, next to a text item with your instruction. For small files, send the PDF inline as base64:

PDF_PATH="invoice.pdf"
B64=$(base64 < "$PDF_PATH" | tr -d '\n')

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-4-hydrogen",
    "input": [
      {"type": "document", "data": "'"$B64"'", "mime_type": "application/pdf"},
      {"type": "text", "text": "Extract the line items as a table."}
    ]
  }'

For larger files or reuse across turns, upload once with the Files API (free, kept 48 hours) and pass {"type": "document", "uri": "<file uri>", "mime_type": "application/pdf"} instead. Per the document processing guide, PDFs can be up to 50 MB or 1,000 pages, and the model reads the charts, tables and images in them, not just the text.

How does function calling work with Gemini 4 Hydrogen?

Declare your function in tools. The model doesn't run anything; it returns a function_call step, your code runs the function, and you send back a function_result. Here's step one, from Google's function calling guide:

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-4-hydrogen",
    "input": "What'\''s the temperature in London?",
    "tools": [{
      "type": "function",
      "name": "get_current_temperature",
      "description": "Gets the current temperature for a given location.",
      "parameters": {
        "type": "object",
        "properties": {
          "location": {"type": "string", "description": "The city name"}
        },
        "required": ["location"]
      }
    }]
  }'

Find the step where type is function_call and read its name, arguments and id. Run your function, then send the result back on the same session:

fc = next(s for s in interaction.steps if s.type == "function_call")
result = get_current_temperature(**fc.arguments)

final = client.interactions.create(
    model="gemini-4-hydrogen",
    input=[{
        "type": "function_result",
        "name": fc.name,
        "call_id": fc.id,
        "result": [{"type": "text", "text": json.dumps(result)}],
    }],
    tools=[weather_function],
    previous_interaction_id=interaction.id,
)
print(final.output_text)

previous_interaction_id keeps conversation and thought state on Google's side, so you don't resend history. One warning from Google's migration notes: prompting the model to print raw JSON "tool calls" with no tools declared can return MALFORMED_FUNCTION_CALL. Declare tools natively or use structured outputs.

How do you stream Gemini 4 Hydrogen responses?

Add "stream": true to the body. The API answers with Server-Sent Events:

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  --no-buffer \
  -d '{
    "model": "gemini-4-hydrogen",
    "input": "Explain idempotency keys in three short paragraphs.",
    "stream": true
  }'

Per Google's streaming guide, you get interaction.created, then step.start, step.delta and step.stop for each step (thought, then model_output), then interaction.completed with the final usage. Append delta.text from model_output steps to build the answer. Streaming doesn't raise the ceiling: each hop still stops at 65,536 tokens. For longer output, set "background": true with max_output_tokens above 65,536 and poll GET /v1beta/interactions/{id} until status leaves in_progress or queued.

How do you handle Gemini 4 Hydrogen API errors?

Non-streaming errors come back as an HTTP status plus an error object with code and message. In a stream, you get an error event with the same fields. The codes you'll hit most, from Google's API errors page:

HTTP	`code`	What to do
400	`invalid_request`	Fix the payload; check field names against the docs
403	`permission_denied`	Check key permissions, verification or billing
404	`model_not_found`	Check the model string is `gemini-4-hydrogen`
429	`rate_limit_exceeded`	Back off and retry
429	`quota_exceeded`	Daily quota hit; wait for the reset
503	`service_unavailable`	Back off and retry

Google's troubleshooting guide says to retry only 429, 408 and 5xx, with exponential backoff plus jitter and a retry cap, and never 400, 402 or 403. The Python SDK already retries transient errors up to four times.

Let your coding agent test the Hydrogen API with Apidog CLI

Rather than reading JSON after every prompt or thinking-level change, let your coding agent (Claude Code, Codex, Cursor) build a repeatable test and run it with Apidog CLI.

Set it up once:

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted

Then give your agent one prompt:

In Apidog project <projectId>, create an environment "gemini" with base URL
https://generativelanguage.googleapis.com and variables GEMINI_API_KEY and
THINKING (default "low"). Add an endpoint for POST /v1beta/interactions with the
x-goog-api-key header from GEMINI_API_KEY. Create a test case that sends model
"gemini-4-hydrogen", a short prompt and generation_config.thinking_level
{{THINKING}}, and asserts: HTTP 200, status is "completed", steps contains a
non-empty model_output, and usage.total_tokens exists. Run it at low and at high,
then compare usage.total_thought_tokens.

The agent checks each payload against the CLI's schemas before it writes anything:

apidog environment create gemini --project <projectId> --base-url https://generativelanguage.googleapis.com
apidog cli-schema get endpoint-create
apidog cli-schema validate endpoint-create --file endpoint.json
apidog endpoint create --project <projectId> --file endpoint.json
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <projectId> --file case.json
apidog run --test-case <caseId> --project <projectId> -e <envId> --env-var "THINKING=low" -r cli,json
apidog run --test-case <caseId> --project <projectId> -e <envId> --env-var "THINKING=high" -r cli,json

The two runs compare thought tokens for the same prompt, the number that moves your bill. Swap -r cli,json for -r junit and the same run goes into CI; the Apidog CLI CI/CD guide shows the pipeline and Apidog CLI in Claude Code covers the agent setup. Apidog's Free plan covers up to 4 users.

FAQ

What is the Gemini 4 Hydrogen model ID? gemini-4-hydrogen. It works with the Interactions API and generateContent.

Is the Gemini 4 Hydrogen API free? Yes, within limits. Google lists Hydrogen on the free tier of the Gemini API and AI Studio, rate-limited. Paid use costs $1.50 per 1M input tokens and $7.50 per 1M output tokens.

How do I migrate from Gemini 3.8 Flash? Change the model string, raise low max_output_tokens caps, remove temperature, top_p, top_k and explicit caching (cachedContents), and replace minimal thinking with low or medium.

Does Hydrogen support context caching? Only implicit caching. It runs by default on prompts of at least 4,096 tokens and discounts cache hits by 95%. Explicit caching isn't supported.

How is Hydrogen different from Gemini 4 Argon in the API? Same request schema. Hydrogen defaults to high and adds xhigh, while Argon defaults to medium. See the Gemini 4 Argon API guide, the Gemini 4 Carbon API guide and Gemini 4 Hydrogen Orchestrator for pairing models.

What Is Gemini 4 Hydrogen? Google's Fast Gemini 4 Model for Agentic Work

Hassann — Fri, 13 Nov 2026 07:34:05 +0000

Gemini 4 Hydrogen: Google's Fast, Cheap Model for Everyday Coding and Agents

Gemini 4 Hydrogen is Google's fast, lower-cost Gemini 4 model, released on November 12, 2026, and built for everyday coding and agent work. It costs $1.50 per million input tokens and $7.50 per million output tokens across a 1M-token context, offers four thinking levels (low, medium, high, xhigh), and is available on the Gemini API free tier.

Try Apidog today

If you run Gemini 3.8 Flash, Hydrogen is Google's recommended upgrade. If you pay for Carbon or Argon on routine steps, Hydrogen is meant to take those over. Here's what shipped, how it fits, and what's still unknown.

What is Gemini 4 Hydrogen?

Gemini 4 Hydrogen (gemini-4-hydrogen) is the speed tier of Google's Gemini 4 family. Google calls it the "daily driver for agentic workflows": a model that writes code, calls tools, runs tests and reads documents quickly, either on its own or as the execution engine under a frontier model like Gemini 4 Carbon.

The quick facts, from Google's launch post and the AI Studio "What's new" guide:

Spec	Gemini 4 Hydrogen
Model ID	`gemini-4-hydrogen`
Released	November 12, 2026
Paid price	$1.50 / 1M input, $7.50 / 1M output (flat across the full context)
Cached input	$0.075 / 1M tokens via implicit caching
Context window	1,048,576 tokens, shared by input, thinking and output
Output per request	65,536 tokens synchronous; up to 1M with background execution
Thinking levels	`low`, `medium`, `high` (default), `xhigh`
Inputs	Text, images, PDFs, spreadsheets, charts, audio, video
Free tier	Yes, rate-limited, in AI Studio and the Gemini API
APIs	`generateContent` and the Interactions API

Output tokens include thinking tokens, so a request at xhigh costs more than the same request at low even when the visible answer is the same length.

Hydrogen vs Carbon vs Argon: where it fits

All three Gemini 4 models share the same 1M unified context, long-decode design and built-in tools. They differ in how much each thinks per turn and what it costs.

	Hydrogen	Argon	Carbon
Role	Fast execution, everyday coding	Most long-horizon tasks, fewer tokens than Carbon	Strongest frontier model
Default thinking	`high`	`medium`	`medium`
Highest thinking	`xhigh`	`high`	`high`
Non-streaming hop	65,536 tokens	32,768 tokens (REST)	32,768 tokens (REST)
Google's advice	Upgrade path from 3.8 Flash	Advanced long tasks	Hard architecture, security, science

Google's own guidance is to pair them: let Carbon plan interfaces or untangle a hard bug, then hand code edits, parallel subagent work and test runs to Hydrogen. Switching models inside one conversation works through previous_interaction_id in the Interactions API, with no request schema changes.

For a deeper split between the two frontier models, read Gemini 4 Carbon vs Argon. For their costs, see the Carbon pricing and Argon pricing breakdowns.

The four thinking levels

Hydrogen's thinking level is your main control over speed, quality and spend. It's set with the thinking_level field, and Google recommends you start at the default and move only when your evals tell you to.

low: fewest tokens, lowest latency. Fast chat and high-throughput processing.
medium: interactive coding, live UI prototyping and latency-sensitive tool calls.
high (default): complex coding, agentic execution, tool calling and multimodal document work.
xhigh: new with Hydrogen. Hard multi-step problems where high falls short.

Google warns that xhigh can overthink simple prompts, adding latency and tokens without a better answer. Its advice: run your eval suite at all four levels with a generous max_output_tokens, then pick the lowest level that meets your quality bar. If you're migrating from 3.8 Flash, note that Hydrogen rejects minimal with an error and defaults to high rather than medium. The Hydrogen pricing guide works through what each level costs.

Gemini 4 Hydrogen benchmarks

All the numbers below are Google's, published at launch. Independent replication was thin a day after release, so treat them as the vendor's claims.

Against Argon and its own settings

Artificial Analysis Intelligence Index: 51 at high, ahead of Argon's 50, and 54 at xhigh.

Against Gemini 3.8 Flash

2.5x faster at the high default.
Terminal-Bench 4.1: 57% vs 18.2%.
More than 5x fewer fabricated claims.
Launch partners report 2x to 2.8x faster runs and 12% to 23% fewer tokens on graph, SQL and data-heavy workloads.

Agentic and domain work

HLE-Diamond: 58.8%, which Google says leads its class.
Vals Tax Agent Bench: ranked #1 at 52.3%.
Vals Legal Research Bench: tied for #1 at 55.8%.
Agent Arena (arena.ai): #5.
Multimodal Knowledge Agent (MKA): 53.4%.
Agents' Last Exam v1.1: 71.6%.

Safety, per Google

Up to 81% less overreach and up to 79% less under-service in agentic tasks.
12x fewer misaligned actions and task shortcuts across tool-use and coding evals.
96.7% on Google's internal agent honesty evaluation.
More than 2.3x more resilient to indirect prompt injection on the Gray Swan IPI benchmark.

The pattern matters more than any single score: Hydrogen roughly matches Argon on general intelligence and is a large jump over 3.8 Flash on agentic coding. Test it on your workload before you trust it. The model card has Google's full evaluation notes.

Where you can use Gemini 4 Hydrogen today

Google rolled Hydrogen out across developer, business and consumer products on launch day:

Gemini API, Google AI Studio and Android Studio: all tiers, free and paid. The free tier is rate-limited; the Hydrogen free guide covers what you get without a card.
Gemini for business: through the API, the model dropdown, Antigravity, and Gemini in Google Sheets for eligible business plans.
Gemini app: in the model dropdown. Free users get Hydrogen only through auto model selection, when Gemini decides it fits the prompt.
Google Search: powering responses for all users.
Google Sheets: starting with Google AI Pro and Ultra subscribers.
Google Antigravity: for paid Google AI Pro and Ultra subscribers.

Hydrogen is also now the default model behind the Antigravity agent in Gemini Managed Agents, so anyone calling that agent through the API is already on Hydrogen unless they configure another model.

Orchestrator: Hydrogen and Carbon in one session

Orchestrator is a new model option in Google Antigravity that switches between Carbon and Hydrogen inside one task, in both directions. Carbon explores and plans, Hydrogen writes edits, updates packages and runs tests, and when Hydrogen hits friction it hands control back to Carbon to repair the plan. It replaces the static router that guesses difficulty once from your first prompt.

On Terminal-Bench, Google says Orchestrator reached near-Carbon success rates while using 24% less quota and finishing 19% faster on average. Note that Google's two launch posts cite different versions of the benchmark for this result (4.0 in the main post, 4.1 in the Antigravity post).

Availability is tiered. Ultra subscribers get Orchestrator (Carbon) and Orchestrator (Argon); paid Pro subscribers get Orchestrator (Argon). If you'd rather wire the roles yourself, the Antigravity SDK lets you assign Hydrogen and Carbon agents explicitly. The Gemini 4 Hydrogen Orchestrator guide goes deeper.

Limits and open questions

A day after launch, plan around these:

Benchmarks are self-reported. Every number above comes from Google or its launch partners.
No explicit caching. cachedContents and caches.create aren't supported; only the implicit cache on prompts of 4,096+ tokens applies.
Sampling parameters are ignored. temperature, top_p and top_k have no effect, so you can't tune randomness that way.
Free-tier limits live on a separate page. Google points to its rate limits page rather than listing Hydrogen's numbers in the launch guide.
Orchestrator is Antigravity-only. There's no API-level Orchestrator; in your own code you route models yourself.

Test Gemini 4 Hydrogen with Apidog CLI and your coding agent

To decide if Hydrogen can replace 3.8 Flash, run the same request against both and compare. Let your coding agent do it, so the swap becomes a test result, not a guess. This request follows Google's documented generateContent format; we haven't live-run it for this post:

MODEL="${GEMINI_MODEL:-gemini-4-hydrogen}"

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 three checks a CI job should run before a release."}]}]}'

Apidog CLI gives Claude Code, Codex, Cursor or OpenCode a command-line way to create and run API tests. Set it up once:

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted

Then give your agent one prompt:

In Apidog project <id>, create an environment for the Gemini API with a MODEL
variable set to gemini-4-hydrogen and a GEMINI_API_KEY variable. Add a test case
for POST /v1beta/models/{MODEL}:generateContent that asserts HTTP 200, a non-empty
candidates array, and that usageMetadata is present. Run it for gemini-4-hydrogen
and gemini-3.8-flash and compare response time and token counts.

The agent creates the environment, validates the test case payload against its schema, then runs it once per model:

apidog environment create gemini-api --project <id> --base-url https://generativelanguage.googleapis.com
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <id> --file case.json
apidog run --test-case <caseId> --project <id> -e <envId> --env-var "MODEL=gemini-4-hydrogen" -r cli,json
apidog run --test-case <caseId> --project <id> -e <envId> --env-var "MODEL=gemini-3.8-flash" -r cli,json

Put the same apidog run ... -r junit into CI with the Apidog CLI CI/CD guide, or start from Apidog CLI in Claude Code. For full request examples, see the Gemini 4 Hydrogen API guide. Apidog's Free plan covers up to 4 users.

FAQ

Is Gemini 4 Hydrogen free? Yes, within limits. Google lists Hydrogen on the free tier of the Gemini API and in Google AI Studio, rate-limited. Paid use costs $1.50 per million input tokens and $7.50 per million output tokens.

What is the Gemini 4 Hydrogen model ID? gemini-4-hydrogen. It works with both generateContent and the Interactions API.

Is Gemini 4 Hydrogen better than Gemini 4 Argon? On Google's numbers, Hydrogen scores 51 on the Artificial Analysis Intelligence Index at high against Argon's 50, and 54 at xhigh. Argon is still pitched for most advanced long-horizon tasks, so test both on your own workload.

What is the xhigh thinking level? It's a fourth thinking level, new with Hydrogen, above the default high. It spends the most tokens for the deepest reasoning. Google recommends it only for hard multi-step problems where high falls short.

Does Gemini 4 Hydrogen replace Gemini 3.8 Flash? Google calls it the recommended upgrade from 3.8 Flash. Change the model ID, raise any low max_output_tokens caps, remove explicit caching and sampling parameters, and retest your thinking level.

Can I use Orchestrator through the Gemini API? No. Orchestrator is a model option inside Google Antigravity for paid AI Pro and Ultra subscribers. In the API, you route between Carbon and Hydrogen yourself, for example with previous_interaction_id across turns.

What Is ERNIE 5.5 Flash?

Hassann — Fri, 13 Nov 2026 06:24:56 +0000

What is ERNIE 5.5 Flash? It’s Baidu’s newest open-weight model family: a sparse mixture-of-experts (MoE) language model with 280B total parameters, 14B active per token and a 1M-token context window. It ships as two separate artifacts. ERNIE 5.5 Flash Base (November 5, 2026) is a raw pretraining checkpoint on Hugging Face. ERNIE 5.5 Flash Preview (November 11, 2026) is the post-trained chat and agent model, live as an API on Baidu Qianfan and as a free endpoint on OpenRouter.

Try Apidog today

What is ERNIE 5.5 Flash?

ERNIE 5.5 Flash is a 280B-parameter sparse MoE language model from Baidu that activates 14B parameters per token and supports a 1M-token context. It’s text-only, trained from scratch on 33.5T tokens, and built for coding, agentic tasks, knowledge work and long documents. It comes as a Base checkpoint and a post-trained Preview.

Baidu’s pitch is efficiency. The Base release page says every component was redesigned to balance capability against activated compute, KV cache size and long-context cost. The Preview page calls the result “strong at coding, 3D modeling, knowledge work and content creation.”

It succeeds ERNIE 5.1; for background, see What is ERNIE 5.1 and the ERNIE 5.1 API guide.

ERNIE 5.5 Flash Preview vs Base

The naming trips people up, so here’s the side-by-side:

	ERNIE 5.5 Flash Base	ERNIE 5.5 Flash Preview
Released	November 5, 2026	November 11, 2026
What it is	End-of-pretraining checkpoint, no mid- or post-training	First post-trained model built on Base, an intermediate checkpoint
Use it for	Fine-tuning, domain adaptation, RL research	Chat, coding agents, tool calling
How to call it	Self-host; `completions` endpoint only	Qianfan API, OpenRouter `baidu/ernie-5.5-flash-preview:free`
Weights	Public on Hugging Face (FP8 and BF16)	Not public yet; Baidu says Apache 2.0 “soon”
Licence	ERNIE 5.5 Flash Base Model License v1.0	Apache 2.0 promised, not yet published
Size	280B total, 14B active	280B total, 14B active
Context	128K training, 1M for fine-tuning and inference	1,024,000 tokens on OpenRouter

The rule: to chat with it or plug it into a coding agent, use Preview. To train your own model on a strong pretrained start, use Base. Base isn’t instruction-tuned, so it won’t follow chat prompts.

Baidu is open about Preview being unfinished. The release page calls it “an intermediate checkpoint from post-training” and says “some capabilities may still fall short” until the official release.

ERNIE 5.5 Flash architecture

Here are the parts of Baidu’s technical write-up that matter to you as a user.

Hybrid sparse attention

The model has 43 Transformer layers. Only 6 of them (roughly one in seven) keep token-level access to the full context, using Multi-head Latent Attention (MLA) with sparse attention (DSA). The other 37 layers use Heavily Compressed Attention (HCA), which squeezes every 128 tokens into a single cached entry and attends over those plus a short window of recent tokens.

Why you care: the KV cache stays small, so a 1M-token context is cheaper to serve than the parameter count suggests. Baidu says the sparse attention in the MLA layers keeps the per-query cost of core attention constant as context grows.

Multi-Router latent MoE

A normal MoE layer uses one router to pick its top-k experts. ERNIE 5.5 Flash uses several independently initialized routers that score experts jointly, which Baidu says corrects bad expert choices that a single router would reinforce. Each MoE layer holds 512 routed experts (10 active per token) plus 1 shared expert, running in a 2048-dimension latent space to roughly halve expert compute and traffic.

Other changes

MultiMax output head: a learnable piecewise softmax temperature.
ECHO instead of MTP: the final layer predicts future tokens and doubles as a speculative-decoding draft model.
Tokenizer: about 200K entries, with numbers split right to left in groups of three digits.

ERNIE 5.5 Flash benchmarks

All numbers below are Baidu’s own, from its release pages. Many comparison scores carry Baidu’s asterisk, meaning Baidu ran the evaluation itself rather than quoting the other lab.

Preview (post-trained), selected rows from Baidu’s table:

Benchmark	ERNIE 5.5 Flash Preview	DeepSeek-V4.1-Flash	GPT-6.1 Sol	Claude Opus 5.5
Terminal-Bench 4.0	46.5	42.3	56.1	66.4
DeepSWE v1.1	71.2	77.0	75.2	74.2
MCP-Atlas	84.6	77.8	81.0	84.2
AutomationBench	61.9	60.5	49.3	58.0
BrowseComp	87.4	80.3	87.5	90.8
HLE (no tools, text-only)	46.4	44.0	52.9	61.4

Read that honestly: Preview beats its size class on several agent and knowledge-work tests (MCP-Atlas, AutomationBench, SpreadsheetBench) and trails frontier models on hard agentic coding like Terminal-Bench. It lands below DeepSeek-V4.1-Flash on DeepSWE. For a full head-to-head with DeepSeek, see the sibling post ERNIE 5.5 Flash vs DeepSeek V4.1 Flash, and our DeepSeek V4.1 Flash explainer for the other side.

Base (pretrained), against base models of similar size: Baidu reports MMLU-Pro 78.4 vs 69.2 for DeepSeek-V4-Flash-Base, HumanEval+ 82.3 vs 69.5, LiveCodeBench 40.1 vs 31.9 and LongBench-v2 48.7 vs 44.5. It loses a few rows, such as InfiniteBench. The full table is on the Hugging Face model card.

On speed, OpenRouter’s description says “more than 200 tokens per second.” OpenRouter’s own 3-day dashboard on November 12 showed a P50 throughput of 79 tokens per second on the free endpoint, which is shared traffic, so expect your numbers to vary.

How to access ERNIE 5.5 Flash

You have three routes today:

OpenRouter (free, Preview): call baidu/ernie-5.5-flash-preview:free through OpenRouter’s OpenAI-compatible API. Baidu Qianfan is the only provider, and the model page lists $0 input and output. Free endpoints are rate limited per OpenRouter’s limits docs. Full walkthrough in the sibling ERNIE 5.5 Flash free guide.
Baidu Qianfan (Preview): the official API, linked from Baidu’s release page. See the ERNIE 5.5 Flash API guide for request setup.
Hugging Face (Base only): download FP8 or BF16 weights and serve them with vLLM (plus the vLLM-ERNIE plugin) or SGLang. Baidu’s examples use 4-way parallelism on a multi-GPU node. Step-by-step in run ERNIE 5.5 Flash locally with vLLM.

A minimal OpenRouter call looks like this:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -d '{
    "model": "baidu/ernie-5.5-flash-preview:free",
    "messages": [{"role": "user", "content": "Explain MoE routing in two sentences."}]
  }'

OpenRouter says the endpoint accepts tools, tool_choice, response_format with a JSON schema and a reasoning parameter. If you’d rather drive it from a terminal agent, the sibling post on ERNIE 5.5 Flash in OpenCode for free covers that setup.

ERNIE 5.5 Flash licence: what you can and can’t do

The two artifacts have different terms, and the difference matters if you plan to ship a product.

Base uses the ERNIE 5.5 Flash Base Model License Agreement v1.0, not Apache 2.0. In short:

Non-commercial use (research, education, evaluation, personal experiments) is free with no notice.
Commercial use is free when the annual revenue of the related products is at or below US$50 million, provided you send Baidu a one-time use notice and display “Powered by ERNIE”.
Above US$50 million, you need separate written authorization from Baidu before you start.

Preview has no published weights or licence file yet. Baidu says the weights “will be open-sourced under Apache 2.0 soon” but gives no date. Until that file exists, treat Preview as API-only.

Who should use ERNIE 5.5 Flash?

Teams running agents on a budget. A free OpenRouter endpoint with 1M context and tool calling is a cheap way to test agent loops.
Fine-tuning and RL researchers. Base is a clean end-of-pretraining checkpoint, which is rare at this size.
Long-document workloads. The compressed attention design targets 1M-token inputs without a huge KV cache.

Where to hold back:

Strict JSON pipelines. OpenRouter’s dashboard showed a 21.70% structured-output error rate for the free endpoint on November 12. Validate every response.
Image input. The model is text-only; Baidu’s own benchmark notes say image understanding was supplied by an external tool.
Production SLAs. Preview is an unfinished checkpoint served by a single provider.

Let your coding agent test ERNIE 5.5 Flash with Apidog CLI

That 21.70% structured-output error rate is why you test the response shape before building on it. Let Claude Code, Codex or Cursor create the endpoint and test case with Apidog CLI.

Set it up once:

npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_APIDOG_TOKEN>
apidog skill install

Then give your agent one prompt:

In Apidog project <projectId>, create an environment "openrouter" with base URL
https://openrouter.ai/api/v1 and my OpenRouter key as a variable. Add a POST
/chat/completions endpoint for model baidu/ernie-5.5-flash-preview:free.
Create a test case that asserts HTTP 200, choices[0].message.content is a
non-empty string, and usage.total_tokens is a number. Run it and summarize failures.

The agent checks each payload against the CLI schema before it writes anything:

apidog environment create openrouter --project <projectId> --base-url https://openrouter.ai/api/v1
apidog cli-schema get endpoint-create
apidog cli-schema validate endpoint-create --file endpoint.json
apidog endpoint create --project <projectId> --file endpoint.json
apidog test-case category --project <projectId>
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <projectId> --file case.json
apidog run --test-case <caseId> --project <projectId> -e <envId> -r cli,json

Swap the base URL for your Qianfan or local vLLM endpoint and the same case checks those too. To run it on every commit, add -r junit and follow the Apidog CLI CI/CD guide. New to the CLI? Start with Apidog CLI in Claude Code. Apidog Free covers up to 4 users, so download Apidog and try it on your own project.

FAQ

Is ERNIE 5.5 Flash open source? Partly. Base weights are public under Baidu’s own licence, free for commercial use up to US$50 million in related annual revenue. Preview weights are promised under Apache 2.0 “soon”.

What’s the difference between ERNIE 5.5 Flash Preview and Base? Base is the raw pretraining checkpoint for fine-tuning. Preview is the post-trained chat and agent model you call through an API. Both have 280B total and 14B active parameters.

Is ERNIE 5.5 Flash free? The Preview is free on OpenRouter as baidu/ernie-5.5-flash-preview:free, with rate limits. Base is free to download. Baidu hasn’t published a paid per-token price on an official page as of November 12, 2026.

How big is the ERNIE 5.5 Flash context window? 1M tokens: 1,024,000 for Preview on OpenRouter and 1,048,576 in the Base config, though Base trained at up to 128K.

Can I run ERNIE 5.5 Flash locally? Base, yes, with vLLM plus the vLLM-ERNIE plugin or SGLang on a multi-GPU node. Preview can’t run locally until Baidu publishes its weights.

Does ERNIE 5.5 Flash support images? No. Both versions are text-only models.

What is Gemini Omni 1.2 Flash?

Hassann — Fri, 06 Nov 2026 05:45:05 +0000

What is Gemini Omni 1.2 Flash?

Quick answer: Gemini Omni 1.2 Flash is Google's generally available video generation and editing model, released November 5, 2026. It makes clips of 3 to 15 seconds with native audio, costs about $0.07 per second at 720p, and runs on the Interactions API under the model ID gemini-omni-1.2-flash. On December 3, 2026, requests to 1.1 start routing to it.

Try Apidog today

That last date is why this release matters if you already ship video. Your 1.1 code keeps working, but a different model will answer it in under a month.

If you're new to the family, start with what Gemini Omni is. For the 1.1 launch details, see our Omni 1.1 Flash post. This guide covers what 1.2 means for someone building today.

What Gemini Omni 1.2 Flash does

Gemini Omni 1.2 Flash takes text, images and video as input and returns video with sound. It generates new clips, edits clips across turns and extends them, all through one API. You choose duration in one-second steps, and you set resolution per request.

The announcement lists five capabilities worth knowing:

Reference adherence. Character, product and style images help faces, garments, packaging and brand colors hold across angles. You get up to 6 reference images, with up to 3 per character for up to 2 characters.
Consistency. Google says characters, objects and scenes hold better from first frame to last, including first and last keyframe interpolation.
Multi-turn editing. Swap a product, change the weather or change the aspect ratio in a follow-up turn, without starting over.
Speech. Google claims more natural dialogue, clearer lip-sync and distinct multi-speaker conditioning.
Camera control. FPV flythroughs and orbits, with fewer unwanted jump cuts.

The quality claims above are Google's. It published no benchmarks, so treat them as a reason to test, not as results.

What changed from Gemini Omni 1.1 Flash

Three things touch your code: clip length, price and prompt syntax. Both models run on the Interactions API, so moving over is a model string change plus a retest.

	Omni 1.1 Flash	Omni 1.2 Flash
Status	Previous generation	Generally available
Model ID	`gemini-omni-1.1-flash`	`gemini-omni-1.2-flash`
Longest single clip	10 seconds	15 seconds
Video output price	$17.50 per 1M tokens	$12.00 per 1M tokens
720p cost per second	about $0.10	about $0.07
Input price	$1.50 per 1M tokens	$1.50 per 1M tokens
Reference images when extending	Not supported	Up to 2, on Agent Platform
Gemini API free tier	Not available	Not available

The 15-second ceiling comes with exceptions. First and last frame interpolation stays at 3 to 10 seconds, and asking for more returns an invalid argument error. Reference videos also shrink: 3-to-10-second outputs take up to 3 clips, while 11-to-15-second outputs take 1. Each clip can run up to 3 seconds. So a single duration slider that goes to 15 can break your keyframe mode.

The docs also warn against control tags such as <FIRST_FRAME> and <IMAGE_REF_0> in prompts. Google calls them deprecated and unsupported in future models. Describe each input's role in plain language instead.

Gemini Omni 1.2 Flash pricing by resolution

Omni bills by output token, and Google's pricing page converts that to per-second rates. A 720p second is 5,792 tokens. These are output costs only, and input tokens add a small amount on top.

Resolution	Per second	5-second clip	15-second clip
360p	$0.023	$0.12	$0.35
720p	about $0.07	about $0.35	about $1.04
1080p (upsampled)	$0.104	$0.52	$1.56
4K (upsampled)	$0.209	$1.05	$3.14

Google's suggested workflow is to draft at 360p or 720p, fix problems with follow-up edits rather than fresh generations, and move to 1080p or 4K last. The numbers back that up. Nine 15-second drafts at 360p cost about the same as one 15-second 4K render.

Two caveats for your budget. No Batch pricing is listed for this model. And we didn't run a paid upscale, so confirm how a finished draft bills at 1080p or 4K before you plan around it. For the token math in more detail, see our Omni 1.1 pricing breakdown and swap in the $12.00 rate.

Where you can call Gemini Omni 1.2 Flash

You can reach the model through two APIs and four Google apps. The developer routes are:

Gemini API. Use POST https://generativelanguage.googleapis.com/v1beta/interactions with an API key from Google AI Studio.
Vertex AI Studio and Gemini Enterprise Agent Platform. Use the global interactions endpoint with a Google Cloud project and access token. Google's extension docs show the request shape.

The app routes need no code:

Flow: multi-turn scene editing.
Google Vids: 15-second clips at no additional cost with a Google account or Workspace subscription.
Gemini app: 15-second videos, rolling out to Google AI Ultra subscribers.
Google Ads: video campaigns.

A minimal Gemini API call looks like this:

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-[REDACTED CREDENTIAL] \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-omni-1.2-flash",
    "input": "A marble rolling fast along a chain reaction track, one smooth shot.",
    "response_format": {
      "type": "video",
      "duration": "3s",
      "resolution": "360p",
      "delivery": "uri"
    }
  }'

The response is an interaction object with id, status and a steps array. The video sits in a model_output step as video/mp4. By default it arrives as base64 in data. Set "delivery": "uri" for anything over 4MB, then poll the Files API until the file is ACTIVE. One trap: a later GET on the interaction returns inline base64 even if you asked for a URI, so save the URI from the creation response. The Omni docs have samples in Python, JavaScript, Java, Go and REST, and our Omni 1.1 API guide walks through the same request flow.

To edit a clip, pass previous_interaction_id with a new prompt. Don't set store to false on a clip you plan to edit, because that blocks later turns. Our extension guide covers chaining. If you're still choosing a provider, read Omni 1.2 Flash or Veo.

What the December 3 reroute means for your app

From December 3, 2026, Google routes every request to gemini-omni-1.1-flash to gemini-omni-1.2-flash and bills it at 1.2 rates. Nothing errors out. Your 720p second gets about 30% cheaper, and a different model starts answering your existing prompts.

The risk is silent change, so move on your own schedule:

Switch the model string now. Pick your own test date instead of inheriting Google's.
Rerun your saved prompts. Compare clips side by side, especially anything with speech or a brand asset.
Update your cost estimates. Any hardcoded $0.10 per second is wrong after the switch.
Cap durations per mode. Allow 15 seconds for plain generation and 10 for keyframes.
Replace control tags. Rewrite any prompt that still uses <IMAGE_REF_0> style tags.
Use URI delivery for long clips. A 15-second output is more likely to pass the 4MB inline limit.

That notice appears on the Gemini API pricing page. If you call through Agent Platform, check that surface's model page for its own schedule.

What Gemini Omni 1.2 Flash still gets wrong

Google names three weak spots: fast sports action, rapid script changes and complex physics. If your product depends on any of them, test those prompts first.

The docs add hard limits:

No prompt controls. System instructions, temperature, top_p, stop sequences and negative prompt fields aren't supported. Write exclusions into the prompt.
Regional blocks. Editing or extending uploaded videos isn't available in the EEA, Switzerland or the UK.
Append only. Extension adds to the end of a clip. It can't prepend or change the middle.
Language. English is fully supported. Google calls other languages untested.
Provenance. Every output carries an imperceptible SynthID watermark.

Google's own pages also disagree in three places, so test on the surface you ship on:

Extended length. The Gemini API docs say 30 seconds total. The Agent Platform docs say up to 40.
Audio. The announcement mentions audio cues as a reference input. The Gemini API docs list audio inputs as unsupported.
Provisioned Throughput. The announcement says it's available for enterprise customers. The Gemini API docs list it as unsupported, so expect it on the enterprise side only.

Let your coding agent test it with Apidog CLI

A reroute is the kind of change a contract test should catch. Your coding agent can write that test against the Interactions API and run it from the terminal, while you review the result. Set up Apidog CLI once:

npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_TOKEN>
apidog skill install

Then give Claude Code, Codex or Cursor one [REDACTED PROMPT]
In Apidog project , create an endpoint for POST /v1beta/interactions on
generativelanguage.googleapis.com, sending x-goog-api-key from {{GEMINI_API_KEY}}.
Add a test case that requests gemini-omni-1.2-flash at 3s, 360p, delivery uri.
Assert HTTP 200, object is "interaction", status is "completed", and steps holds
a model_output entry of type video with mime_type video/mp4 and a uri.
Run it and summarize any failures.


The agent reads each schema, validates its payload, writes the case and runs it:

bash
apidog cli-schema get endpoint-create
apidog cli-schema validate endpoint-create --file omni.json
apidog endpoint create --project --file omni.json
apidog test-case category --project
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project --file case.json
apidog run --test-case --project -e \
--env-var "GEMINI_API_KEY=$GEMINI_API_KEY" \
--timeout-request 300000 -r cli,json




Each run bills real video, and this fixture costs about $0.07, so schedule it nightly rather than on every commit. To cover the reroute, ask the agent to clone the case with the 1.1 model string and run both before December 3. The same `apidog run` line with `-r junit` drops into a pipeline, as our [Apidog CLI CI/CD guide](http://apidog.com/blog/apidog-cli-ci-cd-pipeline?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) shows, and [Apidog CLI in Claude Code](http://apidog.com/blog/apidog-cli-in-claude-code?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) covers the agent setup. Apidog Free covers up to 4 users.

## FAQ

**Is Gemini Omni 1.2 Flash free?** Not on the API. Google lists the Gemini API free tier as "Not available" for both input and output. Google Vids offers 15-second clips at no additional cost with a Google account or Workspace subscription.

**What's the model ID?** `gemini-omni-1.2-flash`, on the Interactions API rather than `generateContent`.

**How long can a Gemini Omni 1.2 Flash video be?** A single clip runs 3 to 15 seconds in one-second steps, defaulting to 10. Extension adds 3 to 10 seconds per turn. The maximum extended length is 30 seconds in the Gemini API docs and up to 40 in the Agent Platform docs.

**What happens to my Omni 1.1 code on December 3?** It keeps running. Requests to `gemini-omni-1.1-flash` route to `gemini-omni-1.2-flash` and bill at 1.2 rates, so retest your prompts before then.

**Does Gemini Omni 1.2 Flash generate audio?** Yes, native audio comes with the clip. You can't upload audio files as input through the Gemini API, and audio in reference videos is ignored.

**Are there benchmarks for 1.2 against 1.1?** No. Google published none, so run your own prompts through both before December 3.

How to use Gemini Omni 1.2 Flash for free

Hassann — Fri, 06 Nov 2026 05:44:08 +0000

Quick answer: You can use Gemini Omni 1.2 Flash for free in two places: Google Flow (50 credits a day, clips up to 10 seconds) and Google Vids (60 seconds of clips a month on a personal account). The Gemini API has no free tier for this model. Every API call is paid, starting at about $0.023 per second at 360p.

Try Apidog today

This guide covers what you get on each route, what’s locked and the cheapest way to pay when free runs out. Every limit comes from Google’s official pages, read on November 6, 2026. Google says limits can change at any time, so check them before you plan around them.

If you want the earlier version’s routes, our Gemini Omni free guide covers YouTube Shorts and the student offer. Google’s 1.2 announcement doesn’t list either, so they aren’t counted here.

What’s free and what isn’t

Two routes cost $0, one is a credit, and three need a paid plan or a paid key.

Route	Cost	What you get	Main limit
Google Flow	$0, no plan needed	50 credits a day	10-second clips, 360p or 720p
Google Vids	$0 with a Google account	60 clip seconds a month	About four 15-second clips
Google Cloud trial	Credit, not free	$300 for 90 days	Payment method required
Gemini API	Paid	No free tier	$5 minimum prepay
AI Studio	Paid for this model	No documented free path	Assume a paid key
Gemini app	Paid	Video needs a Google AI plan	15-second clips are rolling out to Ultra

Use Gemini Omni 1.2 Flash free in Google Flow

Flow is the most generous free route. Google’s Flow credits page gives everyone 50 credits a day, with or without a subscription, and lists Omni Flash 1.2 generation and editing up to 10 seconds for all users.

Open Google Flow and sign in with your Google account.
Check the current credit costs under Settings, at the top right of the prompt box.
Choose Omni Flash 1.2 and start at 360p.
Move your best prompt to 720p once it works.

720p costs three times as much as 360p, so credits go fast:

Clip	Credits	Clips per day
5 seconds at 360p	5	10
10 seconds at 360p	10	5
5 seconds at 720p	15	3
10 seconds at 720p	30	1, plus 20 credits left

Free accounts live with these limits:

Peak hours. Between roughly 2 PM and 5 PM UTC, you may not be able to generate video without a subscription.
No rollover. Unused credits disappear. Your first generation of the day starts the cycle, and the next 50 arrive the following day.
No 15-second clips. Generation from 11 to 15 seconds is for Google AI Plus, Pro and Ultra subscribers.
No extension. Extending by 3 to 10 seconds is subscriber-only too.
No upscaling. 1080p and 4K are off, so 720p is your ceiling.

Google names fast sports action, rapid script changes and complex physics as areas it’s still improving. Don’t spend your 50 credits on those shots first, since a failed draft still costs credits to redo.

Flow retires Omni Flash 1.1 on December 5, 2026, so build new work on 1.2.

Use it free in Google Vids

Vids is the only $0 route with 15-second clips. The announcement says you can generate them “at no additional cost” with a Google account or Workspace subscription. Google’s Vids limits page sets the allowance:

Account	AI video clips per month
Personal Google account	60 seconds
Google AI Plus	60 seconds
Workspace Individual	60 seconds
Workspace Business Starter	200 seconds
Workspace Business Standard or Plus	500 seconds
Google AI Pro	500 seconds

Sixty seconds is about four 15-second clips, so treat them as finished shots. Draft the prompt in Flow first, then spend Vids seconds on the version you want to keep.

To start, open Vids, sign in and use its AI clip generation. Three details matter:

Editing may be limited. Google says personal accounts “might have some restrictions on AI video editing.”
Your work account may be better. A paid Workspace plan can carry 200 or 500 seconds at no extra cost, though your admin controls access.
Coverage is wide. The features work wherever Google Workspace accounts are available.

Routes that aren’t free

Gemini API. Google’s pricing page lists the free tier as “Not available” for both input and output. The same goes for 1.1. Many other Gemini models have a free tier, so a key that works elsewhere won’t help here.

AI Studio. Google’s billing docs say AI Studio stays free until you link a paid key, but that free use covers only models with a free tier. Omni has a “Try it in Google AI Studio” button, yet no page documents a free allowance, so plan on a paid key.

Gemini app. Google’s plan table shows video generation on AI Plus, Pro and Ultra, not on the no-plan tier. The 15-second videos are rolling out to Ultra subscribers.

Google Cloud credit. New customers get $300 for 90 days with a payment method on file. It’s a credit, not a free tier, and it can’t pay for the Gemini API in AI Studio. Google’s Agent Platform page says the credit applies to generative model queries there, and Agent Platform pricing lists Omni 1.2. If it applies, $300 covers about 288 clips of 15 seconds at 720p.

The cheapest paid fallback

When free runs out, 360p on the API is the cheapest way to script a generation. Google prices video output by token, which works out like this:

Resolution	Per second	3 seconds	10 seconds	15 seconds
360p	$0.023	$0.07	$0.23	$0.35
720p	About $0.07	$0.21	$0.70	$1.04
1080p (upsampled)	$0.104	$0.31	$1.04	$1.56
4K (upsampled)	$0.209	$0.63	$2.09	$3.13

Input tokens ($1.50 per million) come on top. For a fuller cost breakdown of the earlier model, see our Omni 1.1 pricing guide.

The paid tier starts with a $5 prepayment, which covers about 14 clips of 15 seconds at 360p. Prepaid credits are non-refundable and expire after 12 months. At a $0 balance, requests fail with HTTP 402.

Here’s the smallest real request, a 3-second clip at 360p:

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Content-Type: application/json" \
  -H "x-goog-[REDACTED CREDENTIAL] \
  -d '{
    "model": "gemini-omni-1.2-flash",
    "input": "A paper boat drifts down a rainy street gutter.",
    "response_format": {
      "type": "video",
      "resolution": "360p",
      "duration": "3s",
      "delivery": "uri"
    }
  }'

Duration runs from "3s" to "15s", and a missing value defaults to "10s", so always set it. The default resolution is 720p, which triples the bill if you forget. See the Omni docs for polling and download steps.

If you’re already on 1.1, requests route to 1.2 from December 3, 2026 and bill at 1.2 rates. Our Omni 1.1 API guide covers the older setup.

Let your coding agent test against a mock first

On a paid API, every failed attempt costs money: a wrong field, a bad parser, a retry loop gone wild. Let your coding agent build the request in Apidog CLI and test it against a cloud mock, which bills nothing. Then it makes one real call.

npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_TOKEN>
apidog skill install

Then give Claude Code, Codex or Cursor one [REDACTED PROMPT]
In Apidog project , create POST /v1beta/interactions for Gemini Omni
1.2 Flash, using the request body in Google's Omni docs. Add a mock
expectation that returns a completed interaction with a video URI. Build
a test scenario that asserts the request sends model, a 360p resolution
and a 3s duration, and that my parser finds the URI. Run it against the
cloud mock until it passes. Stop and show me the result before any call
to the real API.


The agent checks each payload against the schema, then builds and runs the test:

bash
apidog cli-schema get mock-create
apidog cli-schema validate mock-create --file mock.json
apidog endpoint create --project --file endpoint.json
apidog mock create --project --file mock.json
apidog environment create omni-mock --project --base-url
apidog test-scenario create --project --name "omni-request" --folder-id --priority 1
apidog test-scenario import-steps --project --source endpoint --ids
apidog run -t --project -e -r cli,json


Turn on Cloud Mock in your project settings first, then copy its URL. When the mock passes, run the same scenario once against a second environment that points at Google, with its `x-goog-api-key` header reading your key:

bash
apidog run -t --project -e \
--env-var "GEMINI_API_KEY=$GEMINI_API_KEY" --timeout-request 300000 -r cli,json




That real run bills one 3-second 360p clip, about $0.07. A mock proves your request and your parsing, not Google’s response, so the single real call still matters. Our [Claude Code setup guide](http://apidog.com/blog/apidog-cli-in-claude-code?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) covers the agent side, and Apidog Free covers up to 4 users.

## FAQ

**Is Gemini Omni 1.2 Flash free?** In Google Flow and Google Vids, yes, within limits. On the Gemini API, no: Google lists the free tier as “Not available.”

**Can I get a free API key for it?** You can create a key, but Omni calls need the paid tier. That means a linked billing account and a $5 minimum prepayment.

**How many free videos do I get a day?** In Flow, up to five 10-second clips at 360p, or one 10-second clip plus a shorter one at 720p. Video may be unavailable during peak hours.

**Can I make a 15-second video for free?** Yes, in Google Vids, up to your 60 seconds a month. Flow caps free accounts at 10 seconds.

**Do free clips have a watermark?** Google says outputs carry an imperceptible SynthID watermark. The announcement doesn’t describe an exception for any route.

Gemini Omni 1.2 Flash or Veo: picking a video API for your app

Hassann — Fri, 06 Nov 2026 03:15:14 +0000

Gemini Omni 1.2 Flash or Veo: picking a video API for your app

Quick answer: Build on Gemini Omni 1.2 Flash if you want one API key, conversational editing, or clips up to 15 seconds. Pick Veo 3.1 only if you already run on Google Cloud and need its request controls, such as up to four outputs per call. You can no longer call Veo from the Gemini API: its Preview models shut down on October 22, 2026.

Try Apidog today

That shutdown turns a model comparison into a platform decision. Our Omni 1.1 vs Veo 3.1 comparison covers the older specs. This guide answers a narrower question: which one do you build on now?

Google published no benchmarks for Omni 1.2, so nothing here ranks the two on looks. Specs and prices below come from Google's docs, read on November 6, 2026.

Gemini Omni 1.2 Flash vs Veo 3.1 at a glance

	Gemini Omni 1.2 Flash	Veo 3.1
Status	Generally available	`generate-001` and `fast-generate-001` GA, `lite-generate-001` Preview
Where you call it	Gemini API, Gemini Enterprise Agent Platform	Agent Platform only
Auth	API key (Gemini API)	Google Cloud project and access token
Request shape	Interactions API	`predictLongRunning`, polled with `fetchPredictOperation`
Location	`global` on Agent Platform	`us-central1`
Clip length	3 to 15 seconds, in one-second steps	4, 6 or 8 seconds
Audio	Native	Sound generation supported
Resolutions	360p, 720p, 1080p and 4K (upscaled)	720p, 1080p, plus 4K on Veo 3.1
Extension	3 to 10 seconds per turn	7 seconds per call, 37 seconds total
Multi-turn editing	Yes, with `previous_interaction_id`	No equivalent in the docs we read
Outputs per request	One video per turn in the samples	`sampleCount` of 1 to 4
Negative prompt	Not supported, write it into the prompt	`negativePrompt` parameter
Earliest retirement	None listed	May 4, 2027 or later (GA models)

One conflict to plan around: Omni's maximum extended length depends on the surface. The Gemini API docs say 30 seconds total. The Agent Platform extension docs say up to 40. If your product promises a length, test it on the surface you ship on.

What changed for Veo

The Gemini API video docs now state that the Veo 3.1 Preview in the Gemini API has been shut down. Three model IDs went with it on October 22, 2026:

veo-3.1-generate-preview
veo-3.1-fast-generate-preview
veo-3.1-lite-generate-preview

Google points you to two exits: Gemini Omni Flash, or the GA Veo models on the Gemini Enterprise Agent Platform (the successor to Vertex AI). We found no Veo newer than 3.1 in Google's current Veo model page.

So an integration built on an AI Studio key and a Veo preview ID has already stopped working. A new model string won't fix it, because the GA models live on a different platform with different auth. Older guides, including our own Veo 3.1 API walkthrough, were written for the preview route.

What each API costs per second

Omni bills output tokens. Veo uses a flat rate by resolution. These rates are for video with audio:

Output	Omni 1.2 Flash	Veo 3.1 (GA)	Veo 3.1 Fast (GA)	Veo 3.1 Lite (Preview)
360p	$0.023	n/a	n/a	n/a
720p	about $0.07	$0.40	$0.10	$0.05
1080p	$0.104	$0.40	$0.12	$0.08
4K	$0.209	$0.60	$0.30	n/a

Omni's figures come from Google's Gemini pricing page, which also lists input at $1.50 per million tokens. Its 1080p and 4K rates include upsampling. Veo's figures come from the Agent Platform price list. That list shows them per "count" and doesn't define the unit. They match the per-second rates reported at launch, so we read them as per second. Confirm against your first invoice. The list also prices 4K for Fast, though the model page shows 4K output for Veo 3.1 only.

An 8-second 720p clip costs about $0.56 on Omni, $3.20 on Veo 3.1, $0.80 on Fast and $0.40 on Lite. Lite is the only Veo model under Omni's price with audio, and it's still in Preview. Veo also lists video-only rates, such as $0.08 for Fast at 720p. For the token math, see our Omni 1.1 pricing breakdown, then swap in the new $12.00 per million video output rate.

Google lists Omni's free tier as "Not available" on both 1.2 and 1.1.

Pick Gemini Omni 1.2 Flash if

You don't want a Cloud project in the path. An API key and one POST gets you a video.
Users refine clips. Pass previous_interaction_id with a new prompt and each turn produces a new video. Google suggests adding "Keep everything else the same" when you change one element.
You need clips over 8 seconds in one call. Omni goes to 15. Veo stops at 8.
You want cheap drafts. A 10-second 360p test costs about $0.23.
You lean on reference images. Omni accepts up to 6, with up to 3 per character for up to 2 characters.

Know the limits first. Google names fast sports action, rapid script changes and complex physics as areas it's still improving. Audio uploads aren't supported. Editing or extending uploaded videos isn't available in the EEA, Switzerland or the UK. Every output carries an imperceptible SynthID watermark.

Pick Veo 3.1 if

You already run on Google Cloud. Projects, IAM and Cloud Storage are in place, so the extra setup costs you nothing.
You want several takes per request. sampleCount returns up to 4 videos from one call.
You rely on negativePrompt. Omni has no such field.
You need a dated model commitment. Google lists retirement as May 4, 2027 or later for the GA models, which gives you a date to plan around. Omni 1.1's short notice is the counterexample: from December 3, 2026, requests to gemini-omni-1.1-flash route to 1.2 and bill at 1.2 rates.
You extend uploaded footage in the EEA, Switzerland or UK. Veo's extension docs list no such limit. Confirm for your region before you build on that.

The trade-off: us-central1 only, a Google Cloud project, and a polling loop. Extension input must be MP4 at 24 fps, 1 to 30 seconds long. The extension page also lists Lite in its model table but leaves it out of the REST section, so treat Lite extension as unconfirmed.

Migrating a Veo integration to the Interactions API

Moving to Omni changes your request, polling and response parsing. Here's a Veo extension call, following Google's docs:

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/veo-3.1-generate-001:predictLongRunning

{
  "instances": [{
    "prompt": "The drone keeps climbing above the harbor",
    "video": { "gcsUri": "gs://my-bucket/clip.mp4", "mimeType": "video/mp4" }
  }],
  "parameters": { "storageUri": "gs://my-bucket/out/", "sampleCount": 1 }
}

And the same job on Omni, through the Agent Platform:

POST https://aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/global/interactions

{
  "model": "gemini-omni-1.2-flash",
  "store": false,
  "input": [
    { "type": "text", "text": "The drone keeps climbing above the harbor" },
    { "type": "video", "uri": "gs://my-bucket/clip.mp4", "mime_type": "video/mp4" }
  ],
  "response_format": [{
    "type": "video",
    "delivery": "uri",
    "gcs_uri": "gs://my-bucket/out/",
    "aspect_ratio": "16:9",
    "duration": "7s"
  }],
  "generation_config": { "video_config": { "task": "extend" } }
}

Map your fields like this:

Veo	Omni
`instances[0].prompt`	`input` text item
`instances[0].video.gcsUri`	`input` video item `uri`
`parameters.storageUri`	`response_format` `gcs_uri`
`parameters.aspectRatio`	`response_format` `aspect_ratio`
`parameters.seed`	`generation_config.seed`
`parameters.negativePrompt`	A "Do not do X" line in the prompt
`parameters.sampleCount`	No field in the docs we read, send separate requests
`fetchPredictOperation`	`background: true`, then GET the interaction ID
`videos[].gcsUri`	`steps` entry of type `model_output`, video item

Four details to watch:

Response format shape. The Agent Platform sample wraps response_format in an array. The Gemini API docs describe a single object. Copy the shape for the surface you call.
Duration format. Omni wants a string such as "7s", from "3s" to "15s", and "3s" to "10s" for extensions.
Lost URIs. On the Gemini API, GET /v1beta/interactions/{id} returns inline base64 even if you asked for URI delivery. The URI is only guaranteed in the creation response or the stream, so save it there.
Editing needs storage. With store: false you can't edit that video in a later turn.

For a first Interactions call, our Omni 1.1 API guide still fits with the new model ID.

Let your coding agent test both with Apidog CLI

If you might swap providers later, or run both, you want one set of checks that doesn't care which model answered. Hand that to your coding agent. It defines both endpoints with Apidog CLI, wraps each in a test scenario, and groups them in one test suite with the same assertions.

npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_TOKEN>
apidog skill install

Then give Claude Code, Codex or Cursor one [REDACTED PROMPT]
In Apidog project , create endpoints for Gemini Omni 1.2 Flash
(POST /v1beta/interactions) and Veo 3.1 Fast (predictLongRunning plus
fetchPredictOperation). Build one test scenario per provider and put both
in a test suite named video-provider-contract. Poll Veo until done. Assert
the same things on each: the job finishes, the output is video/mp4, and a
video URI or data field is present. Run it and summarize any failures.


The agent reads each schema, validates its payload, then builds and runs the suite:

bash
apidog cli-schema get endpoint-create
apidog cli-schema validate endpoint-create --file omni.json
apidog endpoint create --project --file omni.json
apidog test-scenario create --project --name "omni-contract" --folder-id --priority 1
apidog test-scenario import-steps --project --source endpoint --ids --sync manual
apidog test-suite create --project --name "video-provider-contract"
apidog test-suite update --project --file suite.json
apidog run --test-suite --project -e \
--timeout-request 300000 -r cli,junit --out-dir ./reports




A provider swap then shows up as a failed assertion, not a broken player in production. Keep fixtures small, because every run bills real video: a 3-second 360p Omni clip plus a 4-second 720p Fast clip comes to about $0.47. Run that nightly, not on every commit. The same line drops into a pipeline, as our [Apidog CLI CI/CD guide](http://apidog.com/blog/apidog-cli-ci-cd-pipeline?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) shows. Apidog Free covers up to 4 users.

## FAQ

**Can I still call Veo with a Gemini API key?** No. The Veo 3.1 Preview models in the Gemini API shut down on October 22, 2026. The GA models run on the Gemini Enterprise Agent Platform, which uses a Google Cloud project and an access token.

**Is there a Veo 4?** Not that we could find. Google's current Veo model page lists 3.1 models only, as of November 6, 2026.

**What happens to my Omni 1.1 code?** From December 3, 2026, requests to `gemini-omni-1.1-flash` route to `gemini-omni-1.2-flash` and bill at 1.2 rates. Your model string keeps working, but test your prompts on 1.2 before that date, since the model behind it changes.

**Which one makes better-looking video?** Google publishes no benchmarks here, so we won't name a winner. Run the same prompts through both and judge the clips yourself.

What Is GPT-6 Cyber? Access, Pricing and How to Test the API

Hassann — Fri, 06 Nov 2026 02:27:40 +0000

What Is GPT-6 Cyber? Access, Pricing and How to Test the API

GPT-6 Cyber is OpenAI's cybersecurity model for authorized vulnerability research, exploit development and penetration testing, announced on November 5, 2026. It costs $20 per million input tokens and $100 per million output tokens. You call it as gpt-6-cyber through the Responses API, but only with Daybreak Red access plus separate approval for this model.

Try Apidog today

That's the key difference from the last release. When we covered GPT-5.6 Cyber in August, there was no public price and no public request shape. Now OpenAI documents the model ID, the price, the request and the errors. A regular API key still won't get you in, though.

This guide covers what the model is, who qualifies, what it costs and how to test the integration. One disclosure: we don't have Daybreak Red access, so nothing below ran against gpt-6-cyber. The request and error codes come from OpenAI's Daybreak API guide, checked on November 6, 2026.

What is GPT-6 Cyber?

GPT-6 Cyber is a cyber-specialized variant of GPT-6 Astra, built for authorized security work such as finding vulnerabilities, developing exploits and web pentesting. OpenAI post-trained it with reinforcement learning to refuse fewer authorized security tasks and to stay inside the scope a researcher sets.

Three facts from the GPT-6 Cyber system card help you place it:

It's a specialist. OpenAI says it doesn't beat Astra at general coding: 82.95% on ExpertSWE against Astra's 83.24%.
It's rated Critical. Under OpenAI's Preparedness Framework it carries Critical in Cybersecurity, the same as GPT-6 Astra. GPT-5.6 Cyber was rated High.
It completes what Astra refuses. On RemoteExploitBench, Astra with Daybreak Blue refused every task, while GPT-6 Cyber completed 95%.

OpenAI's headline results come from real targets. Its researchers used the model to develop 948 Linux privilege escalation exploits and to find 81 high-severity Firefox vulnerabilities, which Mozilla has started fixing. Those are OpenAI's reported numbers from the GPT-6 Cyber announcement, not independent results.

Who can access GPT-6 Cyber?

Only approved organizations can use it today. OpenAI says GPT-6 Cyber is initially available through the API and Codex to a select group of Daybreak Red customers, and that it will expand to all Red customers soon. It gave no date.

Access level	Who can get it	What you get	GPT-6 Cyber?
Standard	Any API account	Mainline models, standard safeguards	No
Daybreak Blue	Verified individuals and organizations	Reduced refusals on models such as GPT-6 Sol and GPT-6 Luna	No
Daybreak Red	Approved business and enterprise organizations	GPT-5.6 Cyber, plus reduced refusals on mainline models including Astra	Not by itself
Red + model approval	Red organizations approved for this model	GPT-6 Cyber and GPT-5.6 Cyber	Yes

The Daybreak overview spells out four limits worth reading before you apply:

Individuals can't apply for Red. They can apply for Blue, which needs a paid plan, identity verification and a physical FIDO2 security key.
Money doesn't buy access. A contract or purchase doesn't guarantee approval.
Approval doesn't turn anything on. An owner still has to enable Daybreak for a project, and enabling Red doesn't grant GPT-6 Cyber.
Customer-facing use is out. Daybreak isn't for downstream product traffic or third parties unless OpenAI has approved a specific setup. Partners go through a separate program.

You can apply through the Daybreak page. For more on the tiers, see our Daybreak Blue vs Red guide. Utilities and open-source projects can also register interest in Daybreak for Frontline Defenders, OpenAI's $1 billion subsidized access program.

GPT-6 Cyber pricing and specs

OpenAI lists GPT-6 Cyber at exactly twice the price of GPT-6 Astra, according to its pricing page and model page.

Per 1M tokens	GPT-6 Cyber	GPT-6 Astra	GPT-5.6 Cyber
Input	$20.00	$10.00	$12.50
Cached input	$2.00	$1.00	$1.25
Output	$100.00	$50.00	$75.00
30-minute cache write	$25.00	$12.50	$15.625
12-hour cache write	$50.00	$25.00	$31.25

These are short-context rates. The pricing page shows no long-context rate for GPT-6 Cyber, so confirm with your account team before you plan around very large prompts.

A call with 50,000 input tokens and 10,000 output tokens costs $2.00 on GPT-6 Cyber and $1.00 on Astra. Agent runs repeat calls, so caching matters: cached input is a tenth of the full rate.

The specs on the model page:

Context window: 1,050,000 tokens
Max output: 128,000 tokens
Input and output: text and image in, text out
Features: streaming, function calling and structured outputs. No fine-tuning.
Tools: web search, file search, code interpreter, hosted shell, apply patch, skills, computer use, MCP and tool search
Rate limits: 5,000 requests per minute and 1 million tokens per minute on the Build tier, unless your organization has custom limits

GPT-6 Cyber benchmarks vs GPT-5.6 Cyber and Astra

GPT-6 Cyber's gain over GPT-5.6 Cyber is large, while its lead over Astra is smaller and doesn't hold on every test. All of these scores come from OpenAI's announcement and system card.

Evaluation	GPT-6 Cyber	GPT-6 Astra	GPT-5.6 Cyber
ExploitGym	48.45%	42.43%	32.1%
ExploitGym Hardened	36.94%	29.69%	Not reported
SRE-Bench (reverse engineering)	92.84%	87.98%	Not reported
Web pentesting recall	40.3%	32.0%	Not reported
Honeypot exploited, no safety prompt	0.07%	0%	5.51%

The honeypot row matters if you run agents. OpenAI places an easy-to-attack, out-of-scope service next to a hard task. GPT-6 Cyber crossed that line in 0.07% of graded runs, and in none with deployment safety instructions added.

Where GPT-6 Cyber is weaker

The system card also shows places where it trails Astra. These matter more for your test plan than the headline scores:

Reporting blockers: 20.29% of graded final answers were flagged, against 11.66% for Astra. OpenAI says most flagged runs disclosed the blocker earlier but dropped it from the summary.
Stopping at warnings: it stopped 73.00% of the time when stopping was right, against 78.38% for Astra.
FrontierCyber: Irregular's external test scored it 90 of 288 against Astra's 96. Neither model solved any of the 15 hardest challenges.

The practical lesson is simple: don't accept the agent's final summary as proof. Check its evidence, keep a human on high-risk runs, and follow OpenAI's advice to run in isolated environments with explicit limits on targets and credentials.

How to call GPT-6 Cyber through the API

Use the Responses API with model set to gpt-6-cyber and access_programs.cyber set to daybreak_red. Selecting Red doesn't switch your model or grant access to one, so you need both fields and the setup below.

Confirm with your account team that your organization has Daybreak Red and GPT-6 Cyber approval.
Require SSO on the API organization and enforce MFA through your identity provider.
Have an organization owner enable Daybreak Red on a non-default project. Default projects can't enable it, and changes can take about 15 minutes.
Create an API key in that project.
Add your public egress IPs to the IP allowlist.
If the project uses Zero Data Retention, set up Private Safety Processing.

Then send OpenAI's documented request:

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-cyber",
    "access_programs": {"cyber": "daybreak_red"},
    "safety_identifier": "user_a17f",
    "input": "Suggest a regression test for a path traversal fix."
  }'

Replace safety_identifier with a stable, pseudonymous ID for the person making the request. In the response, check model and access_programs.cyber to confirm what actually served the call.

The Daybreak guide documents three access errors:

Error	What it means	Fix
`400 invalid_access_program`	Wrong program value for this model	Use the value named in the error
`400 unsupported_access_program`	Model doesn't support Daybreak	Switch models, or send `standard`
`403 access_program_not_enabled`	Key's project or organization lacks the program	Check the project, then request access

Field validation fails too: access_programs and cyber are optional, but neither accepts null. Also, an access error isn't the same as a refusal. Safeguards still apply after approval, so a refused prompt doesn't prove your setup is wrong.

Let your coding agent test it with Apidog CLI

A gated model has a narrow setup and an expensive failure mode, so your agent should own the checks. Apidog CLI lets it write them once and rerun them on every key rotation or allowlist change. Apidog Free covers up to 4 users.

npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_TOKEN>
apidog skill install

Then give your agent one prompt. It works with or without Daybreak access, because the mock branch needs no OpenAI key:

In Apidog project <id>, add POST /v1/responses from OpenAI's Daybreak guide.
Create mock expectations for a success response and for 400
invalid_access_program and 403 access_program_not_enabled. Create a test
scenario that checks our client handles each one. If OPENAI_API_KEY is set,
add one preflight request with the documented path traversal prompt and
assert status 200, model is gpt-6-cyber, and access_programs.cyber is
daybreak_red. Never send exploit prompts or real targets. Run it against
the <env> environment and summarize failures.

The agent reads each schema, validates its payload and runs the scenario:

apidog cli-schema get endpoint-create
apidog endpoint create --project <id> --file endpoint.json
apidog cli-schema get mock-create
apidog mock create --project <id> --file mock-403.json
apidog cli-schema validate test-scenario-create --file scenario.json
apidog test-scenario create --project <id> --file scenario.json
apidog run -t <scenarioId> --project <id> -e <envId> -r cli,json

Keep the live check to that one small request, since every run bills at full rates, and run it from an allowlisted IP. Mock bodies should use only fields OpenAI documents, because we couldn't capture a live response.

The same apidog run line with -r junit drops into a pipeline, as shown in our Apidog CLI CI/CD guide. For agent setup, see Apidog CLI in Codex.

FAQ

Is GPT-6 Cyber available to everyone? No. It's limited to Daybreak Red organizations with separate GPT-6 Cyber approval. OpenAI says access will expand to all Red customers soon, but it hasn't given a date or announced general availability.

How much does GPT-6 Cyber cost? $20 per million input tokens, $2 per million cached input tokens and $100 per million output tokens, at short-context rates. Approval is still required, and a purchase alone doesn't guarantee access.

What's the GPT-6 Cyber model ID? Use gpt-6-cyber in the model field, with access_programs.cyber set to daybreak_red.

Can individuals use GPT-6 Cyber? Not through an application. Individuals can apply for Daybreak Blue only, and Blue has no access to cyber-specialized models. OpenAI notes that some individuals have access as exceptions.

Is GPT-6 Cyber better than GPT-6 Astra? For authorized offensive security work, usually. It leads Astra on ExploitGym and SRE-Bench and refuses far less. For general coding, OpenAI reports no gain, and it costs twice as much.

Can I use GPT-6 Cyber in Codex? Yes, once your organization is approved. Sign in with your approved workspace, or use an API key from a project with Daybreak Red enabled. OpenAI recommends Codex's sandboxing and Auto-Review for this model.

Claude Code Subagents Now Use Less of Your Limit

Hassann — Fri, 06 Nov 2026 00:32:37 +0000

Claude Code Subagents Now Use Less of Your Limit

Claude Code subagents now take less of your usage limit. Anthropic moved the status line on background subagents from a full conversation re-read to Haiku 5.5 working from short notes. Each update costs about 99% less, and sessions with background subagents used about 5% less of the limit. Update to v2.1.316 or later to get it.

Try Apidog today

That's the whole story in four sentences. The rest of this post covers who gets the change, what the two percentages mean, what stays unknown, and which settings cut subagent usage further.

What changed in Claude Code subagents

A background subagent is a helper that runs alongside your main session while you keep working. In the terminal, it shows a short status line so you can see what it's doing, and that line refreshes every 30 seconds.

Anthropic announced the change on X on November 5, 2026:

Before: each 30-second update re-read the subagent's whole conversation.
Now: Haiku 5.5 writes the update from short notes.
Unchanged: the subagent keeps its own model. If it runs on Opus 5.5 or Sonnet 5.5, it still does. Only the status line moved to Haiku 5.5.

You don't need to change a setting or trade away quality on the work itself. The subagent's output comes from the same model as before.

Why a subagent status line was expensive

A status line was expensive because a one-line summary was paying for a full read of a long conversation. The output was tiny, the input wasn't, and the job repeated every 30 seconds for as long as the subagent ran.

The arithmetic shows how fast that adds up. At one update every 30 seconds, a subagent running for an hour produces 120 updates. Three running for an hour produce 360.

Conversation length matters too. The Claude Code cost docs say token costs scale with context size, and a subagent's conversation grows as it reads files and runs tools. So the old design likely charged the most when a long-running subagent had the most context. That's our reading of the docs, since Anthropic hasn't published a cost curve for it.

Don't confuse this with the custom status line you set up with /statusline. The status line docs say that one runs locally and doesn't consume API tokens. The change here covers the status line Claude Code generates for each running subagent.

The numbers: 99% per update, about 5% per session

The two figures measure different things, and only one of them describes your limit.

Figure	What it measures	What it isn't
About 99% less	The cost of one status update	A saving on your bill or your limit
About 5% less	Limit used by sessions with background subagents	A saving on sessions without them
About 6% more	Prompts you get from the same limit, per Anthropic	A rise in the limit itself

If you remember one number, make it 5%. A 99% cut to something that was a small part of the session gives you a small saving on the session. Subagents still do their real work on their own model, and that work is where most of the usage goes.

Anthropic didn't say how much of the limit status updates used before. The two figures together suggest roughly a twentieth of those sessions, but that's an inference from rounded numbers, not a published figure.

Your own saving will also vary. About 5% is what Anthropic reports across sessions with background subagents. It didn't publish a range, and a session with one short subagent has less to gain than a session with several long ones.

Who gets the lower subagent usage

Anthropic says the change is live for most individual plans and all organization plans, in the CLI only.

Where you use Claude Code	Status
Pro, Max, Ultra	Live for most users, not all
Team, Enterprise	Live for everyone
CLI	Covered, on v2.1.316 or later
Desktop app	Nothing to change: it doesn't write this status line
API key, Bedrock, Vertex, Foundry	Not stated

The desktop detail comes from a reply in the same thread by Lydia Hallie of Anthropic, who said the desktop app doesn't write this subagent status line, so there was nothing to change there.

Two gaps are worth knowing about:

"Most" has no public test. The thread and docs don't name a flag or indicator that shows whether your Pro, Max, or Ultra account has it. Being on the right version is necessary, but it doesn't prove the change is live for you.
Pay-per-token users have no answer yet. Anthropic framed this around plan limits and didn't address API-key or cloud provider setups. The changelog for 2.1.318 does change subagent progress summaries on Bedrock, Vertex, Foundry, or with telemetry off: on a cold prompt cache, one can wait up to 5 minutes for the subagent's pending response. That shows those setups get their own handling, not that they get this saving.

The 2.1.316 changelog entries we read don't mention the status line either, so the thread is the only source for the numbers and the version.

How to update Claude Code and check your version

Three commands cover it:

claude --version   # needs to show 2.1.316 or later
claude update      # installs a newer version if one exists
claude --version   # confirm

claude update also works for package manager installs, where it updates through that package manager. The newest version listed in the changelog on November 5 was 2.1.318.

To see what subagents use, run /usage inside a session. On Pro, Max, Ultra, Team, and Enterprise plans, it attributes recent usage to skills, subagents, plugins, and MCP servers as percentages. Press d or w to switch between 24 hours and 7 days. The figures are approximate and come from local history on that machine, so treat a before and after comparison as a rough guide. If you're tracking limits closely, our Claude Pro and Max limits guide explains how they work.

Other ways to spend less on subagents

The status line fix is automatic, but it's about 5%. The docs are plain about the rest: each subagent sends its own requests, and they count toward the same limit as your main conversation. These settings have more room to help.

Pick a smaller model. A subagent inherits your session's model unless told otherwise, so a switch to Opus also applies to those subagents. Set model: haiku in a subagent definition for simple jobs. Our guide to Claude Haiku 5.5 in Claude Code covers that setup.

To set a default for all of them:

{
  "env": {
    "CLAUDE_CODE_SUBAGENT_MODEL": "haiku",
    "CLAUDE_CODE_SUBAGENT_MODEL_FORCE": "1"
  }
}

The first variable alone is only a default. A subagent definition or a model Claude passes still wins, and it doesn't change the built-in Explore and Plan subagents. The second forces one model onto every subagent.

Lower the effort. Version 2.1.316 added CLAUDE_CODE_SUBAGENT_EFFORT, which sets the effort level for subagents when nothing else names one, instead of inheriting the session's. It's in the changelog but wasn't in the environment variable reference on November 5, so check accepted values before you rely on it. For one subagent, set the documented effort field in its definition (low, medium, high, xhigh, or max, depending on the model).

Run fewer at once. The default cap is 20 running subagents per session. Set CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS to a lower whole number if you want a hard ceiling. Run /tasks to see what's running, and which model and effort each subagent uses.

Keep the brief narrow. The cost docs note that vague requests trigger broad scanning. A subagent told to check one endpoint reads less than one told to review the API. Our guide to creating custom Claude Code subagents walks through the full definition format.

Run API tests in a background subagent with Apidog CLI

API test runs suit a background subagent: they take time, produce verbose output, and you only need the failures back. Apidog CLI lets the subagent run a saved test scenario while your main session keeps coding, and the raw output stays out of your main context.

Set it up once:

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick Claude Code when prompted

Then add a small subagent at .claude/agents/api-tester.md:

---
name: api-tester
description: Runs Apidog test scenarios and reports only the failures.
tools: Bash, Read
model: haiku
background: true
---
Run the Apidog test scenario you are given. Report which steps failed
and why. Don't paste the full output.

Now give Claude Code one [REDACTED PROMPT]
Use the api-tester subagent to run Apidog test scenario in
project against environment . Keep working on
the checkout refactor. When it finishes, tell me only what failed.


The subagent runs commands like these:

bash
apidog test-scenario list --project
apidog test-scenario run --project -e -r cli,json --out-dir apidog-reports




Permission prompts from a background subagent show up in your main session, naming the subagent that's asking. For long runs, 2.1.318 also moves a shell command to the background after 3 minutes, so the prompt cache doesn't expire while it runs.

The same `run` command works in CI with `-r junit`, as the [Apidog CLI CI/CD guide](http://apidog.com/blog/apidog-cli-ci-cd-pipeline?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) shows. For the general setup, see [Apidog CLI in Claude Code](http://apidog.com/blog/apidog-cli-in-claude-code?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation). Apidog's Free plan covers up to 4 users.

## FAQ

**Do Claude Code subagents now cost 99% less?** No. The 99% applies to each status update. Anthropic says sessions with background subagents used about 5% less of the limit.

**Does my subagent now run on Haiku 5.5?** No. The subagent keeps its own model. Only the status line moved to Haiku 5.5.

**What version do I need?** v2.1.316 or later. Run `claude --version` to check and `claude update` to upgrade.

**Does this apply to the Claude desktop app?** No, because there was nothing to change. Anthropic's Lydia Hallie said the desktop app doesn't write this subagent status line.

**Is it live on my Pro plan?** Probably, but not certainly. Anthropic says most Pro, Max, and Ultra users have it, and everyone on Team and Enterprise. The thread and docs don't name a way to check your account.

**Does this help if I use an API key or Bedrock?** Anthropic hasn't said. The announcement talks about usage limits and doesn't cover API-key, Bedrock, or Vertex usage.

How to Use the GPT-Image-2.6 API

Hassann — Thu, 05 Nov 2026 10:22:40 +0000

How to Use the GPT-Image-2.6 API

The GPT-Image-2.6 API generates and edits images through two OpenAI models, gpt-image-2.6-flare and gpt-image-2.6-sunburst. Send a prompt to POST /v1/images/generations with your API key, then decode b64_json from the response. Version 2.6 adds image markup, SVG and GIF output, and a complexity parameter.

Try Apidog today

This guide covers authentication, a first generation, a markup edit, SVG export, and quality and complexity settings. It sticks to what's new, so read our gpt-image-2.5 API guide for streaming and the Responses API tool, and our ChatGPT Images 2.6 explainer for the full release. We built every request below from OpenAI's docs on November 5, 2026. We haven't run them against a live key, so test them before you ship.

GPT-Image-2.6 API at a glance

Item	Detail
Model IDs	`gpt-image-2.6-flare`, `gpt-image-2.6-sunburst`
Generate	`POST /v1/images/generations`
Edit	`POST /v1/images/edits`
Auth	`Authorization: Bearer $OPENAI_API_KEY`
Output	`b64_json`; PNG by default, plus JPEG, WebP, GIF, SVG
`quality`	`low`, `medium`, `high`, `xhigh`, `max`, `auto` (default)
`complexity`	`low`, `medium`, `high` (`high` if omitted)
Image token rates	$8 input, $2 cached input, $30 output per 1M
Text token rates	$5 input, $1.25 cached input per 1M

Rates come from the OpenAI pricing page. Both models cost the same per token, so pick on speed and edit precision.

Flare or Sunburst: which model should you call?

Call Flare for fast iteration and everyday generation. OpenAI says it can return an image in as little as six seconds at low quality, and that it improves layout for posters and product imagery. Call Sunburst for detailed work and repeated edits, where OpenAI claims better consistency at medium or high quality.

Those are OpenAI's claims, not independent benchmarks. Our Flare vs Sunburst comparison for 2.5 explains the split.

Authentication and setup

You need three things before your first call:

Create an API key in the OpenAI dashboard and export it as OPENAI_API_KEY.
Complete API Organization Verification if your organization needs it. OpenAI says you may have to before you can use GPT Image models.
Install jq for the curl examples, or the openai package for Python.

If your app serves individual users, also send a hashed safety_identifier of up to 128 characters. It replaces the deprecated user parameter.

Generate your first image

This request uses Flare at low quality, which suits drafts.

curl --fail-with-body --silent --show-error \
  https://api.openai.com/v1/images/generations \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.6-flare",
    "prompt": "A minimal poster for a developer meetup, with the words SHIP IT in bold type",
    "size": "1024x1536",
    "quality": "low",
    "complexity": "low"
  }' | jq -er '.data[0].b64_json' | base64 --decode > poster.png

The same call in Python:

import base64
from pathlib import Path
from openai import OpenAI

client = OpenAI()

result = client.images.generate(
    model="gpt-image-2.6-sunburst",
    [REDACTED PROMPT],
    size="1536x1024",
    quality="medium",
    extra_body={"complexity": "low"},
)

Path("mug.png").write_bytes(base64.b64decode(result.data[0].b64_json))

We pass complexity through extra_body so the call doesn't depend on your SDK version exposing it as a named argument. GPT Image models always return base64, so don't send response_format, and don't look for a url field.

OpenAI's guide says to read the response's usage object to measure token use. The API reference describes that field as gpt-image-1 only, though its sample response includes it, so confirm it appears on your 2.6 responses before you build cost tracking on it.

Edit an image with markup

Markup tells the model where to make a change. You send the original image, a transparent PNG with your circles or sketches, and a prompt describing the edit.

curl --fail-with-body --silent --show-error \
  https://api.openai.com/v1/images/edits \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.6-flare",
    "images": [{"image_url": "https://your-bucket.example/kitchen.png"}],
    "markup": {"image_url": "https://your-bucket.example/vase-overlay.png"},
    "prompt": "Recolor the vase inside the red circle to solid cobalt blue. Keep everything else unchanged. Remove the red circle.",
    "quality": "medium",
    "complexity": "low"
  }' | jq -er '.data[0].b64_json' | base64 --decode > vase.png

JSON requests use the images array and a markup object that holds exactly one of image_url or file_id. An image_url can be an HTTPS URL or a base64 data URL. Multipart requests take a file upload instead, and the image generation guide has that version in Python.

The overlay has strict rules:

After orientation, it must match the first image's width and height.
It must contain transparent pixels, so don't flatten it onto the photo.
It applies to the first input image. Any others act as references.
Each of the two images can hold at most 16,777,216 pixels, and the overlay file can't exceed 50 MB.
You can't combine markup with mask or prompt_rewriter.

Tell the model to remove the annotation, as OpenAI's own example does. Markup costs the same as any other edit. The Responses API doesn't take it, so use a mask there.

Export SVG

Set output_format to svg on the generations endpoint for icons, logos and illustrations that need editable paths.

curl --fail-with-body --silent --show-error \
  https://api.openai.com/v1/images/generations \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.6-sunburst",
    "prompt": "A flat two-color wheat logo for a bakery called Field and Flour",
    "output_format": "svg",
    "quality": "medium",
    "n": 1
  }' | jq -er '.data[0].b64_json' | base64 --decode > logo.svg

The API first renders a reference image, which quality controls, then writes the SVG from it. The decoded bytes are UTF-8 XML with no scripts, external resources or embedded rasters.

Four limits apply:

n must be 1.
Streaming, partial images, output_compression and prompt_rewriter don't work.
The edits endpoint can't output SVG, and it won't accept an SVG as a raster input.
The optional svg object picks the authoring model, but only if your account has SVG model selection. Otherwise, omit it.

You pay twice: the image rate for the reference image and the authoring model's rate for its tokens. The API reference lists a separate svg_usage object for that second part, so log it.

Generate a GIF

The API returns a finished GIF, not a sprite sheet. Add three fields to a generations request:

{
  "model": "gpt-image-2.6-flare",
  "prompt": "A small orange robot waves, blinks and returns to its starting pose. Make it loop.",
  "output_format": "gif",
  "frame_count": 9,
  "frame_duration_ms": 200,
  "size": "auto"
}

Decode b64_json the same way and save it as .gif. Check two things first:

Frame limit. The guide says frame_count runs from 2 to 64. The API reference says 2 to 16. Stay at 16 or below until you've tested higher.
Access. The reference says GIF output requires access to the GIF preview for the selected model, while the guide doesn't mention this. A rejected GIF request may be an access issue, not a bad payload.

GIF output doesn't support streaming, partial images or custom output_compression, and the edits endpoint can't return it. OpenAI publishes no GIF-specific billing formula, so run a small test and check your bill before you scale.

Set quality and complexity

quality controls rendering detail and drives token cost. complexity controls how much the model plans before rendering, and changing it carries no separate fee.

Set complexity on every request. The default is high, yet OpenAI recommends low for most edits. The guide warns that higher settings can add latency and introduce unwanted changes.

Quality also sets your output bill. This table uses OpenAI's calculator for a 1024x1024 image, read November 5, and excludes input tokens:

`quality`	Output tokens	Output cost
`low`	823	$0.02469
`medium`	1,449	$0.04347
`high`	1,756	$0.05268
`xhigh`	3,122	$0.09366
`max`	7,024	$0.21072

The gap between medium and high is about a cent, so compare both. The pricing page's Batch tab doesn't list 2.6 yet, so don't assume the 2.5 batch discount applies.

Handle errors and timeouts

Sort failures by whether a retry can help:

Failure	What to do
Rate limit or server error	Retry with backoff
Quota error	Don't retry; fix billing
`error.type` is `image_generation_user_error`	Change the prompt or input first
`error.code` is `moderation_blocked`	Read `moderation_details`, then revise

Use error.code as your stable check, and log the request ID. moderation_details carries moderation_stage and coarse categories, which belong in your logs, not in user-facing messages. Set client timeouts above two minutes, because OpenAI says complex prompts can take that long.

Let your coding agent test it with Apidog CLI

Your coding agent can turn these requests and limits into a test suite with Apidog CLI. Set it up once:

npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_TOKEN>
apidog skill install

Then give Claude Code, Codex or Cursor one [REDACTED PROMPT]
In Apidog project , add POST /v1/images/generations and POST /v1/images/edits
on https://api.openai.com. Read the Bearer [REDACTED] from OPENAI_API_KEY.
Create test cases for gpt-image-2.6-flare at low quality and low complexity:

PNG generation: assert status 200 and data[0].b64_json exists.
SVG generation: assert status 200 and output_format equals svg.
GIF with frame_count 6: assert status 200 and output_format equals gif.
SVG with n set to 2: assert a 4xx status and that error.message exists.
GIF with frame_count 17: record the status, because OpenAI's docs disagree. Put them in a test suite named "GPT-Image-2.6", run it against environment , and summarize every failure.


The agent reads each schema, validates its payload, then writes and runs the suite:

bash
apidog cli-schema get endpoint-create
apidog cli-schema validate endpoint-create --file endpoint.json
apidog endpoint create --project --file endpoint.json
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project --file case.json
apidog cli-schema validate test-suite-create --file suite.json
apidog test-suite create --project --file suite.json
apidog test-suite run --project -e \
--env-var "OPENAI_API_KEY=$OPENAI_API_KEY" --on-error continue -r cli,json




Case 5 settles the frame limit for your account, and case 3 shows whether you have GIF access. Successful cases make real, billable generations, so keep quality low. Swap in `-r junit` to run the suite in a [CI pipeline](http://apidog.com/blog/apidog-cli-ci-cd-pipeline?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation), and see the [Claude Code setup guide](http://apidog.com/blog/apidog-cli-in-claude-code?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) for agent details.

## FAQ

**What are the GPT-Image-2.6 API model names?** `gpt-image-2.6-flare` and `gpt-image-2.6-sunburst`. The API reference lists no dated snapshots for them yet, unlike the 2.5 models.

**How much does the GPT-Image-2.6 API cost?** Image tokens cost $8 per 1M input and $30 per 1M output. A 1024x1024 image costs about $0.025 in output at `low` and about $0.053 at `high`, before input tokens.

**Should I migrate from gpt-image-2.5?** Migrate if you need SVG, GIF or `complexity`. Test your costs first: a `low` image uses about 4.2 times the tokens it did on 2.5, and the 2.6 models have no Batch pricing listed yet.

**Can I use `complexity` on the edits endpoint?** Yes. OpenAI recommends `low` for most edits.

**Can I turn an uploaded image into a GIF through the API?** No. The edits endpoint doesn't return GIF or SVG, so both formats start from a text prompt on the generations endpoint.

**Does the API return a URL?** No. GPT Image models always return base64 in `b64_json`, so decode it and store the file yourself.