apprun.icuAI footprint

Calculator · AI energy & emissions

What does 1,000 tokens of AI actually cost the grid?

Pick a model, describe your prompt, and get the electricity, CO₂e and water behind it — per 1,000 tokens and for a whole month of traffic. Twenty-eight benchmarked models, the carbon intensity of the grid that serves them, and the honest caveats.

Free no account Private runs in your browser Sourced published benchmarks Export CSV, share link, print

Your call

model & prompt

Balanced — 1K in / 1K out

Provider default — follows the selected model.

Per 1,000 tokens

input + output combined
Energy — Wh
Carbon — gCO₂e
Water — mL
Energy cost — ¢
This one call —

Same token count, each benchmarked prompt shape. A short prompt carries a fixed per-request cost over very few tokens, which is why it costs more per 1,000 tokens than a long-context call does.

Your month

100,000 calls
Electricity — kWh
Carbon — kgCO₂e
Carbon / year — tCO₂e
Water — L

    Same workload, other models

    sorted by energy

      Ranking uses the same prompt and the same grid, so the only difference is the model.

      Energy per 1,000 tokens, model by model

      28 models · benchmark, not invoice

      Watts per 1,000 tokens, normalised from the benchmark prompts so they can be compared directly. Shorter prompts look expensive per token because a fixed cost is spread over very few tokens — that is a real effect, not an error.

      Energy and carbon per 1,000 tokens for 28 language models
      Model Provider Size Wh / 1K short Wh / 1K balanced Wh / 1K long gCO₂e / 1K
      Llama 3.2 Vision 11B Meta 11B 0.177 0.107 0.082 0.041
      Llama 3.2 1B Meta 1B 0.175 0.109 0.030 0.042
      GPT-4.1 nano OpenAI undisclosed 0.257 0.136 0.039 0.048
      Llama 3 8B Meta 8B 0.230 0.144 not measured 0.056
      Llama 3.1 8B Meta 8B 0.257 0.165 0.052 0.063
      Llama 3.2 3B Meta 3B 0.287 0.189 0.050 0.073
      GPT-4.1 mini OpenAI undisclosed 1.052 0.423 0.138 0.149
      Llama 3.3 70B Meta 70B 0.617 0.428 0.143 0.165
      GPT-4o OpenAI undisclosed 1.052 0.607 0.155 0.214
      GPT-4o mini OpenAI undisclosed 1.052 0.709 0.183 0.250
      o1-mini OpenAI undisclosed 1.577 0.799 0.313 0.282
      Llama 3 70B Meta 70B 1.590 1.052 not measured 0.405
      o3-mini OpenAI undisclosed 2.125 1.224 0.254 0.432
      GPT-4.1 OpenAI undisclosed 2.295 1.256 0.368 0.443
      Claude 3.7 Sonnet Anthropic undisclosed 2.090 1.391 0.480 0.535
      Llama 3.2 Vision 90B Meta 90B 2.692 1.724 0.476 0.664
      Llama 3.1 70B Meta 70B 2.752 1.779 1.011 0.685
      o4-mini (high reasoning) OpenAI undisclosed 7.290 2.519 0.493 0.889
      o3-mini (high reasoning) OpenAI undisclosed 5.797 2.564 0.400 0.905
      Claude 3.7 Sonnet (extended thinking) Anthropic undisclosed 8.725 2.841 1.482 1.094
      GPT-4 OpenAI undisclosed 4.945 3.256 not measured 1.149
      GPT-4 Turbo OpenAI undisclosed 4.140 3.379 0.846 1.192
      Llama 3.1 405B Meta 405B 4.978 3.455 1.805 1.330
      DeepSeek-V3 DeepSeek 671B MoE 8.785 4.564 1.203 2.739
      o1 OpenAI undisclosed 11.115 6.050 1.521 2.134
      GPT-4.5 OpenAI undisclosed 16.807 10.250 2.652 3.616
      o3 OpenAI undisclosed 17.565 10.707 3.411 3.777
      DeepSeek-R1 DeepSeek 671B MoE 59.538 14.500 2.925 8.700

      Short = 100 input / 300 output tokens, balanced = 1K / 1K, long = 10K / 1.5K. Carbon uses each provider's modelled grid intensity.

      How these numbers are made

      No major lab publishes per-token energy for its API. The figures here come from an open, reproducible benchmark that combines the one thing everyone can observe — measured API latency and throughput — with published hardware and data-centre data. For every model the study estimates the power of the serving node, multiplies by Power Usage Effectiveness (PUE), and converts energy to CO₂e with the carbon intensity of the grid the provider runs on.

      • Energy. Node power × time, where time is output length ÷ tokens per second, plus time to first token. Batch size is assumed to be 8; a provider running batch 16 would use roughly 43% less energy per prompt.
      • Scaling your tokens. Each benchmark is a whole request of a known shape, so the calculator turns it into a rate per token for that shape and multiplies by your token count. A workload that matches a benchmark shape reproduces that benchmark exactly, and nothing is extrapolated beyond the three measured shapes. That is why the shape selector matters: long-context calls cost far less per token than short ones, because the fixed part of a request is the same either way.
      • Overhead. PUE of 1.12–1.27 covers cooling and power loss beyond the server.
      • Carbon. Energy in kWh × carbon intensity of the provider's grid (0.35–0.60 kgCO₂e/kWh in the study). Change it here to your own grid.
      • Water. On-site cooling water from WUE plus the water used generating the electricity off site.

      What is left out — and why it matters

      The study measures operational impact (scopes 1 and 2) and deliberately excludes the embodied carbon of manufacturing the hardware: attributing a whole GPU's footprint to a single prompt inflates per-call numbers and makes models incomparable. It also cannot see provider-side caching, quantization or speculative decoding, all of which change real energy. Treat the output as an order of magnitude plus a ranking — useful for choosing models, not for an audited disclosure.

      Cross-check: what Google measures in production

      Google is the only major provider that instruments its own serving stack. For May 2025 it reports that a median Gemini Apps text prompt consumes 0.24 Wh and 0.03 gCO₂e under a comprehensive boundary covering accelerators, host memory, idle capacity and cooling, and that software and procurement work cut median energy 33× and carbon 44× in a year. That is the honest benchmark to keep in mind: the number depends far more on the serving stack than the model name suggests.

      Sources

      1. N. Jegham, M. Abdelatti, L. Elmoubarki & A. Hendawi, How Hungry is AI? Benchmarking Energy, Water, and Carbon Footprint of LLM Inference, arXiv:2505.09598 (2025) — Table 1 and Table 4. arxiv.org/abs/2505.09598
      2. B. Elsworth et al., Measuring the environmental impact of delivering AI at Google Scale, arXiv:2508.15734 (2025). arxiv.org/abs/2508.15734
      3. Meta, Llama 2 model card — GPU hours, TDP and training emissions used to sanity-check hardware power assumptions. MODEL_CARD_LLAMA2.md
      4. The Green Grid / ISO/IEC 30134 for the PUE definition, and Our World in Data energy dataset (Ember and Global Carbon Project) for the national carbon intensities in the grid picker. github.com/OWID/energy-data
      5. Equivalence factors: US EIA, How much electricity does an American home use? (10,791 kWh per residential customer per year, 2022 data), and the US EPA Greenhouse Gas Equivalencies Calculator — 8,887 gCO₂ per gallon of gasoline, a 22.8 mpg weighted-average fleet, and an urban tree grown for ten years sequestering 23.2 lb of carbon a year. epa.gov/energy/greenhouse-gas-equivalencies-calculator

      Questions people actually ask

      short answers

      How do I calculate the carbon footprint of an LLM API call?

      Multiply the energy the call uses by the carbon intensity of the grid that serves it. If a prompt uses 2.5 Wh and the data centre runs on a grid with 0.35 kgCO2e per kWh, the call emits about 0.88 gCO2e: 0.0025 kWh × 0.35 kgCO2e/kWh. Energy and emissions are therefore two different numbers, and the same model can have very different footprints in different countries.

      How much energy does one LLM call use?

      It depends on the prompt shape far more than on the model name. In the benchmark behind this calculator, a balanced prompt (1,000 input + 1,000 output tokens) ranges from about 0.27 Wh for GPT-4.1 nano to 21.4 Wh for o3 — roughly a 79× spread. A short 100-in/300-out prompt costs about a third of that, while a 10K-in long-context prompt costs more but spreads its fixed cost over far more tokens.

      Why do short prompts cost so much more per 1,000 tokens?

      Because every request pays a fixed cost before a token comes out: the model is loaded, the request is scheduled, and the first token must arrive before the rest of the answer. On GPT-4.1 that works out at roughly 2.3 Wh per 1,000 tokens on a 400-token prompt but about 0.37 Wh per 1,000 tokens on an 11,500-token prompt, because the same fixed cost is spread over far more tokens. Output is also generated one token at a time, which is why trimming a long answer usually saves more than trimming the same number of context tokens.

      Does a bigger model always cost more carbon?

      No. Parameter count is a weak predictor because hardware, batching and serving software dominate. The benchmark shows reasoning models such as o3 and DeepSeek-R1 among the most energy-hungry per prompt, while GPT-4o costs less energy per prompt than the older GPT-4 Turbo despite being newer and more capable.

      How accurate are these numbers?

      Treat them as order-of-magnitude estimates, not invoices. They combine measured API latency and throughput with published accelerator power, data-centre PUE and grid carbon intensity, at an assumed batch size of 8. Providers do not disclose per-token energy, and Google — the only major lab measuring its own production stack — reports 0.24 Wh for a median Gemini Apps text prompt under a comprehensive boundary. Real values move with batch size, latency targets, caching and how clean the local grid is.

      Can I use this to report emissions to my team or auditor?

      Use it for scoping, model selection and honest relative comparisons between models, then replace the estimates with your provider's own reporting if you have one. For disclosure, report the boundary you used (accelerator only, or accelerator plus host, cooling and idle capacity), the grid intensity, and the date — because all three change the answer.