Author’s note: Gemini 4 Carbon’s introductory pricing ends on November 30. This article helps you recalculate the bill before the deadline and restructure the integration layer into a setup where “switching models only means changing the ID and endpoint.”
If your business already runs on Gemini 4 Carbon, the next 10 days are worth taking seriously. Google’s developer page states, Gemini 4 Carbon’s introductory pricing runs until 2026-11-30 and switches to standard pricing starting 2026-12-01, with both input and output unit prices doubling. Today is 2026-11-20. The introductory pricing hasn’t ended yet, so there’s still enough time to adjust your cost model and integration code.
This isn’t an article telling you to switch models right away. Switching over isn’t necessarily cheaper, and the results won’t necessarily be equivalent. This article tackles two more practical issues: how to recalculate costs after the deadline, and how to refactor the invocation layer into a structure you can switch at any time—so the next time pricing or the context window changes, you only need to change the model ID and endpoint, not rewrite the entire invocation.
Core value: After reading this article, you’ll have the exact expiry date, both sets of numbers for introductory and standard pricing, and the endpoints you should use when switching to Hydrogen, Neon, Fable, or Astra.

Gemini 4 Carbon: Key Facts as the Introductory Pricing Expires
Let’s get the key facts down in one place first. The numbers below come from Google’s developer page and from pricing that APIYI verified on 2026-11-20; they’re in USD per million tokens.
| Key point | Details | Impact on you |
|---|---|---|
| Introductory pricing deadline | Through 2026-11-30 |
November billing is calculated at introductory rates |
| Introductory pricing | Input 2, output 10, cache read 0.10 |
Your current cost baseline |
| Standard pricing (from December 1) | Input 4, output 20, cache read 0.20 |
Cost roughly doubles at the same usage |
| APIYI current listing | gemini-4-carbon input 2, cache read 0.1, output 10 |
Matches introductory pricing; after expiry, defer to the platform’s model list |
| Alternative models | Hydrogen, Neon, Fable, Astra | Different endpoints — they can’t share a single request body |
How to Understand Gemini 4 Carbon’s Two Price Tiers
The difference between introductory and standard pricing is straightforward: input goes from 2 to 4, output from 10 to 20, and cache reads from 0.10 to 0.20 — all three double. So from December onward, your cost is essentially “November usage at the same volume, multiplied by 2.” If your prompts contain lots of reusable prefixes and your cache hit rate is high, the absolute increase on cache reads will be smaller, but the multiplier is still 2×.
One thing to keep separate is the listing price on APIYI (apiyi.com). As of the 2026-11-20 check, gemini-4-carbon on the platform is listed at input 2, cache read 0.1, output 10 — that matches Google’s introductory pricing, not the standard pricing that starts December 1. How the platform adjusts after expiry should be based on its model list at that time; don’t treat the listing price you see today as a guarantee for December onward.
Why You Shouldn’t Lock In to a Single Model
If you integrate only one model, the risks come from three directions. First, repricing — the end of an introductory period or a promo adjustment directly changes your unit cost. Second, the model being deprecated or renamed — the old ID suddenly stops working and calls fail across the board. Third, the same model can have inconsistent reasoning levels and context windows across different access routes, so parameters you tuned on one route may not take effect on another.
None of these three shifts are under your control. What is under your control is how big the blast radius is when they happen. If model IDs, endpoint types, and pricing parameters are all hardcoded into your application logic, every change means code edits, retesting, and a redeploy. If all of that is consolidated into configuration at the integration layer, a change is just one line of config.

How to Recalculate Costs After Gemini 4 Carbon Expires
Plug Your Own Usage Into Both Pricing Schemes
Recalculating really only takes three numbers: monthly input tokens, monthly output tokens, and monthly cache-read tokens. Multiply each by its unit price and add them up, and you’ve got your monthly cost. Let’s walk through it with a hypothetical usage: 100M input tokens and 20M output tokens per month, ignoring cache for now. This usage is just an illustration, so swap in the real numbers from your own bill.
| Billing option | Input unit price | Output unit price | Monthly cost under the assumed usage |
|---|---|---|---|
| Carbon introductory price (through 11-30) | 2 |
10 |
100×2 + 20×10 = 400 USD |
| Carbon standard price (from 12-01) | 4 |
20 |
100×4 + 20×20 = 800 USD |
gemini-4-hydrogen |
1.5 |
7.5 |
100×1.5 + 20×7.5 = 300 USD |
gemini-4-neon |
3 |
15 |
100×3 + 20×15 = 600 USD |
claude-fable-5-2 |
8 |
40 |
100×8 + 20×40 = 1600 USD |
gpt-6.2-astra (first tier) |
8 |
40 |
100×8 + 20×40 = 1600 USD |
This table only accounts for unit prices, not quality. Hydrogen has the lowest unit price, but whether it can replace Carbon depends on how much your task demands in terms of reasoning quality and format stability. Fable and Astra cost more per unit, so they fit steps that demand high quality and are worth paying for output quality—not as a cost-cutting option. In other words, the point of recalculating is to see the cost of each path clearly, not to assume that switching automatically saves money.
Where to Verify the Price Data
There are two sources you can cross-check for APIYI pricing. One is the master model table; the version checked on 2026-11-20 was updated at 2026-11-19 10:59 (UTC+8). The other is the pricing endpoint api.apiyi.com/api/pricing, version shell-api-modelmak-v1, where a model_ratio of 1 equals an input price of 2 USD per million tokens; output and cache prices are converted via completion_ratio and cache_ratio, respectively.
Take gemini-4-neon as an example: this model doesn’t appear in that version of the master table, but it’s in the pricing endpoint: model_ratio is 1.5, completion_ratio is 5, and cache_ratio is 0.05. That converts to input 3, output 15, and cache read 0.15, matching Google’s list price. For budgeting, I’d treat the pricing endpoint as the source of truth and use the master table as a secondary reference.
gpt-6.2-astra has tiered pricing, so you need to check both places. The master table lists the first tier as input 8, cache read 0.4, and output 40; above 272000 tokens, input becomes 16. The pricing endpoint, meanwhile, shows that above 272000 tokens, output is billed at 60 and cache read at 0.8. If your individual requests often carry very long contexts, these tiers can have a big impact on cost, so you’ll need to estimate them separately.
💰 Cost-checking tip: Pull APIYI apiyi.com’s pricing endpoint and model list once before and once after the expiration date, and put the unit prices into your routing config instead of hardcoding them in code comments. That way, when you reconcile monthly, you only need to check whether the config and platform data agree.
Gemini 4 Carbon Replacement Models: Endpoint Cheat Sheet
Match the endpoint before you swap models — don’t assume the request body carries over
This is where teams trip up most often. A lot of them figure, “it’s all OpenAI-compatible, so I just change the model field,” and then discover that some models recommend a completely different endpoint with a different request body schema. The table below lists the recommended endpoint types for each drop-in replacement model. All calls go through the same base URL: https://api.apiyi.com/v1.
| Model ID | Recommended endpoint | Input / cache read / output unit price | Switch notes |
|---|---|---|---|
gemini-4-carbon |
chat or Gemini native | 2 / 0.1 / 10 (current listing) |
After expiry, refer to the model list |
gemini-4-hydrogen |
chat or Gemini native | 1.5 / 0.075 / 7.5 |
Same endpoints as Carbon, smallest change |
gemini-4-neon |
chat or Gemini native | 3 / 0.15 / 15 |
Pricing per the pricing endpoint |
claude-fable-5-2 |
chat or messages | 8 / 0.2 / 40 |
Native capabilities are more complete via messages |
claude-fable-5-2-thinking |
chat or messages | 8 / 0.2 / 40 |
Thinking tier is a separate ID |
gpt-6.2-astra |
responses recommended | First tier 8 / 0.4 / 40 |
Tiered pricing above 272000 tokens |
Also, gemini-4-argon appears in the master table at an input price of 2, cache read 0.1, and output 10 — the same as Carbon’s current listing price. Its endpoint details aren’t covered in the reference material for this article, so if you’re considering it, confirm the recommended endpoint in the platform docs before wiring it up.
How the three endpoint types differ
The chat endpoint is OpenAI-compatible chat completions: the core of the request body is model plus a messages array, and most SDKs default to this. The Gemini native endpoint uses Gemini’s own request structure, which suits scenarios that need native parameters (specific thinking configs, for example). The messages endpoint is Claude’s native format — system prompt placement and content block structure both differ from chat. The responses endpoint is OpenAI’s newer interface shape, and it’s the recommended path for gpt-6.2-astra.
So a solid integration layer should have a separate adapter for each endpoint type. Your business code just passes in “task type + content,” and the adapter assembles the right format. For exact endpoint paths and fields, follow the documentation center on APIYI.
🎯 Technical tip: Before switching, use the same API key on APIYI apiyi.com to send a few real business requests to each candidate model’s recommended endpoint. Confirm the response structure, thinking-tier behavior, and context length all match expectations before you touch the routing config.

Gemini 4 Carbon Swappable Integration Layer Quick Start
Minimal Example: One Unified Client
This section skips the long code dumps and just gives you the key configuration. When you initialize the client with the OpenAI-compatible SDK, you only need two parameters: client = OpenAI(api_key="YOUR_API_KEY", base_url="https://api.apiyi.com/v1"). After that, calling the chat endpoint looks like client.chat.completions.create(model="gemini-4-carbon", messages=msgs). Want to switch to Hydrogen? Just change model to gemini-4-hydrogen — the two share the chat endpoint, so the request body stays exactly the same.
Switching to gpt-6.2-astra is a different story. The recommended form is client.responses.create(model="gpt-6.2-astra", input=msgs): the parameter name changes from messages to input, and the response structure is different too. This is precisely why the integration layer has to split adapters by endpoint instead of just swapping model names.
The Full Refactoring Steps
To turn a single-model call into a swappable structure, work through these in order:
- Extract the routing configuration: build a config table where each row holds the task name, model ID, endpoint type, input price, output price, and cache-read price. Business code only ever refers to the task name.
- Write one adapter per endpoint: implement four adapters — chat, Gemini native, messages, and responses. Each adapter converts the unified input into the request body that endpoint expects, and converts the response back into a unified structure.
- Unify the base URL and key: all adapters share the same
base_urland API key, so switching models never means new key management. - Add a fallback chain: give critical tasks a primary and a backup model — say,
gemini-4-carbonas primary andgemini-4-hydrogenas backup — and route to the backup automatically when the primary errors out or goes offline. - Instrument costs: log the model ID and token usage on every call, estimate cost in real time using the unit prices in the config table, and reconcile against the bill at month’s end.
View example routing config fields
A typical routing config entry can contain these fields: `task: “summary”`, `model: “gemini-4-carbon”`, `endpoint: “chat”`, `price_in: 2`, `price_out: 10`, `price_cache: 0.1`, `fallback: “gemini-4-hydrogen”`. After December 1, all you need to do is update `price_in` and `price_out` based on the platform’s model list, or swap out `model` and `endpoint` — the business code doesn’t change at all.
For tiered-pricing models like `gpt-6.2-astra`, it’s worth adding a `tier_threshold: 272000` along with the matching higher-tier unit price fields, letting the cost instrumentation module decide which tier a request lands in based on its token count.
🚀 Quick start: If you don’t have a unified entry point yet, register at APIYI (apiyi.com) to get an API key and free trial quota. Run Carbon, Hydrogen, Neon, Fable, and Astra all through with a single key first, then decide how to configure your routing.
Pre-Deadline Checklist
| Item | Suggested deadline | Notes |
|---|---|---|
| Export November usage | Before 11-25 | Get the real token counts for input, output, and cache reads |
| Run the numbers under both price sets | Before 11-26 | Calculate monthly cost using introductory and standard pricing separately |
| Trial-run the candidate models | Before 11-28 | Send a batch of real requests through each recommended endpoint |
| Ship the routing config | Before 11-30 | Primary/backup models and unit prices all go into config |
| Recheck platform pricing | After 12-01 | Update unit prices based on the platform’s model list |
Frequently Asked Questions (FAQ)
Q1: How long exactly does the Gemini 4 Carbon introductory price run?
According to Google’s developer page, the introductory price lasts through 2026-11-30, with input at `2`, output at `10`, and cached reads at `0.10` USD per million tokens during that period. Starting 2026-12-01, standard pricing kicks in: input `4`, output `20`, cached reads `0.20`.
Q2: What will Carbon cost on APIYI after December?
Right now, `gemini-4-carbon` on the APIYI shelf is input `2`, cached reads `0.1`, output `10` — that’s the introductory price. For pricing after December 1, refer to the platform’s model list. This article makes no guarantees about shelf prices beyond that date, so once the intro period ends, check directly on APIYI at apiyi.com.
Q3: How much code do I need to change to move from Carbon to Hydrogen?
Barely any. Both recommend the same endpoints — chat or Gemini native. If you’re already using the chat endpoint, you just change the `model` field from `gemini-4-carbon` to `gemini-4-hydrogen`. That said, validate with real requests first; a lower unit price doesn’t mean equivalent task quality.
Q4: Why can’t I just rename the model when switching to Claude Fable or GPT Astra?
Because the recommended endpoints are different. `claude-fable-5-2` can go through chat or messages, and its native capabilities are more complete over messages; `gpt-6.2-astra` is best called through responses, where both request parameters and response structure differ from chat. If you simply swap the model name, you’ll often run into unrecognized fields or parsing failures.
Q5: Where should I look for Gemini 4 Neon pricing?
The 2026-11-19 version of the master model table doesn’t include a Neon row, but the pricing endpoint does — converted, that’s input `3`, output `15`, cached reads `0.15`, which matches Google’s list price. For budgeting, go with the pricing endpoint; the endpoint is likewise chat or Gemini native.
Q6: How can I quickly compare a few candidate models with a single key?
The easiest route is testing everything through an API aggregation platform:
1. Register at APIYI (apiyi.com) to get an API key and free trial credits
2. Set your client’s `base_url` to the unified address, then call each model through its recommended endpoint
3. Log token usage and output quality for each model, then plug the numbers into the recalculation table in this article
Q7: What are the limitations of this switchable access layer?
The access layer only lowers switching costs — it can’t erase quality differences. Different models may interpret the same prompt differently, follow formats differently, and behave differently at various thinking levels, so regression testing is still needed after switching. Also, tiered-pricing models (like Astra above `272000` tokens) need separate estimates; a single unified cost formula will underestimate long-context requests.
Gemini 4 Carbon Introductory Pricing Expiration: Key Takeaways
- The end date is clear: the introductory price runs through 2026-11-30, and standard pricing kicks in on December 1
- Costs roughly double: input, output, and cache-read standard prices are all twice the introductory rate
- Listed price isn’t a promise: APIYI’s current Carbon pricing reflects the introductory rate — after it expires, the model list is the source of truth
- Endpoints differ: Hydrogen and Neon go through chat or gemini, Fable through chat or messages, and Astra is best on responses
- Switching models doesn’t automatically save money: Hydrogen has a low unit price while Fable and Astra are pricier, so judge by results, not price alone
- Configuration is the key: model ID, endpoint, and unit price all live in routing config, and business code only knows task names
- A unified entry point makes validation easy: use a single APIYI key to run several candidate models before deciding on routing
Summary
When it comes to Gemini 4 Carbon’s introductory pricing expiring, there are three core points:
- Do the math first: plug your real usage into both the introductory and standard rates — after December, the same usage will cost roughly twice as much.
- Then match the endpoints: the recommended endpoints for replacement models aren’t the same, so confirm the request format for chat, gemini, messages, and responses before switching.
- Finally, make it configurable: consolidate model IDs, endpoint types, and unit prices into routing config, so the next time prices or context windows change, you only touch config, not code.
You’ve got 10 days until November 30 — enough time to export usage, recalculate under both price sets, and test-run candidate models. Don’t tie your business to one model at one price. Leaving a swappable seam in the integration layer is the safest preparation for whatever changes next.
We recommend connecting through APIYI at apiyi.com as a unified entry point, so you can validate results and compare costs across multiple models and endpoints with a single key.
📚 References
-
Google Developer Page – Gemini Pricing Overview: Gemini 4 Carbon introductory and standard pricing
- Link:
ai.google.dev - Notes: The introductory pricing deadline and the standard pricing that takes effect December 1
- Link:
-
APIYI Model Master List: Input, output, and cached-read unit prices for each model
- Link:
docs.apiyi.com/models.md - Notes: Version checked on 2026-11-20, updated 2026-11-19 10:59 (UTC+8)
- Link:
-
APIYI Pricing Endpoint: Real-time prices converted by rate multiplier
- Link:
api.apiyi.com/api/pricing - Notes: Version
shell-api-modelmak-v1, handy for programmatic unit-price reads
- Link:
Author: APIYI Technical Team
Technical discussion: Feel free to reach us through the APIYI homepage; model endpoints and parameter details are available in the documentation center
