ForHosting KIT · Science

AI water footprint calculator

A thousand AI queries at half a liter each consume 500 liters of freshwater, or 0.5 cubic metres: enter your own query count and the intensity from your source to get a transparent figure for a report. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Queries: 1,000
Liters per query: 0.5

You get

Total water liters: 500
Total water ml: 500,000
Total water m3: 0.5
Total water us gallons: 132.086026179

Every large-language-model query consumes electricity at a data centre, and that electricity is typically cooled with evaporative cooling towers that withdraw and consume freshwater. Sustainability teams, product managers, and journalists therefore want a transparent water footprint of AI usage rather than a vague claim that chatbots use a lot of water. This AI water footprint calculator estimates total water in liters by multiplying the number of queries by the liters consumed per query, using the intensity you supply from a published study, a vendor disclosure, or your own metering. Zero queries or a zero intensity is valid and returns zero liters.

What an AI water footprint is and how the linear identity works

The water footprint of a digital service is the volume of freshwater consumed to deliver that service, not the water that merely passes through a cooling loop and is later returned to a river. For generative AI the dominant freshwater term at many data centres is evaporative cooling: electricity becomes heat, heat is rejected in cooling towers, and a fraction of the circulating water evaporates into the atmosphere.

Published studies therefore report a water intensity in liters or milliliters per prompt, per conversation, or per kilowatt-hour of model energy, and a usage count converts that intensity into a total. You supply both factors because intensity is not a universal constant: it depends on the model family, the token length, the region, the cooling technology, and whether the figure is consumption or withdrawal. A one-thousand-query workload at half a liter per query is five hundred liters; the same workload at 1.29 milliliters per query is 1.29 liters.

What you can do with it

Monthly product sustainability reports

Multiply billed AI queries by a disclosed liters-per-query intensity and record total freshwater in liters, cubic metres, and US gallons for an environmental disclosure.

Classroom and journalism estimates

Let students or reporters vary query count and intensity, then verify that total water equals queries times liters per query without unit-conversion mistakes.

Internal AI usage dashboards

Convert a prompt log into a site water balance so procurement and operations can compare models by freshwater, not only by tokens or dollars.

FAQ

What happens if queries or liters per query is negative?

A water footprint cannot be a sink under this linear model, so any negative factor is rejected and is not billed.

What liters-per-query value should I use?

Use a published study, a vendor water-intensity disclosure, or your own metering. Intensity is not a universal constant: it depends on the model, token length, region, and cooling technology.

How is the AI water footprint calculated?

Multiply the number of queries by the liters of water each query consumes. One thousand queries at half a liter each come to 500 liters, which the result also shows as milliliters, cubic metres and US gallons.

Why does using AI consume water?

Data centres turn electricity into heat, and many get rid of that heat in evaporative cooling towers, where part of the circulating freshwater evaporates. That evaporated water is what a water footprint counts.

Is water returned to a river counted in the total?

No. The footprint covers freshwater consumed, mainly the part that evaporates, not water that only passes through a cooling loop and goes back. Check whether your source figure measures consumption or withdrawal before using it.

Related tools

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/eco/ai-water-footprint

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/eco/ai-water-footprint \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"queries":1000,"liters_per_query":0.5}'

const res = await fetch("https://api.kit.forhosting.com/eco/ai-water-footprint", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "queries": 1000,
    "liters_per_query": 0.5
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/eco/ai-water-footprint",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "queries": 1000,
    "liters_per_query": 0.5
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/eco/ai-water-footprint", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"queries":1000,"liters_per_query":0.5}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"queries":1000,"liters_per_query":0.5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/eco/ai-water-footprint", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "queries": 1000,
  "liters_per_query": 0.5
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "eco.ai_water_footprint",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Technical notes

Negative query counts and negative intensities are rejected as invalid_input because a water footprint cannot be a sink under this linear model.

What an AI water footprint is and how the linear identity works

This calculator uses the linear identity total_water_liters equals queries times liters_per_query. The endpoint also reports milliliters, cubic metres, and US liquid gallons so a sustainability notebook can drop the total into a household-equivalent or a site water balance without a side conversion. It does not invent an intensity from a model name, does not call a telemetry API, and does not apply a scarcity-weighted overlay; those layers sit outside this multiply and should be applied in your own bookkeeping if a regional water-stress factor is required.

Input contract, aliases, and what happens when a value is negative

Zero is valid on either factor and returns zero liters, which is the correct result for an unused service or a dry-cooled intensity of zero. Example: one thousand queries times 0.5 liters per query is 500 liters, which is 500000 milliliters, 0.5 cubic metres, and about 132.086 US gallons. Pair the volume with your own scarcity weights or energy-based intensities if the inventory protocol requires them. POST a JSON body with two required finite numbers: queries, the count of AI prompts or billed conversations in the period you are estimating, and liters_per_query, the water intensity in liters consumed per query. Accepted aliases for the count are query_count, n_queries, ai_queries, and prompt_count. Accepted aliases for the intensity are liters, l_per_query, water_per_query, water_intensity, and liters_query. Each field may arrive as a JSON number or as a decimal numeric string. Missing fields, empty strings, non-finite values, and magnitudes beyond the supported absolute ceiling fail with invalid_input naming the field. A negative query count or a negative intensity is rejected because a water footprint cannot be a sink under this linear model; the error message states that the field cannot be negative and the request is not billed. On success the body echoes the cleaned queries and liters_per_query, and returns total_water_liters as the primary volume together with total_water_ml, total_water_m3, and total_water_us_gallons, plus formula and equation strings for display.

Where an AI water footprint calculator earns its keep

Product sustainability teams use an AI water footprint calculator so a monthly query log times a disclosed liters-per-query figure becomes a liters total they can drop into an environmental report without opening a spreadsheet of unit conversions. Failed validation does not consume balance. Keep requests small, pin the rounded liter and gallon figures in tests, and you get reproducible water-footprint estimates for homework, LMS plugins, sustainability scripts, and edge workers without standing up environmental middleware of your own. Classroom climate labs and journalism desks need a deterministic oracle that rejects a negative count as invalid_input instead of returning a hollow success with a negative volume that a buggy pipeline might accept as a credit. Internal AI-usage dashboards and procurement reviews often convert billed completions into a site water balance before they load full life-cycle software; calling a tiny parse API avoids pulling a desktop workbook for a two-factor multiply.

Technical questions

How do I estimate the water footprint of AI usage?

Send a finite non-negative query count and a finite non-negative liters_per_query intensity. The API returns total_water_liters = queries × liters_per_query, plus milliliters, cubic metres, and US gallons.

Does zero queries return zero liters?

Yes. Zero queries or a zero intensity is valid and returns total_water_liters of zero, which is the correct result for an unused service.

What does the AI water footprint calculator cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free

Worked example

What an AI water footprint is and how the linear identity works

What you can do with it

Monthly product sustainability reports

Classroom and journalism estimates

Internal AI usage dashboards

FAQ

Related tools

For developers — API access

API endpoint

Call it from your stack

Example request

Example response

Pricing

Errors

Technical notes

What an AI water footprint is and how the linear identity works

Input contract, aliases, and what happens when a value is negative

Where an AI water footprint calculator earns its keep

Technical questions

thank you