Car vs bike CO2
A 10 km trip in a car using 8 L/100 km burns 0.8 litres of petrol and emits about 1.85 kg of CO2, against 0.21 kg by bicycle, so riding saves 1.638 kg. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Distance
- 10
- Efficiency
- 8
- Distance km
- 10
- Efficiency l per 100km
- 8
- Fuel
- Gasoline
- Factor kg per l
- 2.31
Choosing a bicycle instead of a car is one of the fastest ways a household can cut the carbon dioxide released by a short trip, but the saving is not a slogan: it is fuel burned times an emission factor, minus the small operational footprint of pedalling. This car versus bike CO2 calculator takes a trip distance in kilometres and the car's fuel consumption in litres per 100 kilometres, converts that consumption into litres of petrol or diesel, multiplies by a published tank-to-wheel factor, and compares the result with a cycling factor of twenty-one grams of carbon dioxide equivalent per kilometre. It returns both emissions and the kilograms you avoid by riding.
How driving versus cycling CO2 is calculated
A tank-to-wheel compare starts from the litres the car actually burns on the trip, not from a generic grams-per-kilometre table that hides the vehicle you own. Litres equal distance in kilometres times the consumption figure in litres per 100 kilometres, divided by one hundred. Those litres are then multiplied by a published factor for the fuel in the tank: 2.31 kilograms of carbon dioxide per litre of gasoline, or 2.68 kilograms per litre of diesel.
The two numbers are the screening tank-to-wheel factors used in national conversion tables; they describe tailpipe carbon from burning the fuel, not the oil well, the refinery, or the steel in the car. Cycling is not treated as zero. The European Environment Agency style extra-food factor of 0.021 kilograms of carbon dioxide equivalent per kilometre accounts for the additional calories a rider oxidises on the road, which is the honest operational counterpart to tailpipe exhaust.
Savings equal car emissions minus bike emissions, and the percentage is that difference divided by the car figure. The method does not add vehicle manufacture, tyre wear, road construction, or an e-bike charging mix, because those belong in a life-cycle study with a different inventory. What you get is a transparent operational gap you can audit: change the distance or the L/100 km sticker and the kilograms move in lockstep.
A typical compact at eight litres per 100 kilometres over a ten-kilometre hop burns 0.8 litres and about 1.85 kilograms of petrol carbon, against 0.21 kilograms for the bicycle, which is why the ride usually wins by a wide margin.
Inputs, units, fuel choice and error behaviour
An optional fuel field selects the litre factor. It must be gasoline or diesel; when you omit it the calculator uses gasoline and 2.31 kilograms per litre. Diesel switches the factor to 2.68.
Distance and efficiency must be strictly positive. Missing fields, empty strings, booleans, and tokens that are not plain decimal or scientific numbers fail the same way. Numbers are rounded to twelve decimal places so goldens and clients compare byte-for-byte across runtimes.
There is no network lookup, no random draw, and no dependence on the current date.
Who compares car and bike emissions
Commute programmes, campus mobility desks and city climate offices use a deterministic driving-versus-cycling calculator to turn a stated distance and a fleet-average L/100 km into kilograms they can put in a monthly report, instead of quoting a generic slogan about leaving the car at home. Campaign pages that ask visitors to log a week of errands can send the same two numbers the visitor already typed and show the saving without inventing a vehicle class. Failed validation does not consume balance.
Keep requests small, pin the rounded fields in tests, and you get a reproducible operational compare without standing up a life-cycle database or a traffic model of your own.
What you can do with it
Daily commute carbon memo
Turn a home-to-work distance and the car's L/100 km sticker into kilograms of CO2 for driving versus cycling, plus the saving if the rider leaves the car at home.
FAQ
How is car versus bike CO2 calculated?
Litres burned equal distance (km) times efficiency (L/100 km) divided by 100. Car CO2 multiplies those litres by 2.31 kg/L for gasoline or 2.68 kg/L for diesel. Bike CO2 is distance times 0.021 kg/km. Savings are car minus bike, also as a percent of the car figure.
What does the efficiency field mean?
Litres per 100 kilometres, the consumption figure on a metric window sticker. A higher number is a thirstier car and more carbon. It is not miles per gallon and not kilometres per litre.
Why is cycling not treated as zero emissions?
Pedalling still has an operational footprint from the extra food a rider oxidises. The calculator uses the European Environment Agency style factor of 21 grams of CO2 equivalent per kilometre so the compare is tank-to-wheel versus extra-food, not tailpipe versus a silent zero.
What happens if distance or efficiency is zero or negative?
A non-positive distance is not a trip, and a non-positive L/100 km figure would make litres used undefined. Invalid input is not billed.
Does this include manufacturing, and what does it cost?
No. It is an operational tank-to-wheel versus cycling compare, not a life-cycle assessment of building the car or the bicycle. The browser tool is free.
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/eco/car-vs-bike \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"distance":10,"efficiency":8}'const res = await fetch("https://api.kit.forhosting.com/eco/car-vs-bike", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"distance": 10,
"efficiency": 8
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/eco/car-vs-bike",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"distance": 10,
"efficiency": 8
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/eco/car-vs-bike", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"distance":10,"efficiency":8}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"distance":10,"efficiency":8}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/eco/car-vs-bike", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"distance": 10,
"efficiency": 8
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "eco.car_vs_bike",
"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.
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
Distance and efficiency must be positive finite numbers; anything else fails with invalid_input instead of inventing a footprint.
Inputs, units, fuel choice and error behaviour
Send a JSON object with two required finite numbers: distance, the trip length in kilometres, and efficiency, the car's fuel consumption in litres per 100 kilometres. The second field is named efficiency because that is how window stickers and search queries phrase it, but the unit is consumption: a higher number is a thirstier car and more carbon. Each numeric field also accepts a numeric string and a short list of aliases (dist, trip_distance, km, fuel_efficiency, consumption, l_per_100km, fuel_type) so spreadsheets and forms do not have to rename columns. Zero kilometres is not a trip, and zero or negative litres per 100 kilometres would make fuel used undefined or non-physical, so those cases fail with invalid_input that names the field. On success the response echoes the resolved distance, consumption and fuel, then reports fuel_liters, the factor applied, car_co2_kg, bike_co2_kg, the bike factor, savings_kg, savings_percent, a compact formula string, and the method label ttw_fuel_vs_eea_cycle.
Where a car versus bike emissions API earns its keep
Travel managers who already know each vehicle's sticker consumption can post one task per staff hop and store car_co2_kg beside bike_co2_kg and savings_kg without opening a spreadsheet of emission factors. If you later need manufacture or electricity, feed these tank-to-wheel kilograms into that inventory; this endpoint stops at fuel versus pedalling on purpose.
Integration use cases
Fleet and campus hop reports
Post one task per staff trip with each vehicle's consumption and optional diesel flag, then store car_co2_kg, bike_co2_kg and savings_kg beside the trip identifier.
Classroom and campaign widgets
Let visitors type a trip length and a window-sticker figure and see both emissions on a live tool that matches the API byte-for-byte.