Raphael Friedmann
← Understanding AI

How much electricity does an AI answer use?

Published figures put one chatbot answer at 0.24 to 0.34 Wh. What they include, why they spread so far, and my own RTX 5090: 0.115 Wh per answer alone, 0.024 Wh shared by 32.

“Isn’t AI terrible for the climate?” is a question I now hear more often than “which model should we use?”. It deserves a number, not a feeling. And there are numbers, from the operators themselves and from my own card. They agree more than you might expect, as long as you read what each one counts.

The published figures#

Two operators have put a figure on a single answer.

  • Google, August 2025: the median text prompt in the Gemini apps uses 0.24 Wh, measured on production traffic in May 2025. Google’s comparison: less than nine seconds of watching TV. Counting only the AI chips gives 0.10 Wh. (Google Cloud blog, paper)
  • OpenAI, June 2025: Sam Altman wrote that the average ChatGPT query uses about 0.34 Wh, “about what an oven would use in a little over one second”. (blog post) No method was published with it.

Neither figure has been checked by an independent third party, and both are self-reported. Still, they are the best data available, because only the operator can see the electricity meter.

Energy for one text answer, Wh
Google, chips only0.10Google, full data centre0.24OpenAI, average0.34My RTX 5090, one user0.115My RTX 5090, 32 users0.024
Google and OpenAI as published (data from May and June 2025). My rows are 500-token answers measured on 17 November 2026 and count the graphics card only, so they compare with Google's chips-only bar, not the full data centre.

Why the numbers spread so far#

Estimates for “one AI answer” spread widely. Four things explain most of it.

What is counted. Google’s two figures describe the same prompts. 0.10 Wh is the chips while they compute. 0.24 Wh adds the host CPUs and memory, machines kept idle as reserve, and the cooling and power losses of the building. Any figure without its boundary is half a figure.

How long the answer is. A model writes one token at a time, and every token costs one pass over the model. Twice the words means roughly twice the energy. A “median prompt” is a short exchange; a generated report is not.

Whether the model thinks first. Reasoning models write pages of hidden working-out before the answer. You don’t see those tokens, but the GPU computes every one of them. A hard question to a reasoning model can cost a multiple of a quick chat answer.

How many people share the GPU. This one surprises people most. Writing one token for one user is limited by memory bandwidth, not by compute: the card streams the model’s weights through its memory to produce a single word, and on my card that alone draws about half its 575 W power limit. Serve many users at once and that same pass produces a token for each of them, so the energy per answer falls.

Measured on my own card#

To put real watts on this, I measured my RTX 5090 running imp, the inference engine I build. The model is Flint, a mixture-of-experts model with 40 billion parameters, of which about 2.5 billion work on each token, in 4-bit.

One user 32 users at once
Board power while generating 303 to 308 W 331 to 333 W
Speed 355 to 386 tok/s 1,955 to 1,967 tok/s in total
Energy per 500-token answer 0.115 Wh 0.024 Wh

The method: three single answers and two rounds of 32 parallel requests, every answer 499 tokens long, board power read about every 130 ms with nvidia-smi and summed over the time each answer took. The card idles at 39 W. This counts the graphics card, not the rest of the PC, so it sits next to Google’s chips-only 0.10 Wh, not the 0.24 Wh.

One answer: 0.115 Wh. That is close to Google’s chips-only figure. A gaming card at home and a data centre land in the same range for a single short answer, helped here by a model that only uses 2.5 billion parameters per token.

32 users: a fifth of the energy per answer. With 32 requests sent at once (the engine works on up to 18 of them at a time, the rest wait a moment), the power draw rises only from about 305 to 332 W, while the output rises more than fivefold, from about 370 to 1,960 tokens per second. Each answer now costs 0.024 Wh, 4.9 times less than alone. This is the batching effect in real watts.

My first run missed it. Earlier the same day, the identical test showed no saving at all: a bug in imp’s automatic sizing let the engine run only two answers at once, so the 32 requests queued and each cost as much as a single one. With the fix the engine runs up to 18 answers at a time on this model. Sharing a GPU only saves energy if the engine really batches, so measure it rather than assume it.

What this means in practice#

Per answer, it’s small. 0.24 Wh times 100 answers a day for a year is 8.8 kWh. That is about what a kettle needs to boil 90 litres of water: noticeable over a year, not a lifestyle change.

In total, it’s large. The worry about AI and electricity is not your prompt. It’s the sum over every user, the training runs behind each model, and new data centres being built to serve them. None of that is in a per-prompt figure: Google’s number excludes training, networks and your own device.

Where you can actually save:

  • Pick the smallest model that does the job. Energy follows the parameters that work on each token, which is why Flint’s 2.5 billion active ones keep my card near 0.1 Wh per answer. A small model on a simple task often answers just as well.
  • Turn off thinking when you don’t need it. Reasoning on a lookup question burns tokens for nothing.
  • Ask for shorter answers. Fewer tokens out, less energy, and usually a better read.
  • Share the hardware. A card serving one person at a time pays a full pass over the model for every token; a batched service splits it across many. On my card, 32 users cut the energy per answer to a fifth. That is one more reason self-hosting rarely pays off for a single person or a small team. Privacy can still justify it; efficiency doesn’t.

Bottom line#

One chatbot answer uses roughly a quarter of a watt-hour by the operators’ own figures, about as much as a few seconds of TV. My own card needs 0.115 Wh for a 500-token answer with one user and 0.024 Wh when 32 users share it. The spread between estimates comes from what’s counted, how long the answer is, whether the model thinks first, and how many users share the GPU. The individual prompt is not the problem; the volume is. If you want to cut it, use smaller models, shorter answers, less thinking, and shared hardware.