ForHosting KIT · Science

Flight CO2 emissions calculator

A 1,000 km hop at 0.15 kg per passenger-kilometre puts 150 kg of CO2 on one traveller's account and 600 kg on a family of four: a transparent first number for a trip or a company inventory. 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

Distance: 1,000
Factor: 0.15
Passengers: 1

You get

Distance km: 1,000
Factor kg per km: 0.15
Passenger km: 1,000
Co2 kg: 150

Aviation is one of the fastest ways a single trip can add carbon dioxide to a household or company inventory, and the honest first number is not a slogan about flying less: it is distance times a per-kilometre emission factor times how many people sit on that itinerary. This flight CO2 emissions calculator takes a great-circle or ticketed distance in kilometres, the emission factor in kilograms of carbon dioxide per passenger-kilometre, and a passenger count, then returns the total mass in kilograms. A short-haul hop of one thousand kilometres at 0.15 kilograms per passenger-kilometre for one traveller is 150 kilograms; the same route for a family of four is 600.

How flight CO2 emissions are calculated

A flight-emission estimate is a screening product of three quantities you already have on a ticket: how far the aircraft travels, how many kilograms of carbon dioxide each passenger-kilometre is assigned, and how many people sit on that itinerary. The emission factor is kilograms of carbon dioxide per passenger-kilometre, the unit used by national conversion tables and by the ICAO-style inventories that travel desks already quote.

A short-haul jet often sits near 0.15 to 0.25 kilograms per passenger-kilometre; a long-haul widebody with a high load factor can sit closer to 0.10 to 0.20; a business-class seat that occupies more cabin area is modelled by raising the factor, not by inventing a cabin-class enum here. Passenger count scales the product: one traveller on a thousand-kilometre hop at 0.15 kilograms per passenger-kilometre produces 150 kilograms; four travellers on the same hop produce 600. Written as one line: total kilograms equal distance times factor times passengers.

Passenger-kilometres are the first product, then that figure is scaled by the factor you supplied. The method does not add aircraft manufacture, airport operations, taxi fuel, or a radiative-forcing index unless you have already baked those extras into the factor. It does not convert miles, nautical miles or hours in the air.

What you get is a transparent operational mass you can audit. Change any one of the three factors and the kilograms move in lockstep. This tool is not a car-versus-bike compare and not a breathing-emission page: those answer different searches, about road fuel or exhaled gas, not about a flight.

Distance, factor and passengers explained

Fractional passengers are allowed so an average occupancy of two and a half does not have to be rounded first, and a numeric string is accepted on every field so a spreadsheet export does not have to be recast. A negative factor or a negative passenger count is rejected for the same reason. Missing fields, empty strings, booleans, objects and tokens that are not plain decimal or scientific numbers fail the same way.

Zero passengers is accepted and returns zero kilograms, because an empty itinerary really does add no assigned mass; a zero factor is accepted as a zero-emission aircraft. Numbers are rounded to twelve decimal places so goldens and clients compare byte-for-byte across runtimes. If the product overflows to Infinity the task fails rather than returning a non-finite mass.

Who uses a flight CO2 estimate

Travel desks, sustainability officers and event planners use a deterministic flight CO2 calculator to turn a stated distance, a published per-kilometre factor and a passenger count into kilograms they can put next to a travel policy, instead of quoting a slogan about flying less. Campaign pages that ask visitors to log a year of flights can send the same three numbers the visitor already typed and show the assigned mass without inventing a cabin class or a hidden radiative-forcing multiplier. Failed validation does not consume balance.

Keep requests small, pin the rounded fields in tests, and you get a reproducible aviation product without standing up an airport-pair database of your own.

What you can do with it

Corporate travel carbon memo

Turn each booked sector's kilometres, a published kg-per-passenger-kilometre factor and the travelling party size into kilograms of CO2 for a monthly travel-policy note.

FAQ

How is flight CO2 calculated?

Total kilograms equal distance in kilometres times the emission factor in kilograms of CO2 per passenger-kilometre times the passenger count. Passenger-kilometres are the first product. One thousand kilometres at 0.15 kg/pax-km for one traveller give 150 kilograms.

What emission factor should I use per kilometre?

Published screening values often sit near 0.10–0.26 kilograms of CO2 per passenger-kilometre, depending on haul, load factor and whether you include a radiative-forcing uplift. Supply the factor that matches the inventory you are following. The calculator does not guess a cabin class or look up an airport pair.

Does this include radiative forcing or aircraft manufacture?

No. It returns the operational product of the three numbers you send.

What happens if distance is zero or negative?

A zero or negative length is not a flight. A negative factor or passenger count is also rejected. Zero passengers is allowed and returns zero kilograms. Invalid input is not billed.

Is this the same as car or breathing CO2, and what does it cost?

No. This page estimates assigned aviation carbon from distance, a per-kilometre factor and passengers, not fuel burned on a road or gas exhaled by lungs. 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

POSThttps://api.kit.forhosting.com/eco/flight-emissions

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/flight-emissions \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"distance":1000,"factor":0.15,"passengers":1}'

const res = await fetch("https://api.kit.forhosting.com/eco/flight-emissions", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "distance": 1000,
    "factor": 0.15,
    "passengers": 1
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/eco/flight-emissions",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "distance": 1000,
    "factor": 0.15,
    "passengers": 1
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/eco/flight-emissions", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"distance":1000,"factor":0.15,"passengers":1}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"distance":1000,"factor":0.15,"passengers":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/eco/flight-emissions", 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": 1000,
  "factor": 0.15,
  "passengers": 1
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "eco.flight_emissions",
  "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

Distance must be a positive finite number; a zero or negative length is not a flight, so the task fails with invalid_input instead of inventing a footprint.

Inputs, units, aliases and error behaviour

Send a JSON object with three required finite numbers: distance, the flight length in kilometres; factor, the emission factor in kilograms of carbon dioxide per passenger-kilometre; and passengers, the headcount on that itinerary. Each field also accepts a short list of aliases (dist, d, km, kilometres, kilometers, distance_km, trip_distance, flight_distance, emission_factor, factor_kg_per_km, kg_per_km, ef, rate, emission_factor_per_km, passenger_count, pax, n, people, passenger, heads) so forms do not have to rename columns. Distance must be strictly positive: zero kilometres is not a flight, and a negative length is not a physical route, so those cases fail with invalid_input that names the field. On success the response echoes the resolved distance_km, factor_kg_per_km and passengers, then reports passenger_km, co2_kg, a compact formula string, and the method label distance_times_factor_times_passengers. When passengers is greater than zero the response also includes co2_per_passenger_kg, which equals distance times factor. There is no network lookup, no random draw, and no dependence on the current date: the same three numbers always produce the same JSON.

Where a flight-emissions API earns its keep

Corporate booking tools that already store sector kilometres and party size can post one task per itinerary and store co2_kg beside the trip identifier without opening a spreadsheet of conversion factors. If you later need well-to-wake, non-CO2 climate forcing or aircraft manufacture, fold those extras into the factor you supply or feed co2_kg into that inventory; this endpoint stops at the operational product of distance, factor and passengers on purpose.

Integration use cases

Family holiday itinerary inventory

Post one task per outbound and return hop with ticketed distance, the haul factor you chose and how many seats you bought, then store co2_kg beside the trip.

Offset campaign and classroom widgets

Let visitors type a flight distance, a per-kilometre factor and a passenger count and see the assigned kilograms on a live tool that matches the API byte-for-byte.

Read the full KIT documentation →

Run — free