Fact-Check: Does a ChatGPT Query Really Use 10x the Energy of a Google Search? What the Measured Data on AI Energy per Prompt Shows
“A ChatGPT query uses ten times the electricity of a Google search” is one of the most repeated numbers in technology. It has appeared in utility reports, keynotes and school assignments. When you trace ai energy per query back to the sources, though, the 10x ratio rests on two stale numbers. One is a 2009 Google blog post. The other is a 2023 remark about dollars, not watt-hours. This matters now because providers finally published measured figures in 2025. Utilities and regulators are also sizing grid upgrades partly on per-query stories. You will leave with the full provenance chain, every major disclosure checked against its primary source, and a first-principles energy model you can rerun. You also get a verdict, plus a measurement recipe that lets your team replace borrowed numbers with its own.
What this covers: where 3 Wh and 10x came from, what Google, OpenAI, Microsoft, Epoch AI, Mistral and Hugging Face actually reported, why reasoning and video break the “per query” frame, worked energy math, how to measure joules per token, and why per-query and grid-level numbers answer different questions.
Context and Background
Public debate about AI electricity has two levels that are often mixed up. The first is the marginal cost of one interaction: how many watt-hours a single prompt and response consume. The second is aggregate demand: how many terawatt-hours data centers draw from a grid each year. The 10x claim is a statement about AI energy per query, but it is usually quoted to make a point about the second level.
The aggregate picture is well documented. Lawrence Berkeley National Laboratory’s report for the US Department of Energy, released on 20 December 2024, found that US data centers used about 176 TWh in 2023, roughly 4.4% of national electricity. It projects 325 to 580 TWh by 2028, or about 6.7% to 12% of the total. The International Energy Agency’s Energy and AI special report, published on 10 April 2025, put global data center consumption at about 415 TWh in 2024, around 1.5% of world electricity, rising to about 945 TWh by 2030. The IEA’s April 2026 follow-up, Key Questions on Energy and AI, revised 2025 to 485 TWh after 17% growth in one year, with about 950 TWh expected by 2030.
We analysed what those numbers mean for transmission and generation in our analysis of AI data center power demand, the grid and nuclear in 2026. We also published a source audit of the per-query energy and water figures in AI energy and water per query, with every source traced. This article takes a narrower and more adversarial angle. It tests one specific claim, the 10x ratio, and rebuilds the number from physics so you can see which assumptions move it.
The incumbents in this debate are a small set of sources quoted over and over. They are Alex de Vries’s 2023 commentary in Joule, the Electric Power Research Institute’s (EPRI) 2024 Powering Intelligence report, and the IEA’s reports. More recently they include disclosures from Google, OpenAI and Mistral, plus independent estimates from Epoch AI, Microsoft Research and Hugging Face. Each primary document is linked below, and the most important one, Google’s August 2025 paper on measuring AI inference at scale, is the first production measurement of its kind from a hyperscaler.
AI Energy per Query: Tracing the 10x Claim to Its Source
Short answer: No, not for a typical text prompt in 2025 to 2026. The 10x figure came from a 2023 cost remark multiplied by a 2009 search estimate. Measured and disclosed figures since 2025 put a median text prompt at 0.24 to 0.34 Wh, about the same as Google’s 2009 search estimate. Reasoning, long-context and video workloads, however, can cost tens to hundreds of times more.

Figure 1: How a 2009 search estimate and a 2023 cost remark became the “10x a Google search” headline, and where measured 2025 data landed.
Figure 1 reads top to bottom. Three independent inputs feed the chain: Google’s 2009 search estimate, a February 2023 comment by Alphabet chairman John Hennessy, and a 2023 SemiAnalysis cost model. De Vries combined them in Joule. The IEA and EPRI then repeated the 2.9 Wh versus 0.3 Wh comparison. The headline that followed outlived every one of its inputs. The bottom node shows where measured 2025 numbers sit, roughly a factor of ten below the claim.
The denominator: a 2009 blog post about search
The 0.3 Wh “Google search” number comes from a January 2009 rebuttal by Urs Hölzle, then Google’s senior vice president of operations. He responded to press claims that a search emitted about 7 grams of CO2. Hölzle wrote that a search used about 0.0003 kWh, or 1 kJ, including work done ahead of time such as building the index. He put emissions at about 0.2 grams of CO2. As eWeek reported at the time, Google framed it as “many times too high” a figure being corrected downward.
Google has not published a replacement search figure since. That gap matters. Search infrastructure has had seventeen years of hardware generations, power usage effectiveness (PUE) gains and software changes. The fact-checking organisation Full Fact noted that Google told it its data centers had become more efficient since 2009. A researcher Full Fact consulted said any change was most likely a decrease. Yet search is no longer the same product. Since 2024 many Google results pages include AI Overviews, which run a language model. So the 2009 denominator describes a service that no longer exists in that form.
The numerator: a remark about cost, not energy
The “10x” itself traces to a Reuters article of 22 February 2023 on the economics of AI search. Reuters paraphrased Hennessy as saying an exchange with a large language model “likely cost 10 times more than a standard keyword search.” The context was money: inference hardware, depreciation and electricity together. Hennessy added that inference costs were “a couple year problem at worst.” In the same article, Morgan Stanley estimated Google’s 2022 cost per search at roughly a fifth of a cent.
De Vries’s commentary, “The growing energy footprint of artificial intelligence,” appeared in Joule on 10 October 2023. It took the 10x cost ratio, applied it to Hölzle’s 0.3 Wh, and arrived at about 3 Wh per LLM interaction. It cross-checked against a SemiAnalysis model of ChatGPT that implied 564 MWh per day across about 195 million requests, which is about 2.9 Wh per request. The paper’s larger contribution was a scenario. If every Google search used LLM-style AI, it would need about 29.2 TWh a year, comparable to Ireland’s electricity use. It also projected AI-related electricity could grow by 85 to 134 TWh a year by 2027.
Applying a cost ratio to energy is the original sin of this statistic. Cost ratios include the capital expense of accelerators, which in 2023 dominated the economics of inference. An H100-class server is far more expensive per watt than a search server. A 10x cost difference can therefore coexist with a much smaller energy difference.
The amplifiers: IEA and EPRI
The IEA’s Electricity 2024 report used the 2.9 Wh versus 0.3 Wh comparison. EPRI’s Powering Intelligence report, released at the end of May 2024, repeated it. EPRI also projected that US data centers could use 4.6% to 9.1% of US generation by 2030. Both organisations are credible on aggregate load. On the per-query ratio, however, they relayed de Vries and SemiAnalysis rather than measuring anything. Once two respected energy bodies printed the comparison, it became “established” in thousands of articles.
The SemiAnalysis input deserves one more note. According to Epoch AI’s reconstruction, the model behind the 2.9 Wh figure assumed around 2,000 output tokens per response, older A100 servers and servers running at full rated power. Typical chatbot replies are several times shorter. Each of those assumptions pushes the estimate up, and they compound.
Deeper Analysis: Rebuilding LLM Inference Energy per Prompt from First Principles
The quickest way to judge any per-prompt number is to rebuild it. The energy of one query is not a property of “ChatGPT” or “AI.” It is the product of a handful of physical quantities: tokens processed, energy per token on a given system, and the overheads around the accelerator.

Figure 2: The components of energy per query, with the shares Google reported for its median Gemini Apps text prompt in May 2025.
Figure 2 decomposes one query. Input tokens go through prefill, which is compute-bound and processes the whole prompt in parallel. Output tokens, including any hidden reasoning tokens, go through decode, which generates one token at a time and is bound by memory bandwidth. Both land on the accelerator. Host CPUs and memory, idle machines held for traffic spikes, and facility overhead then sit on top. The dashed edges show the two biggest levers: batching divides accelerator energy across many users, while model size and numeric precision multiply it.
What the measured disclosures say
The table below lists every major figure with its scope. The numbers are quoted from the primary sources.
| Source and date | Figure | What it covers | What it leaves out |
|---|---|---|---|
| Hölzle, Google, Jan 2009 | 0.3 Wh per search | Search incl. index building | Network, devices; 2009 hardware |
| de Vries, Joule, Oct 2023 | about 3 Wh per interaction | 10x cost ratio times 0.3 Wh | Any measurement |
| SemiAnalysis via de Vries, 2023 | about 2.9 Wh per request | 564 MWh per day over 195M requests | Long replies assumed; A100 era |
| Epoch AI, Feb 2025 | about 0.3 Wh | GPT-4o-class estimate, 500 output tokens, H100 | Long inputs, reasoning |
| Sam Altman, Jun 2025 | 0.34 Wh “average query” | ChatGPT, per OpenAI CEO blog | No methodology published |
| Google, Aug 2025 | 0.24 Wh median text prompt | Gemini Apps, accelerators, host, idle, PUE | Training, networking, user devices |
| Microsoft Research, Sep 2025 | 0.31 Wh median, IQR 0.16 to 0.60 | Frontier-scale models on H100 nodes | Specific commercial products |
| Hugging Face AI Energy Score, Dec 2025 | 30x average for reasoning | 40 open models, same hardware | Closed models; GPU-centred |
Epoch AI’s estimate, by Josh You and published on 7 February 2025, is a transparent back-of-envelope model. It assumed GPT-4o has about 100 billion active parameters, 500 output tokens per query and roughly 2 floating-point operations per active parameter per token. It ran this on H100s at 10% compute utilisation and about 70% of peak power, with 1,500 W per GPU including server and facility overhead. The result was about one second of H100 time, or roughly 0.3 Wh. Epoch called its 500-token assumption pessimistic.
Sam Altman’s 10 June 2025 essay “The Gentle Singularity” stated that “the average query uses about 0.34 watt-hours, about what an oven would use in a little over one second.” He added a water figure of about 0.000085 gallons. OpenAI has not published the boundary, model mix or method behind the number. It is a disclosure, not a measurement you can audit.
Google’s paper, “Measuring the environmental impact of delivering AI at Google Scale,” is the most rigorous source. Its authors include Jeff Dean, Amin Vahdat and David Patterson. For the median Gemini Apps text prompt in May 2025, it reports 0.24 Wh, 0.03 gCO2e and 0.26 mL of water. The breakdown is 0.14 Wh for active accelerators (58%), 0.06 Wh for host CPU and DRAM (25%), 0.02 Wh for idle machines (10%) and 0.02 Wh for data center overhead (8%). The fleet PUE was 1.09. Crucially, the authors show that a narrower boundary, counting only active accelerators in the most efficient sites, would yield just 0.10 Wh. They argue that this narrower approach, common in the literature, understates the real footprint by 2.4x.
The Google paper also reports a 33x reduction in energy per median prompt between May 2024 and May 2025. It attributes 23x to model improvements and 1.4x to better machine utilisation, with emissions per prompt falling 44x. That single year of change is larger than the entire gap between the 10x claim and today’s measurements. A per-query figure is therefore a snapshot of a fast-moving target.
Microsoft Research’s paper by Felipe Oviedo and colleagues, submitted to arXiv on 24 September 2025 and now in Joule, modelled frontier-scale models above 200 billion parameters on H100 nodes. It found a median of 0.31 Wh per query, with an interquartile range of 0.16 to 0.60 Wh. The authors state directly that “widely cited estimates are overstated by 4-20x.” For long queries about 15 times longer than typical, the median rose to 3.91 Wh. That is a 13x jump driven only by token count.
Mistral’s July 2025 life-cycle analysis, produced with Carbone 4 and France’s ecological transition agency ADEME, takes a different approach. It reports environmental impact rather than energy. For a 400-token response on Le Chat it gives 1.14 gCO2e, 45 mL of water and 0.16 mg of antimony-equivalent material depletion. It also reports totals for Mistral Large 2’s training plus 18 months of use: 20.4 ktCO2e and 281,000 cubic metres of water. Mistral did not publish a Wh per query figure, so it cannot be compared with the others on energy directly. Its value is the life-cycle boundary, which includes hardware manufacturing.
A worked calculation, labelled illustrative
The numbers below are illustrative, chosen to be physically plausible rather than measured on a specific system. They show why the same model can produce a 0.3 Wh query or a 20 Wh query.
Take one 8-GPU H100 node serving a model with roughly 100 billion active parameters. Assume the node draws about 7 kW at the wall while busy, which is below its rated maximum. Under heavy continuous batching, assume it sustains 3,000 output tokens per second across all concurrent users. Energy per output token is then 7,000 W divided by 3,000 tokens per second, or about 2.3 J per token.
A 500-token answer costs about 1,170 J, or 0.33 Wh. Multiply by a PUE of 1.1 and it becomes about 0.36 Wh. That lands within a few percent of Altman’s 0.34 Wh and inside Microsoft’s interquartile range. Now change one assumption at a time:
- No batching. If the same node serves a single user at 50 tokens per second, energy per token rises to 140 J. The same 500-token answer costs 70 kJ, or about 19 Wh. Batching alone is a 60x lever.
- Reasoning. Keep heavy batching but generate 10,000 hidden reasoning tokens before a 500-token answer. The query now costs about 24 kJ, or 6.7 Wh, roughly 20x the plain answer.
- Long input. Feed in a 100,000-token document. Prefill is more efficient per token than decode, but attention cost grows with context length. Epoch estimated around 40 Wh for such a query, and about 2.4 to 2.5 Wh for 10,000 input tokens.
- Smaller model. Swap in an 8B-parameter model. MIT Technology Review’s May 2025 measurements on H100s found 114 J per response for Llama 3.1 8B, versus 6,706 J for Llama 3.1 405B, after doubling GPU energy to approximate the full server. That is about 0.03 Wh versus 1.9 Wh.
The lesson is that “energy per query” has at least four free variables: model size, tokens out, tokens in and batch efficiency. Any claim that does not state them is not a measurement; it is a shape with a number attached. For the serving-side mechanics behind batch efficiency, see our explainer on chunked prefill and prefill-decode interference in vLLM and SGLang.
Why reasoning and media break the “per query” unit

Figure 3: The workload ladder. A short text prompt sits near the 2009 search figure, but reasoning, agents, long context and video sit orders of magnitude higher.
Figure 3 places workloads on a ladder. The bottom rung, a short text prompt, is now about the same order as the 2009 search figure. Each branch to the right adds multiples. Long-context input adds prefill work. Reasoning adds hidden tokens. Agentic loops multiply the number of model calls per user task. Image and video generation use diffusion models whose energy scales with resolution, steps and frames.
Hugging Face’s AI Energy Score project, led by Sasha Luccioni with Salesforce’s Boris Gamazaychikov, measured 40 open models on identical hardware using CodeCarbon, as Fortune reported on 5 December 2025. Reasoning models used on average 30 times more energy than models without reasoning or with it switched off. A slimmed-down DeepSeek R1 went from 50 Wh per 1,000 prompts with reasoning off to 7,626 Wh with it on. Microsoft’s Phi 4 reasoning model went from about 18 Wh to 9,462 Wh. OpenAI’s largest gpt-oss model used 5,313 Wh on its “low” reasoning setting and 8,504 Wh on “high.” Per prompt, that is roughly 0.02 to 9.5 Wh across the same tasks.
Media generation sits further up. MIT Technology Review measured 2,282 J for one 1024 by 1024 image from a Stable Diffusion 3 model, about 0.6 Wh. It reported that a five-second clip from the CogVideoX video model took roughly 700 times the energy of a high-quality image. In other words, one short video can cost as much energy as thousands of text prompts.
This is the real update the 10x claim misses about AI energy per query. The question “how much energy does an AI query use” has no single answer, because “query” now covers workloads spanning three to four orders of magnitude. The IEA’s 2026 Key Questions report makes the same point: simple text queries typically use less electricity than running a television for the same time. Reasoning, video and agentic tasks, it says, can use hundreds or thousands of times more.
Verdict and the Grid: Per-Query versus Aggregate Data Center Electricity for AI
Our verdict on the claim depends on how it is phrased, so we grade three versions.
| Claim as stated | Verdict | Reason |
|---|---|---|
| “A ChatGPT query uses about 3 Wh” | Outdated | Derived in 2023 from a cost ratio; measured 2025 medians are 0.24 to 0.34 Wh |
| “A ChatGPT query uses 10x the energy of a Google search” | Mostly False for typical text prompts | Numerator fell about 10x; denominator is a 2009 figure for a product that has changed |
| “Some AI queries use far more energy than a search” | True, context-dependent | Reasoning, long-context, agentic and video workloads can be 10x to 1,000x a text prompt |
Why a small per-query number does not mean a small grid problem
A common error now runs in the opposite direction. People take 0.34 Wh, note that it is about one second of oven use, and conclude that AI electricity is a non-issue. The aggregate data say otherwise, and both things can be true at once.
Run the arithmetic, illustratively. Microsoft’s paper estimates that 1 billion queries per day at its median requires about 0.7 GWh per day, or about 0.26 TWh per year. Media outlets reported in mid-2025 that ChatGPT handled about 2.5 billion prompts per day; treat that volume as reported, not verified. At Altman’s 0.34 Wh, it gives about 0.85 GWh per day, or roughly 0.31 TWh a year. Set that against the IEA’s 485 TWh for all data centers in 2025. Simple chatbot text, even at that scale, is a rounding error.
So where does the growth come from? Four places, none of which a per-query number captures:
- Training and experimentation. Frontier training runs occupy tens of thousands of accelerators for months. Google’s paper explicitly excludes training from its 0.24 Wh boundary.
- The tail of the workload distribution. If 10% of queries are long or reasoning-heavy, Microsoft’s model shows daily energy for 1 billion queries rising from 0.7 to 1.7 GWh. The tail, not the median, sets the total.
- Capacity built ahead of demand. Grid planners size connections for peak draw and future racks, not today’s average query. Rack densities of 100 kW and more, which we covered in our guide to 800V DC power architecture for AI data centers, change how utilities plan regardless of per-query efficiency.
- Rebound effects. When each query gets cheaper, providers add reasoning, agents and video, and users ask more. Google’s 33x efficiency gain in one year coincided with rapid growth in total data center electricity.
AI energy per query is therefore the right metric for product engineers comparing designs. It is the wrong tool for predicting grid load. Grid planners should use metered site demand, interconnection queues and capacity forecasts, as LBNL and the IEA do.
Measuring Joules per Token on Your Own Inference Stack
The most useful outcome of this AI energy consumption fact check is to stop borrowing numbers. If you serve models, you can measure your own energy per query within a few percent, at least for the accelerator and host share.

Figure 4: A measurement pipeline that joins GPU and host energy counters with per-request token logs to produce Wh per query percentiles.
Figure 4 shows the pipeline. GPU energy comes from the NVIDIA Management Library (NVML) energy counter, exported through DCGM or polled with nvidia-smi. Host CPU and DRAM energy comes from Intel or AMD RAPL counters, which Kepler exposes on Kubernetes. Prometheus stores both as time series. Separately, your inference server logs input and output tokens per request. An attribution job divides energy over a window by tokens in that window, by model and route. Multiplying by your site’s PUE and grouping by request yields Wh per query percentiles. For one-off scripts and benchmarks, CodeCarbon gives a quicker estimate.
Step 1: read the GPU energy counter, not instantaneous power
NVML provides a cumulative energy counter, nvmlDeviceGetTotalEnergyConsumption, which reports millijoules since the driver was last loaded on Volta-generation and newer GPUs. Differencing a counter is more robust than integrating sampled power readings. A University of Oxford study, “Part-Time Power Measurements: nvidia-smi’s Lack of Attention” by Zeyu Yang, Karel Adámek and Wesley Armour, found that on A100 and H100 GPUs only about 25% of runtime was sampled for power. Naive single-run energy measurements produced errors of up to about 70% in their tests. Their recommended practice, with repeated runs, phase-shifting delays and trimming of the rise time, cut average error from 39.27% to 4.89%.
# Illustrative: measure GPU energy for a fixed load test window.
# Requires the nvidia-ml-py package (import name pynvml).
import time, pynvml
pynvml.nvmlInit()
handles = [pynvml.nvmlDeviceGetHandleByIndex(i)
for i in range(pynvml.nvmlDeviceGetCount())]
def energy_mj():
return sum(pynvml.nvmlDeviceGetTotalEnergyConsumption(h) for h in handles)
start_e, start_t = energy_mj(), time.time()
tokens_out = run_load_test(duration_s=300) # your harness: returns output tokens served
end_e, end_t = energy_mj(), time.time()
joules = (end_e - start_e) / 1000.0
print(f"GPU energy: {joules:.0f} J over {end_t - start_t:.0f} s")
print(f"GPU J per output token: {joules / tokens_out:.3f}")
Run the test for minutes rather than seconds, at realistic concurrency, and repeat it several times. A single short run of one prompt measures the worst case, an idle GPU spinning up for one user, which is exactly the error that inflated early estimates.
Step 2: add the host and the idle reserve
Google’s breakdown shows why GPU-only numbers mislead: host CPU and DRAM added 25% and idle machines another 10% to its median. On Kubernetes, Kepler attributes node energy from RAPL and other sources to pods and containers. Our Kepler 0.12 deep dive on Kubernetes energy attribution, GPU MIG power and carbon metrics covers deployment and the attribution model’s limits. Idle reserve is a policy choice, not a measurement artefact. If your autoscaler keeps 30% headroom, that energy belongs to the service and should be counted.
Step 3: join energy with tokens and report a distribution
Log input tokens, output tokens, reasoning tokens if your API exposes them, model ID and route for every request. Then compute energy per token over fixed windows and allocate it to requests in proportion to tokens. Because prefill and decode have different costs, a better model uses separate coefficients for input and output tokens, fitted by regression across windows with different mixes. Report p50, p90 and p99 Wh per query, not a mean. The mean hides the reasoning tail that dominates your bill and your carbon footprint. If you already export GenAI telemetry, the token attributes in OpenTelemetry’s GenAI semantic conventions give you the request side of the join.
Step 4: quick estimates with CodeCarbon
For notebooks, batch jobs and model comparisons, CodeCarbon wraps the same counters, NVML for GPUs and RAPL for CPUs where available, and writes energy in kWh plus estimated emissions to a CSV file. It is the tool Hugging Face used for AI Energy Score. It is convenient but coarse. It estimates rather than measures when counters are missing, such as CPU power on some cloud VMs, and it does not see facility overhead.
# Illustrative: compare two models on the same prompt set with CodeCarbon.
from codecarbon import EmissionsTracker
for model_id in ["small-model", "large-model"]:
tracker = EmissionsTracker(project_name=f"energy-{model_id}",
output_file="emissions.csv")
tracker.start()
n_prompts = run_eval_prompts(model_id) # your harness
tracker.stop()
# Read the energy_consumed column (kWh) per run from emissions.csv
# and divide by n_prompts to get kWh per prompt.
Trade-offs, Gotchas, and What Goes Wrong
Boundary choice changes the answer by 2x or more. Google’s own paper shows 0.10 Wh under a narrow accelerator-only boundary and 0.24 Wh under its comprehensive one. Neither is wrong, but comparing one provider’s narrow number with another’s broad one creates a fake efficiency gap. Always ask what is included: host, idle reserve, PUE, networking, training amortisation, embodied hardware.
Medians hide the bill. Google, Microsoft and OpenAI all report a median or average for text. If your product enables reasoning by default, your median user may look like Google’s, while your p90 user costs 20x more. Capacity and carbon budgets should be sized on the distribution.
Vendor disclosures are unaudited. Altman’s 0.34 Wh came with no methodology. Google’s paper is detailed but self-reported and uses market-based emissions accounting, which credits clean-energy purchases. Mistral’s LCA was peer-reviewed by two consultancies, but is still company-commissioned. None of these is a third-party audit to a published standard. Treat them as the best available evidence, not ground truth.
Hardware generations make numbers expire. An H100-era figure may not hold on Blackwell or later hardware. Lower-precision formats such as FP8 and FP4 also change energy per token substantially. Our FP8 versus INT8 versus INT4 quantization benchmark shows how precision shifts throughput, which moves J per token in the opposite direction. Date-stamp every number you publish.
Benchmarks are not production. AI Energy Score and MIT Technology Review used controlled single-system runs with fixed prompts. Production fleets batch thousands of concurrent users, use speculative decoding and prefix caching, and carry idle reserve. Lab numbers can be higher or lower than production for the same model.
Search is now AI too. Comparing “AI” with “search” assumes two separate services. With AI Overviews on many results pages, the comparison has partly collapsed into one product. A modern search-with-summary query is closer to an LLM query than to Hölzle’s 2009 search.
Energy is not carbon or water. A 0.24 Wh prompt on a coal-heavy grid emits more than a 1 Wh prompt on hydro. Water depends on cooling design and the generating mix. Our liquid cooling guide for AI data centers explains how cooling choices trade PUE against water use.
Practical Recommendations
If you publish, quote or act on AI energy per query figures, the fix is mostly discipline. State the workload, the boundary, the date and the source in the same sentence as the number. Retire “10x a Google search” from slide decks; it is a 2023 cost remark multiplied by a 2009 estimate. If you need a single figure for a typical 2025-to-2026 text prompt, “about 0.2 to 0.4 Wh, per Google, OpenAI and Microsoft disclosures” is defensible. Add that reasoning and media workloads run far higher.
If you build or run AI services, measure. The pipeline in Figure 4 takes days, not months, to stand up, and it gives you numbers for your models, your batch sizes and your traffic mix. Use those numbers in design reviews. Choosing a smaller model for routing, capping reasoning budgets, enabling prefix caching and raising batch efficiency are all energy decisions as much as cost decisions. Our article on LLM inference SLOs, goodput and capacity planning covers the latency side of that trade.
If you are a policymaker or grid planner, use aggregate data, not per-query anecdotes. Site-level metered demand, interconnection requests and the LBNL and IEA scenarios are the right inputs.
Checklist:
- [ ] Replace any “3 Wh” or “10x” figure in your materials with a dated, sourced range.
- [ ] Specify the boundary: accelerators only, plus host, plus idle, plus PUE.
- [ ] Measure GPU energy with NVML counters over long, repeated runs.
- [ ] Add host energy through Kepler or RAPL and count idle reserve.
- [ ] Join energy with per-request token logs and report p50, p90 and p99.
- [ ] Track reasoning tokens separately and set reasoning budgets per route.
- [ ] Convert energy to carbon with your grid’s location-based and market-based factors, and report both.
- [ ] Re-measure after every model, hardware or serving-stack change.
Frequently Asked Questions
How much energy does a ChatGPT query use?
OpenAI CEO Sam Altman wrote in June 2025 that the average ChatGPT query uses about 0.34 Wh, but OpenAI has not published the method or boundary. Independent estimates agree on the order of magnitude. Epoch AI estimated about 0.3 Wh for a GPT-4o-class text query in February 2025. Microsoft Research modelled a 0.31 Wh median for frontier-scale models. Queries with long documents, reasoning or image generation can use many times more, so a single number describes only short text exchanges.
Is the “10x a Google search” claim true?
Not for a typical text prompt today. The ratio comes from Alphabet chairman John Hennessy’s 2023 remark that an LLM exchange likely cost 10 times more than a keyword search. De Vries multiplied that cost ratio by Google’s 2009 estimate of 0.3 Wh per search to reach about 3 Wh. Measured 2025 figures for median text prompts are 0.24 to 0.34 Wh, which is roughly the 2009 search figure. The claim is best described as outdated and mostly false.
Why do AI energy estimates vary so much?
Because energy per query depends on several independent variables. These are the model’s active parameter count, the number of output and reasoning tokens, and input context length. Batch efficiency and utilisation, hardware generation and numeric precision matter too, as do boundary choices such as whether idle servers and cooling overhead are included. Google showed a 2.4x gap from boundary choice alone. In illustrative calculations, batching alone can change energy per answer by around 60x on the same hardware.
Do reasoning models use more energy?
Yes, substantially. Hugging Face’s AI Energy Score tests in late 2025 found reasoning models used about 30 times more energy on average than models without reasoning or with it switched off. Some models used hundreds of times more. Reasoning models generate long chains of hidden tokens before answering, and every token costs decode energy. Microsoft Research found that queries about 15 times longer than typical raised the median from 0.31 Wh to 3.91 Wh. Capping reasoning budgets is one of the most effective energy controls available.
How can I measure the energy of my own LLM inference?
Read the GPU’s cumulative energy counter through NVIDIA’s NVML library rather than sampling instantaneous power. Run realistic load for several minutes, repeat the test, and divide energy by tokens served. Add CPU and memory energy using RAPL counters or Kepler on Kubernetes, then multiply by your data center’s PUE. Join the results with per-request token logs to report median and tail energy per query. CodeCarbon offers a quicker, coarser option for scripts and model comparisons.
Is AI a big share of global data center electricity?
Data centers as a whole used about 485 TWh in 2025, according to the IEA’s 2026 Key Questions on Energy and AI report, after 17% growth in one year. The IEA expects about 950 TWh by 2030, around 3% of global demand, with AI-focused data centers tripling their use. Simple chatbot text is a small slice of that total. Training, reasoning-heavy and agentic workloads, media generation and capacity built ahead of demand drive most growth.
Further Reading
- AI data center power demand, the grid and nuclear in 2026: the aggregate, grid-level side of the story that per-query numbers cannot answer.
- 800V DC power architecture for AI data centers: how rack-scale power delivery and conversion losses shape facility overhead.
- Kepler 0.12 for Kubernetes energy attribution, GPU MIG power and carbon metrics: the tooling behind step 2 of the measurement pipeline.
- AI energy and water per query, every source traced: our companion audit, which also covers water and training.
- Software Carbon Intensity and carbon-aware scheduling: turning energy measurements into a standard carbon metric.
- Primary source: Elsworth et al., “Measuring the environmental impact of delivering AI at Google Scale” (arXiv:2508.15734).
- Primary source: Oviedo et al., “Energy Use of AI Inference: Efficiency Pathways and Test-Time Scaling” (arXiv:2509.20241).
- Primary source: Epoch AI, “How much energy does ChatGPT use?” and US DOE on the LBNL 2024 data center report.
By Riju — about
