Fuel consumption calculator
45 litres over 500 kilometres is 9 litres per 100 km. Enter the fuel you actually used and the distance you drove on a trip to get the consumption rate of that trip for your logbook. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Fuel used
- 45
- Distance driven
- 500
- Consumption per 100km
- 9 L/100km
This fuel consumption calculator turns two everyday trip figures — the liters you actually burned and the kilometers you actually drove — into the standard rate of liters per one hundred kilometers. Enter fuel used and distance driven; the engine applies the closed identity consumption per 100 km equals fuel used divided by distance driven, times one hundred, and returns that single consumption rate with the unit L/100km. The path is fully deterministic: no traffic model, no map feed, and no date-dependent shortcut. Small checks you may already know include forty-five liters over five hundred kilometers yielding nine liters per one hundred kilometers, and twenty-five liters over three hundred kilometers yielding eight point three three three three three three.
What fuel consumption per 100 km means and what comes back
Fuel consumption per one hundred kilometers answers a practical household question: given how much fuel a vehicle used and how far it traveled, what was the burn rate on that trip. Handbook stickers, dashboard computers, and mixed-unit converters are useful in other moments, but the everyday search for a fuel consumption calculator is usually this two-number identity and nothing more. This page stays on that identity.
If you need miles and gallons converted into several economy units from a brim-to-brim fill-up, use a fill-up consumption helper; if you only need to translate MPG into L/100km without a trip log, use a fuel-economy unit converter; if you are planning how many liters a future journey will take from a known rating, use a trip fuel volume helper. This landing is the generic liters-and-kilometers rate so logbooks, APIs, and the free browser demo share one stable contract.
How the two inputs are read and how the rate is computed
Optional leading plus signs and scientific notation on numeric strings are allowed when they parse as finite decimals; embedded spaces, hex prefixes, and non-numeric tokens are rejected with a message that names the field, so a bad cell does not become a wrong consumption rate. After validation the engine applies the school identity: consumption per 100 km equals fuel used divided by distance driven, times one hundred.
That is the same rearrangement as liters per kilometer scaled to a one-hundred-kilometer reference distance, which is why forty-five liters over five hundred kilometers is nine liters per one hundred kilometers, and why twenty-five liters over three hundred kilometers is eight point three three three three three three after six-decimal rounding. Fuel used may be zero when the distance is positive: a vehicle that burned nothing over a measured stretch reports a consumption rate of zero, which is a legitimate logbook entry. Distance driven may not be zero or negative.
The specified error path is the zero-distance case, because division by zero is undefined and inventing infinity would hide a data-entry mistake. Negative fuel is also rejected.
Where a simple L/100km check belongs in daily life and software
Private drivers meet this calculation when a receipt and an odometer note are enough to check whether city congestion, a roof box, or a new set of tires changed real burn rate versus last month. Households use it to compare two cars on the same weekend route without opening a fleet telematics stack.
Students and driving instructors use it to connect the textbook idea of a consumption rate with a concrete number from a weekend journey, including the classic forty-five liters and five hundred kilometers example that yields nine liters per one hundred kilometers. Expense and mileage products call the contract from scripts when a user logs liters and kilometers and the app must show L/100km without shipping unit-conversion tables for gallons and miles.
Keep requests inside the published magnitude ceiling, pin the six-decimal rate in tests, and you get a reproducible consumption figure for logbooks, LMS plugins, and edge workers without standing up a vehicle-dynamics model of your own.
What you can do with it
Logbook burn rate after a trip
Enter liters used and kilometers driven from a weekend journey to record the actual L/100km figure next to the receipt.
FAQ
What happens if distance driven is zero?
A zero trip length does not define a consumption rate, so the calculator will not invent infinity or a silent NaN.
Can fuel used be zero?
Yes, when distance driven is positive. Zero liters over a measured stretch is a consumption rate of zero. Negative fuel is rejected.
What does the fuel consumption calculator cost?
It is free in your browser on this page.
Can I enter miles and gallons instead?
No. This calculator works in litres and kilometres only. If your figures are in miles and gallons, convert them first or use a fuel-economy unit converter.
Can I use it to plan fuel for a future trip?
Not directly. It measures a trip you already drove from the fuel you used. To estimate how many litres a coming journey will need from a known rating, use a trip fuel planner.
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
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/life/fuel-consumption \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"fuel_used":45,"distance_driven":500}'const res = await fetch("https://api.kit.forhosting.com/life/fuel-consumption", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"fuel_used": 45,
"distance_driven": 500
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/life/fuel-consumption",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"fuel_used": 45,
"distance_driven": 500
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/life/fuel-consumption", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"fuel_used":45,"distance_driven":500}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"fuel_used":45,"distance_driven":500}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/life/fuel-consumption", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"fuel_used": 45,
"distance_driven": 500
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "life.fuel_consumption",
"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
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_abs | 1000000000 |
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
Zero distance is rejected with invalid_input because dividing fuel by zero kilometers does not define a rate.
What fuel consumption per 100 km means and what comes back
There is no Monte Carlo path and no live map feed: the engine either builds a finite non-negative rate inside the supported numeric range or rejects the input with invalid_input. Rejected cases include a missing fuel_used or distance_driven field, a non-finite token, a magnitude above the documented ceiling, a negative fuel volume, and any non-positive distance, because a parked odometer does not define a consumption rate.
How the two inputs are read and how the rate is computed
The preferred fields are fuel_used for the liters burned and distance_driven for the kilometers traveled, but aliases such as fuel, liters, litres, volume, amount, distance, km, dist, and trip_distance are accepted so spreadsheets, query strings, and typed forms can reuse the same contract without renaming columns. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline.
Where a simple L/100km check belongs in daily life and software
Product and education tools use the single-rate response when the audience already works in metric units and does not need MPG companions on the same payload. On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split — free interactive exploration and a priced, identical API — matches the rest of the tier-A catalog and lets you move from a dashboard demo to an automated pipeline without changing the mathematical result.
Integration use cases
Homework and driving-school checks
Confirm the textbook identity (fuel / distance) × 100, including the required invalid_input when distance driven is zero.
Deterministic fixtures for expense apps
Generate a reproducible consumption_per_100km field for mileage tools, CI assertions, and metric-only dashboards.
Technical questions
How is fuel consumption per 100 km calculated?
Send fuel_used in liters and distance_driven in kilometers. The rate is (fuel_used / distance_driven) × 100, returned as consumption_per_100km with unit L/100km.
Which units should I enter?
Liters for fuel_used and kilometers for distance_driven. This landing does not convert gallons or miles; keep both figures metric so the L/100km identity stays honest.