Linear inches calculator
A 22 × 14 × 9 inch carry-on adds up to 45 linear inches, exactly the common US cabin limit. Enter length, width and height in inches or centimetres, add your airline's ceiling, and see whether the bag passes and how much room remains. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Length
- 22
- Width
- 14
- Height
- 9
- Limit
- 45
- Length in
- 22 in
- Width in
- 14
- Height in
- 9
- Linear inches
- 45
Airlines quote bag size as linear inches: the sum of outer length, width, and height, not the bag’s volume. This linear inches calculator adds those three sides, always reports the total in inches, and optionally checks a published ceiling such as forty-five inches for a common United States carry-on or sixty-two inches for many checked bags. Enter positive length, width, and height in inches or centimetres; any side that is missing, zero, negative, or not a number is rejected as invalid input so a blank measurement never looks like a free pass at the sizer.
How linear inches are defined and which sides to measure
Linear inches for luggage are the arithmetic sum of the bag’s outer length, width, and height as it will meet a sizer or a belt. That is not the same as volume: a tall slim duffel and a short cube can share one linear total while holding very different litres. Measure the expanded shell, including fixed wheels and side handles, when that is how the carrier writes the rule; telescoping trolley handles usually stay collapsed unless the fare page says otherwise.
Soft sides that squash still need their full listed size unless the policy allows compression. A non-positive limit, when supplied, fails the same way. Magnitude caps keep arithmetic finite on the isolate.
What you can do with it
Carry-on and checked bag pre-check
Travellers enter outer L×W×H and a published linear-inch limit to see pass or fail and how many inches of headroom remain before the airport sizer.
Suitcase and backpack product pages
Retail listings convert catalogue centimetres or inches into a single linear-inch total so shoppers can filter bags that meet a chosen airline rule.
Travel apps and packing checklists
Trip planners store bag dimensions once, re-check against different carrier ceilings, and show a stable linear-inch total without reimplementing L+W+H in every client.
FAQ
How do I calculate luggage linear inches?
Send positive length, width, and height (unit defaults to inches).
What happens if a dimension is zero, negative, or not a number?
Every side must be a finite positive number; a missing, zero, or negative measurement is not a valid bag dimension.
How do I check an airline size limit?
Pass optional limit in linear inches (for example 45 or 62).
Should I include wheels and handles when I measure my bag?
Measure the outer shell with fixed wheels and side handles included when that is how the airline writes its rule. Telescoping trolley handles usually stay collapsed unless the fare page says otherwise, and soft sides count at their full size unless squeezing is allowed.
Are linear inches the same as the volume of a bag?
No. Linear inches are just the three sides added together. A tall, slim duffel and a short cube can share the same linear total while holding very different amounts, which is why a sizer checks the sum and not the capacity.
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/linear-inches \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"length":22,"width":14,"height":9}'const res = await fetch("https://api.kit.forhosting.com/life/linear-inches", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"length": 22,
"width": 14,
"height": 9
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/life/linear-inches",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"length": 22,
"width": 14,
"height": 9
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/life/linear-inches", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"length":22,"width":14,"height":9}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"length":22,"width":14,"height":9}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/life/linear-inches", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"length": 22,
"width": 14,
"height": 9
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "life.linear_inches",
"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_dimension | 1000000 |
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
The prepaid API bills $0.002 per successful item when packing apps, suitcase product pages, and travel checklists need the same deterministic linear-inch total from servers and SDKs.
How linear inches are defined and which sides to measure
Send required fields length, width, and height as JSON numbers or numeric strings in one shared unit. Optional unit accepts in for inches, the default, or cm for centimetres; aliases units, measure_unit, and dim_unit are honoured. Aliases l, len, and depth map to length; w and breadth to width; h and ht to height. Optional limit (aliases max_linear, max, airline_limit, max_inches) is the airline’s linear-inch ceiling, for example forty-five for many United States cabin bags or sixty-two for many checked pieces. Any dimension that is not a strictly positive finite number fails with invalid_input, because a zero or negative side is not a physical bag. Identical inputs always produce identical JSON: addition plus the exact inch-to-centimetre factor of two point five four, with no network, no random seed, and no wall clock.
Reading linear_inches, dual-unit sides, and an optional limit check
On success the response echoes length, width, height, and unit after stable rounding, plus length_in, width_in, and height_in so centimetre inputs are visible in inches before they are added. The primary field linear_inches is the sum of those three inch sides and is the number you compare with a published airline chart. The formula field restates linear_inches equals length_in plus width_in plus height_in, and method is always sum_dimensions_to_linear_inches so clients can branch on a stable string. When you supply limit, the body also includes within_limit as a boolean, remaining_inches as unused headroom when the bag passes, and excess_inches as how far the bag is over when it fails. Those three limit fields are omitted entirely when you do not send a ceiling, so a simple total stays a simple total. Use linear_inches alone for a packing-day check; use the inch-converted sides when a shopper typed centimetres from a European spec sheet; use the limit fields when checkout or a trip checklist must show pass or fail next to the number on the fare rules. Missing required sides, non-finite values, and any dimension that is not a positive number all fail with invalid_input and are not billed. This endpoint does not download brand-specific policies; you or your product supply the numeric limit that matches the ticket you actually bought.
API usage, pricing, packing workflows, and practical limits
Use the free in-browser linear inches calculator on packing day, when comparing two suitcases in a shop, or in a classroom unit-conversion demo without opening a spreadsheet. For multi-bag parties, call once per piece so each bag is judged against its own cabin or hold class. Send a JSON body with length, width, height, optional unit, and optional limit (or the documented aliases). Use the prepaid API when a travel portal, baggage-fee estimator, suitcase product page, or packing app needs a stable contract under KIT balance at $0.002 per successful item; validation failures never consume balance. Authors shipping SDKs can map linear_inches, within_limit, remaining_inches, and excess_inches into a small table beside the three sides—the same shape travellers see on airport size charts at the counter.
Technical questions
Can I enter centimetres instead of inches?
Yes. Set unit to cm (or aliases units, measure_unit, dim_unit). Each side is divided by 2.54 and the total is still returned as linear_inches.
What does the linear inches calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful item; invalid input is not billed.