Total flight time with layovers calculator
A 150-minute flight, a 75-minute connection and a 210-minute flight add up to 7 h 15 min of travel, of which 6 h are in the air. List legs and waits in order to see the full trip length. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
This total flight time with layovers calculator adds every airborne leg and every ground connection so you see the full origin-to-destination travel time, not only the sum of block times printed on separate tickets. Enter ordered segments with flight minutes and optional layover minutes after each leg except the last; the engine returns total flight, total layover, and total travel minutes and hours, plus compact displays such as seven hours fifteen minutes and a per-leg breakdown for audits. A direct nonstop is one segment with zero layover. A one-stop itinerary is two flights plus one connection. Multi-city chains scale the same formula up to twenty legs without inventing schedules or time zones.
Where multi-leg totals fit in planning, ops, and software
Leisure travelers meet this calculation when a booking engine shows three cheap legs and a glamorous total fare but hides the twelve-hour calendar span that comes from two long connections. Corporate travel desks batch the same formula across preferred itineraries to flag trips whose total travel hours exceed a policy cap even when each individual flight looks short. Student groups and tour operators use the breakdown when a multi-city coach-and-fly package lists only airborne times and someone still needs the full day length for hotel check-in planning.
Support agents paste segment minutes from e-tickets to show a customer why a one-stop option is three hours longer door to door than a nonstop that costs more. Product and education tools call the contract from scripts when a user builds an itinerary builder and the app must show total flight, total layover, and total travel without shipping a full schedule engine.
Pair it with layover MCT checks and arrival local-time helpers when you are assembling a small lab of free, deterministic air-travel planning tools, and keep your own schedule sources for real times while this calculator owns only the transparent sum.
What you can do with it
Compare nonstop vs one-stop total time
Add flight and connection minutes for each routing so fare savings are weighed against extra hours of total travel.
Corporate itinerary policy checks
Sum multi-leg tickets against a maximum total travel hours rule before approving a booking.
Multi-city day-length planning
Roll up three or more legs plus ground waits to size hotel nights and meeting buffers at the final city.
FAQ
What does the total flight time with layovers calculator cost?
It is free in your browser on this page.
How is total travel time calculated?
The last segment does not add a layover.
Can I enter a nonstop flight?
Layover count is zero and total travel equals that flight.
What happens with invalid input?
Examples include a missing segments array, empty list, more than twenty legs, negative durations, durations above 10080 minutes, or a positive layover on the last segment.
Does this look up real flight schedules?
No. You supply the minutes for each leg and connection. The tool only sums them into total flight, layover, and travel time.
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/travel/flight-with-layovers \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"segments":[{"flight_minutes":150,"layover_minutes":75},{"flight_minutes":210}]}'const res = await fetch("https://api.kit.forhosting.com/travel/flight-with-layovers", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"segments": [
{
"flight_minutes": 150,
"layover_minutes": 75
},
{
"flight_minutes": 210
}
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/travel/flight-with-layovers",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"segments": [
{
"flight_minutes": 150,
"layover_minutes": 75
},
{
"flight_minutes": 210
}
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/travel/flight-with-layovers", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"segments":[{"flight_minutes":150,"layover_minutes":75},{"flight_minutes":210}]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"segments":[{"flight_minutes":150,"layover_minutes":75},{"flight_minutes":210}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/travel/flight-with-layovers", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"segments": [
{
"flight_minutes": 150,
"layover_minutes": 75
},
{
"flight_minutes": 210
}
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "travel.flight_with_layovers",
"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_segments | 20 |
max_flight_minutes | 10080 |
max_layover_minutes | 10080 |
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
Invalid lists, negative durations, or a non-zero layover on the final arrival fail with invalid_input instead of a silent wrong total. Use it free in the browser when comparing routings, or call the API at $0.002 per successful request when worksheets and booking tools need the same reproducible sum.
What total travel time with layovers means and what the response contains
Published flight times almost always describe a single airborne or block leg. Passengers experience something larger: the first takeoff, every intermediate wait on the ground, and the final arrival. That full interval is total travel time with layovers, and it is the number people need when they ask how long a trip really takes, whether a red-eye-plus-connection is worth the fare savings, or how much buffer remains before a meeting at the destination city. This calculator answers that question with transparent arithmetic. You supply an ordered array of segments. On the last segment layover is omitted or zero because travel ends when you arrive. Each segment carries flight_minutes, the duration of that leg, and may carry layover_minutes, the ground time after that leg before the next takeoff. The engine sums every flight minute, sums every intermediate layover minute, and returns total_travel_minutes as their sum, with matching hour fields and human-readable displays for flight, layover, and travel totals. The response also echoes segment_count, layover_count which is segment_count minus one for multi-leg trips or zero for a nonstop, a segments array with one-based index, flight_minutes, and layover_minutes per leg, a method tag flight_with_layovers, and a short formula string for logs. There is no live GDS feed, no scraped airline table, and no clock arithmetic: the path either builds a finite result from your numbers or rejects the request with invalid_input. Rejected cases include a missing segments array, an empty list, more than twenty legs, non-object items, missing flight_minutes, negative durations, durations above the seven-day cap, and a positive layover attached to the final arrival. If you need local arrival clock times after a time-zone change, pair a single duration with travel.arrival_local_time; if you need one connection checked against minimum connection time, use travel.layover_time. This page stays focused on summing the whole itinerary so browser demos, spreadsheets, and API clients share one stable contract.
How segments and layovers are read and how results stay reproducible
Each item is an object. Values may be finite numbers or H:MM duration strings such as two colon thirty for one hundred fifty minutes; hours in H:MM may exceed twenty-three because a single ultra-long-haul block can last more than a day. A positive layover on the last segment is rejected so authors do not accidentally count post-arrival ground time as travel. Limits of twenty segments and ten thousand eighty minutes per duration keep inputs practical for passenger itineraries while still covering multi-stop world tours and multi-day surface connections entered as layover minutes. The preferred field name is segments, but legs, flights, and itinerary are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. Flight duration is read from flight_minutes with aliases flight, duration_minutes, minutes, duration, flight_min, and block_minutes. Intermediate ground time is read from layover_minutes with aliases layover, connection_minutes, ground_minutes, wait_minutes, layover_min, and connection. A one-segment list is a valid nonstop: layover_count is zero and total travel equals that single flight. A two-segment list should carry layover_minutes on the first object; if omitted, the connection defaults to zero so a missing cell does not invent a wait. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing segment validation yourself.
Where multi-leg totals fit in planning, ops, and software
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 KIT tier-A catalog and lets you move from a trip-planning demo to an automated pipeline without changing the mathematical result.