How to Use Gemini 4 Carbon: API Setup, Parameters and Cost

Gemini 4 Carbon is Google's multimodal model in the Gemini 4 family, and on OrcaRouter it is reachable from a single key: the model id is google/gemini-4-carbon, the list price is $2.00 per million input tokens and $10.00 per million output tokens, and the Gemini 4 Carbon API page carries the live figures. What follows is the setup that actually works, in the order you will hit it: endpoint, request shape, parameter set, cost, then the latency numbers you should budget for before you put it in front of users.

What the model accepts

The context window is 1,048,576 tokens and the output ceiling is 65K tokens per response, which is the first thing to internalise: a very large document fits in the prompt, but the answer is capped well below the input. Input modalities are text, images, audio, video and documents; output is text. Native tool use and function calling are supported, as are structured JSON outputs, which is what makes it usable inside an agent loop rather than only as a chat box.

Zero Data Retention is available on this model. With ZDR on, requests go only to upstream providers that hold a zero-retention agreement, so if your procurement team needs that in writing, it is a routing setting rather than a separate contract.

Endpoint one: the OpenAI-compatible path

This is the path to take if you already have code running against any OpenAI client. Point the SDK at OrcaRouter, keep the model id, and nothing else in your request changes. The sample below is the whole program:

Set the base URL to https://api.orcarouter.ai/v1, read the key from an environment variable rather than a literal, and pass google/gemini-4-carbon as the model. The same three lines work from the Python, TypeScript and Go SDKs, because the wire format is Chat Completions.

Endpoint two: native generateContent

If your stack is built on the Gemini SDK rather than an OpenAI client, Carbon still answers natively at /v1beta/models/{model}:generateContent on the same host. The interesting consequence is that you can migrate a workload one request at a time: run the OpenAI-compatible path for the services that share code with other vendors, and the native path where you already depend on Gemini-specific fields. Both bill against the same key and the same balance, which is the argument for a gateway over a set of vendor accounts.

The parameters that are honoured

The model page lists the supported set explicitly: include_reasoning, max_tokens, reasoning, response_format, seed, stop, structured_outputs, temperature, tool_choice, tools and top_p. That list is the contract. If you are porting a request from another provider, check it before you ship, because the parameters you reach for out of habit — penalty terms, logit biases, a dozen sampling knobs — are not on it.

Two of them matter more than the rest. structured_outputs plus response_format is what turns a 200,000-token document into a record your downstream code can read without a parser you wrote yourself. And include_reasoning is how you find out what the model did before it answered; leave it off in production and you are trusting an opaque step with your schema.

What a request costs

Input is $2.00 per million tokens and output is $10.00 per million, with cache reads at $0.100 per million. A worked example: a 40,000-token contract plus a 2,000-token structured extraction bills $0.08 of input and $0.02 of output, so ten cents a document. The same 40,000 tokens read from cache bill at $0.004 instead, which is why the caching line matters for any workflow that re-reads the same corpus.

For scale, the same 40,000-token document against Gemini 3.1 Pro costs the same on input but 20 percent more on output, and against Gemini 3 Flash costs a quarter as much on both — the choice between them is about modality and context rather than about the input price, which is identical between Carbon and 3.1 Pro. The free LLM API breakdown is the place to compare that against the rest of the catalogue.

Two latency numbers that mean different things

OrcaRouter's own model page reports the last seven days of live traffic: p50 time to first token of 6.89 seconds, p95 of 10.00 seconds, and output speed of 226 tokens per second, over 9.6 million tokens served. That is what an interactive caller experiences through the gateway.

Artificial Analysis reports 64.7 seconds to first token and 28.4 minutes of wall clock per task for the same model. Those are not in conflict; they are different measurements. AA runs a fixed evaluation harness that asks the model to think for as long as it wants on nine hard benchmarks, so the clock includes the reasoning, not just the network and the prefill. If you quote one number without the other, you will either over-promise interactivity or scare off a buyer who would have been fine.

The honest operational caveat is the error rate: 39.7 percent of requests returned a non-2xx status across all upstream providers in that seven-day window, against 10.8 percent for Claude Fable 5.2 over the same period. Build the retry and fallback path before launch, not after the first incident, and read the Gemini 4 Carbon release notes for what changed when it landed.

Where Carbon fits once it is running

The workloads that justify it are the ones that need the 1M window and more than one modality: whole codebases, long transcripts with speakers, scanned PDFs alongside their extracted text. If you are choosing between Google models, Gemini 4 Carbon vs Gemini 3.1 Pro is the direct comparison; if the alternative is a different vendor entirely, GPT-6.1 Sol vs Gemini 4 Carbon covers the same decision from the other side.

If you are still assembling a stack rather than migrating one workload, the LLM models list has the current catalogue with ids and prices, and the model page linked at the top is the one to check before you hard-code anything — prices and endpoints move.

The checklist

Store the key in an environment variable, not in the repository. Pick the endpoint that matches the SDK you already ship. Send only parameters from the supported list, and use response_format plus structured_outputs when the output feeds code. Budget output at 65K tokens and cache anything over 20K that you read more than twice. Expect a p50 near seven seconds and plan for the minority of calls that return an error. Then measure it on your own traffic, because a benchmark chart is a starting point and your request distribution is the only thing that decides whether it was the right pick.