Carbon Cost per ChatGPT Query: The Real Hidden Price in 2026

Carbon Cost per ChatGPT Query: The Real Hidden Price in 2026

Using ChatGPT feels instant—type a prompt, get an answer, move on. But new research based on the arXiv paper “The ultimate carbon cost of a ChatGPT query” tries to pin down what that convenience really means for the climate. Not just “energy use” in some abstract way, but an “ultimate carbon cost” attached to something familiar: a single query.

The punchline is surprisingly specific: the paper estimates the carbon cost per complex LLM query is on the order of ~$0.4 per query (with big uncertainty). It converts that into emissions too—roughly ~10 g CO₂e per query, where the dominant unknown isn’t hardware, it’s how many tokens the system actually processes.

Why This Matters (Right Now, Not “Someday”)

This research matters because “AI footprint” conversations often get stuck at two extremes: either people argue that it’s tiny compared to industries like shipping, or they throw vague horror stories at the wall. What this paper does differently is force a per-use lens—something normal users can actually reason about: “How much damage is bundled into each request I make?”

That’s especially urgent as LLM usage shifts from simple chat toward agentic and file-heavy workflows (code generation, document processing, “reasoning” modes, real-time web actions). The paper’s own logic shows why: when you ask for more tokens, you don’t just get a “longer answer.” You often trigger much more computation, and that’s where the carbon cost scales.

A real-world scenario you could apply today: imagine a team using an LLM daily to summarize reports, generate drafts, and run small “agent” tasks across uploaded documents. If their workflows quietly inflate token counts—say from ~1,000 tokens to tens of thousands—the emissions per “simple” action could jump by orders of magnitude, even if the app still feels like a single click.

And this builds on earlier AI research about responsibility and system impacts. The paper explicitly frames itself in the spirit of work like Bender et al.’s “Stochastic Parrots” (2021), which warned that we should understand AI as part of socio-technical systems—not as a magic capability with no downstream consequences. The new angle here is a measurable bridge between “what users do” and “what the climate has to live with next.”

What the Researchers Actually Built: From Hardware to “Ultimate Cost”

The paper’s structure is basically a long chain of assumptions—each link converts one kind of unknown into another. The goal isn’t to claim one “true number,” but to show a plausible order-of-magnitude for the climate consequences of running LLM queries.

The two footprints: operational vs embodied carbon

The researchers treat carbon emissions as coming from two places:

• Operational footprint: emissions from the electricity used during inference (and related compute).
• Embodied footprint: emissions tied to manufacturing and building the hardware that’s used to run the system.

They then roll these into a combined metric the paper refers to as carbon compute intensity (CCI): basically “how many grams of CO₂e you get per unit of compute,” in a way that can be scaled up to real usage.

“Ultimate carbon cost” vs “emissions today”

A key twist is that this isn’t just “how much CO₂ went out the stack.” The paper leans on a concept called ultimate cost, where emissions are translated into long-run impacts and expressed using a dollar-per-ton damage estimate.

In other words: rather than stopping at tons of emissions, it tries to convert to the kind of consequence accounting that matters for the far future. The paper uses a damage value of about $100k per ton of carbon oxidized (with a stated range from $10k to $750k, and an order-of-magnitude philosophy).

The method in one sentence

They:
1. estimate hardware + operational compute emissions per unit of compute (via CCI),
2. estimate the compute required per query (via token counts),
3. then convert those emissions into an ultimate carbon cost per query.

This is exactly the “hidden layers of abstraction” problem the paper wants to expose.

The Core Unknown: Tokens per Query (Why $0.4 Isn’t the End of the Story)

If there’s one variable that dominates everything in this estimate, it’s the number of tokens processed per query—not how impressive the output looks.

Tokens are the chunks of text the model “reads and reasons over.” In the simplest chat interaction, token counts might be relatively modest. But with modern apps, users increasingly trigger pipelines where token use explodes.

The paper gives a useful range:
- A “simple scenario” example is around ~1,000 tokens total.
- A “complex scenario” example is around ~30,000 tokens (e.g., code + file input via an agentic workflow).

And the paper also points out real-world variance: some systems can go much higher—50,000 tokens is mentioned as plausible in practice for tasks done via agentic tools.

The estimate range the paper lands on for emissions-per-query

The research ultimately reports a carbon cost-per-query estimate of about:

• ~$0.4 per query
• corresponding to ~10 g CO₂e per query

But the paper is careful: the dominant uncertainty is token count. It states that across a large token range, the carbon cost equivalently scales such that the per-query estimate could span something like:

• ~1.2 cents/query up to ~120 cents/query

That’s a two-order-of-magnitude swing—meaning your usage pattern could shift the climate burden dramatically even if you “feel” like you’re using the same AI service.

How They Cross-Checked Compute Intensity (CCI): The Hardware Reality Check

The paper doesn’t just pick one CCI number—it compares multiple life-cycle and compute-efficiency studies and shows why the uncertainty stays stubbornly large.

Embodied + operational CCI ranges from prior work

Here’s a comparison of the CCI-style values discussed in the paper (note: these are reported ranges from different analyses and studies, so they’re not meant to be perfectly apples-to-apples, but they show the spread the authors are dealing with):

What this comparison tells you: even before tokens enter the story, the carbon cost per compute unit isn’t pinned down well enough for a single confident value.

Why the paper chooses an example CCI around 1,000

For illustrative calculations tied to per-query emissions, the paper uses a CCI around ~1,000 g CO₂e per 10¹⁸ FLOP (consistent with the upper end of some ranges and aligned with operational assumptions).

That’s one reason the per-query number sits at an “order of magnitude” level—not a precise carbon bill.

Turning One Query into Grams and Dollars

Now we get to the part that people will actually argue about online: “How much is one query?”

From compute → emissions → per-query cost

The paper connects tokens to compute via a rough relationship (using earlier work): each token corresponds to some small amount of FLOPs that scale with the model architecture size.

Then, using CCI, they estimate emissions for a query. For a “complex” scenario, they arrive at the ~10 g CO₂e per query order of magnitude.

They also compute an intermediate metric: token carbon intensity (TCC), landing around:

• ~0.0012 cents per token (equivalently presented as ~1.2×10⁻³ cent/token)

But again: TCC is only helpful if you know tokens-per-query. And that’s exactly what most users and even many product teams don’t publicly track.

The big takeaway: per-query is small, but usage is multiplicative

A single query might be like a few cents worth of climate impact (again: order of magnitude). The real issue is that AI systems run at massive scale.

The paper explores this using an estimate of GPT-4 usage volume during its runtime as a primary model, producing an estimated total query count on the order of ~1.4×10¹² queries over its runtime window (with stated uncertainties due to user base interpolation and the fact that not all requests used GPT-4, plus the possibility of API calls increasing totals).

Even when the per-query burden is modest, the totals become enormous.

“Ultimate Carbon Cost” in Practice: What the Numbers Mean for People, Teams, and Product Design

The paper doesn’t just produce a number and walk away. It pushes you to use the number as a conversation tool.

Token leaderboards can be misleading (and environmentally dangerous)

The discussion around employee token usage is blunt for a reason. The paper notes that extremely high token totals reported via internal leaderboards are likely inflated or not tied to meaningful real-world outcomes, but they demonstrate how fast token consumption translates into carbon cost under the same compute-to-emissions logic.

The authors use that logic to show:
- 10,000,000 tokens-style scales become millions-level carbon cost in their per-token framing, even if the “work done” behind the tokens is questionable.

The implication for normal readers: token counters that are treated like trophies can create incentives for massive compute use—compute that may not deliver equivalent social value.

Why product teams should care about “token budgets”

If you’re building AI features, the token count per user action is basically your “carbon budget per click.”

This paper indirectly supports approaches like:
- caching and retrieval instead of repeated long context,
- limiting unnecessary tool calls,
- chunking documents smartly,
- offering “fast/cheap” modes versus “deep/expensive” modes.

This isn’t just cost optimization—it’s carbon optimization.

Key Takeaways

• Order-of-magnitude estimate: The paper estimates the carbon cost of a complex LLM query is about ~$0.4 per query, corresponding to ~10 g CO₂e per query.
• The biggest unknown is tokens per query: Carbon cost per query can swing from ~1.2 cents/query to ~120 cents/query depending on token usage (the paper emphasizes this uncertainty heavily).
• CCI uncertainty matters too: Prior life-cycle studies report CCI ranges that can differ a lot (e.g., values spanning roughly tens to over a thousand g CO₂e per 10¹⁸ FLOP, depending on methodology and assumptions).
• Per-query impact is small—but scale dominates: Even modest emissions per query add up fast when usage reaches hundreds of billions to trillions of queries.
• AI “token leaderboards” can distort behavior: If token counts are treated like achievements without tying to real outcomes, they can encourage compute waste—along with a hidden climate price.
• Practical next step for readers and teams: Treat tokens per user action as a measurable metric (and reduce it when possible). The paper’s framework gives you a way to translate “usage patterns” into climate-consequence language.

If you want, tell me what kind of user you are (casual chat, heavy coding agent, document-heavy workflow, etc.) and I can help estimate where you likely fall in that token range—and what that means in plain English.