Gemini 4 Carbon vs Grok 4.7: The Price List Says 3x, the Invoice Says Nothing

Gemini 4 Carbon lists at $10 per million output tokens. Grok 4.7 lists at $6. On the two numbers every pricing page puts in bold, Carbon costs two-thirds more to talk and twice as much to read, and the obvious conclusion is that Grok 4.7 is the value pick. Then you measure what a finished task costs, and the two models come out one cent apart: $7.76 for Gemini 4 Carbon against $7.77 for Grok 4.7 on Artificial Analysis's Intelligence Index. Same bill, twenty-five index points of capability between them. That is the whole argument of this comparison, and it is not one that either vendor's rate card can show you.

The timing matters for how you read the rest. Gemini 4 Carbon became callable on the paid Gemini API on 10 November 2026, twelve days after Google announced it to a closed cohort. Grok 4.7 shipped from xAI on 21 September 2026 and has been routable since. One is a week old in public hands; the other has seven weeks of production use behind it.

Two rate cards that look further apart than they are

Start with the raw structure, because the tiering is where the two diverge in practice.

• Output price — Carbon $10 per million until 30 November 2026, then $20. Grok 4.7 $6 per million below 200,000 input tokens, then $12.

• Input price — Carbon $2, then $4 from 1 December. Grok 4.7 $2, stepping to $4 above the 200k line. Identical structure, identical numbers, different dates attached.

• Cached input — Carbon $0.10 per million now, $0.20 after 1 December, implicit caching only. Grok 4.7 $0.50, stepping to $1.00 on long prompts, with a 75% discount on the fresh rate.

• Context — Carbon 1,048,576 tokens. Grok 4.7 500,000. Carbon is the larger window by a factor of two.

• Output ceiling — Carbon 65,536 tokens synchronously, up to 1,048,576 with long decode. Grok 4.7 up to 450,000. In practice Grok writes longer answers in a single call than Carbon does by default.

• Input modality — Carbon takes text, image, audio, video and PDF. Grok 4.7 takes text, image and file.

• Weights — both closed. Neither can be self-hosted, so both carry the same vendor-risk exposure.

• Reasoning effort — Carbon thinking at low, medium and high; Grok 4.7 at low, high and xhigh. Published figures are quoted at high and xhigh respectively, which is the first thing to check before copying any headline score.

Two asymmetries in that list do real work. Carbon's 1M context is twice Grok's, which matters for whole-repository or multi-document work. Grok's 450K output ceiling is seven times Carbon's synchronous limit, which matters if the deliverable is itself long — a generated report, a migrated file, a long patch series. A model that can hold a million tokens of input but only write 65K back is not a long-output model, however the context window reads on a spec sheet.

The number that reconciles the two prices

Artificial Analysis measures both models on the same nine-evaluation index, version v5.0.1, and publishes a cost per index task that folds in how many tokens each model actually spends finishing the work. That measurement is the reason this comparison does not go the way the rate card suggests.

• Intelligence Index — Gemini 4 Carbon 60 at high effort, fourth of 74. Grok 4.7 35 at xhigh, forty-first of 74. Carbon's medium and low settings score 58 and 54; Grok's high and low settings both land at 35 and 31.

• Cost per index task — Carbon $7.76, Grok $7.77. One cent apart, in the expensive model's favour.

• Output tokens on the index — Carbon 205 million, Grok 148 million, against a 72.8 million median.

• Time per index task — Carbon 25.6 minutes, Grok 25.9 minutes. Again level.

• Output speed — Carbon 80 tokens per second, Grok 67. Carbon is the faster generator despite being the more expensive one.

• Time to first answer token — Carbon 66.85 seconds, Grok 53.64 seconds. Both are far outside the 12-second median for their price tier, and Grok is the quicker of the two to start.

The reconciliation is verbosity, not discount. Carbon emits 39% more output tokens per task than Grok does, and its output price is 67% higher, yet the total task cost lands within a cent because Grok's token price is not the only input into the bill — input volume, reasoning tokens and the per-task shape all contribute. Whatever the exact decomposition, the practical reading is the one that would survive any re-derivation: a per-token comparison between these two models tells you almost nothing about what a workload costs, and the two vendors' headline prices differ by more than their measured cost per outcome does.

Twenty-five points is not twenty-five points everywhere

A composite gap of this size usually survives decomposition; the question is where it does and does not. Three caveats before anyone budgets against 60-versus-35.

The first is effort. Carbon's 60 is at high effort, Grok's 35 at xhigh. Both are the vendors' preferred settings rather than matched ones, so the comparison is between each model run as its maker intends, not at equal compute. Turn either down and the gap narrows or widens depending on which end you move: Carbon at low is 54, Grok at low is 31.

The second is that the v5.0.1 index is nine evaluations blended, and the board does not publish per-benchmark scores for either model — every sub-chart on both pages reads "No publicly available API." So the honest statement is that Carbon wins the composite by 25 points and nobody outside Artificial Analysis can currently say which of the nine evaluations produced that margin. Anyone publishing a per-benchmark breakdown of this pair is either quoting a vendor or inventing one.

The third is that the index is one instrument. It is a good one, revised recently and applied consistently to both models, but it is not a product decision. A model that loses 25 composite points can still win the task you have, and the next two sections are about the cases where it does.

Where Grok 4.7 wins outright

Three of them, and the first is not a benchmark.

Maturity. Grok 4.7 has been generally available for seven weeks. Gemini 4 Carbon has been callable for one day after a rollout that changed shape twice in a fortnight — gated announcement on 28 October, paid API on 10 November, price doubling on 1 December. A team that needs a model to be the same thing next quarter has, at this moment, exactly one option in this pair with a track record.

Long single-call output. 450,000 tokens against 65,536 synchronous. If the job is "write the whole file" rather than "answer the question," the ceiling decides it before the index does.

Cost certainty on long prompts, if your input is small. Grok's step to $4/$12 only fires above 200,000 input tokens, and below that line its $6 output rate is a third of Carbon's post-December $20. For a workload with moderate input and heavy output — summarisation, drafting, transformation — the arithmetic does favour Grok, and the near-identical cost per index task is a statement about that particular nine-evaluation mix, not a universal law.

Against that, Grok's cached input at $0.50 per million is five times Carbon's current $0.10. For a RAG pipeline that re-sends the same 100,000-token corpus on every call, that single line can outweigh everything above it. This is the most common way a team picks the wrong model of these two: they compare output rates and never compute cache economics on their own traffic shape.

Where Carbon is worth the money

The case for Carbon is narrower than its index score and stronger than its price suggests.

Multimodal intake. Audio and video input are the cleanest separator in this entire comparison. Carbon ingests both; Grok 4.7 does not list either. A pipeline that has to watch a screen recording or transcribe-and-reason over a call has one candidate here, and no amount of index points closes that.

Cyber and vulnerability work. Google built Carbon for it, gated the first release to cyber defenders, and reports SEC-bench Pro at 88.2%, ExploitGym at 54.8% and CWE-bench at 71.0% — all vendor-reported and unreproduced, but the direction is consistent with the model's stated purpose and with the fact that Google chose to release it to defenders before developers. xAI makes no comparable cyber claim for Grok 4.7.

Whole-repository context. A 1M window against 500K. Twice the ceiling is a real difference for monorepo-scale tasks, and for the specific case of "hold the entire service in context and reason across it," Grok cannot follow.

And one honest counterweight: Carbon's advantage is bought with latency. At 66.85 seconds to first token and 25.6 minutes per index task, it is not a model to put behind a request-response interface without substantial patience. Neither is Grok at 53.64 seconds. If your product needs sub-10-second responses, this comparison is between two models that both lose, and the answer is a smaller, faster model on either side.

Running both, which is the actual answer

The reason this matchup resists a verdict is that the two models are shaped for different stages of the same pipeline. Carbon for the intake end, where modality and context dominate and volume is low. Grok for the long-output end, where the job is producing a lot of text from a bounded prompt, and where a $6 output rate beats a $20 one. Most teams that need either need both, and the mistake is signing up for two contracts, two SDKs and two billing relationships to get them.

One OpenAI-compatible endpoint is the shortcut, and it is available today for the routable half of this pair: grok/grok-4.7 sits on OrcaRouter at xAI's own $2/$6 — the same list price, passed through with 0% markup, including the $4/$12 step above 200,000 input tokens — alongside google/gemini-4-argon at $2/$10 for the Gemini-side work that does not need Carbon's modality set. Gemini 4 Carbon itself is not in the catalogue; it is reached through Google's paid API, and that leg of the pipeline is a direct integration.

The routing DSL is the part that makes the split practical rather than aspirational: the same request can be composed to try the cheap path and escalate on a validation failure, with automatic failover if a provider degrades. That matters more here than usual, because the expensive model in this pair has changed its access terms twice in fourteen days. A pipeline that can move a branch to a different model without a redeploy is the only version of this architecture that survives its own vendor's roadmap.

Choose by the constraint you actually have

• If the deliverable is long output from a bounded prompt — Grok 4.7, and check your cache volume first.

• If the input includes audio, video or scanned PDFs — Carbon, because there is no alternative in this pair.

• If the task is security analysis or vulnerability triage — Carbon, on the strength of Google's reported cyber numbers and the company's own gating choice, with the caveat that none of those figures has been independently reproduced.

• If you need the whole repository in context — Carbon's 1M window, accepting the latency.

• If you need a model whose terms will not change next month — Grok 4.7, and this is a stronger argument than it sounds.

• If you cannot decide — run both. The measured cost per task is within a cent, so a two-week bake-off costs roughly what one model costs, and it produces a better answer than any composite score.

What none of these lists can tell you is which model is smarter, because "smarter" is the wrong quantity at this distance. Twenty-five index points is a large gap measured properly, and it still leaves the cheaper-on-paper model tied on cost per outcome and ahead on output ceiling, maturity and time to first token. That is not a contradiction in the benchmarks. It is what happens when two models are built for different jobs and marketed with the same word.