Freight class from density
Pre-check a freight class before you request LTL rates: 200 pounds in 20 cubic feet is a density of 10 PCF, which falls in the 9 to 10.5 band and maps to class 92.5. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Weight lb
- 200
- Volume cu ft
- 20
- Density pcf
- 10
- Freight class
- 92.5
- Density min pcf
- 9
- Density band
- 9–10.5 pcf → class 92.5
Less-than-truckload (LTL) carriers price freight partly by NMFC freight class, and density is the practical lever shippers control: denser freight usually lands in a lower class and a lower rate. This freight class calculator accepts total shipment weight in pounds and total cubic volume in cubic feet, divides weight by volume to get density in pounds per cubic foot (PCF), and looks up the standard density-based NMFC class band from class 400 (very light, under 1 PCF) down to class 50 (30 PCF and above). Use it to pre-check carton builds, compare packing options, and feed class estimates into LTL quotes before a full NMFC item description is filed.
How density becomes an NMFC freight class
Freight class under the National Motor Freight Classification is a published scale from 50 to 500 that reflects how difficult a commodity is to handle, stow, and insure. For many general commodities, density is the dominant factor: low-density goods take more trailer space per pound and tend toward higher classes, while high-density goods pack efficiently and tend toward lower classes. This calculator implements the widely used density-to-class reference table in pounds per cubic foot.
Density is simply total weight divided by total cubic volume for the shipment or handling unit you are classifying. For example, two hundred pounds in twenty cubic feet is ten PCF, which falls in the nine to ten-and-a-half PCF band and maps to freight class 92.5. Four hundred pounds in ten cubic feet is forty PCF and maps to class 50.
The table steps through bands such as under one PCF for class 400, one to under two for class 300, continuing through intermediate classes including 250, 200, 175, 150, 125, 110, 100, 92.5, 85, 70, 65, 60, and 55, until thirty PCF and above resolve to class 50. Band edges are inclusive on the lower bound and exclusive on the upper bound except the open top band at thirty and above.
What you can do with it
LTL quote pre-check
Enter shipment pounds and cubic feet to estimate NMFC freight class from density before requesting carrier rates.
Packaging and cartonization
Compare packing options by volume and weight so denser builds can drop into a lower freight class band.
FAQ
What happens if volume is zero or negative?
Cubic volume must be positive to define density; invalid input is not billed.
Which units does the freight class calculator use?
Weight in pounds (lb) and volume in cubic feet (ft³). Density is returned as pounds per cubic foot (PCF), the unit used by the standard NMFC density table.
Is density the only factor for real NMFC class?
Density is the main driver for many general commodities, but liability, stowability, and handling can still change class. This tool maps density to the reference band only.
What freight class does very dense freight get?
Class 50. Any shipment at 30 PCF or more lands in the densest band, so 400 pounds in 10 cubic feet, a density of 40 PCF, is class 50. At the other end, under 1 PCF is class 400.
Which volume should I measure for freight density?
Measure the outer dimensions of the carton, crate or pallet you actually hand to the carrier, not the product alone. That way the density matches the shipment the carrier really receives.
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/ecom/freight-class-weight-density \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"weight_lb":200,"volume_cu_ft":20}'const res = await fetch("https://api.kit.forhosting.com/ecom/freight-class-weight-density", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"weight_lb": 200,
"volume_cu_ft": 20
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/ecom/freight-class-weight-density",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"weight_lb": 200,
"volume_cu_ft": 20
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/ecom/freight-class-weight-density", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"weight_lb":200,"volume_cu_ft":20}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"weight_lb":200,"volume_cu_ft":20}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/ecom/freight-class-weight-density", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"weight_lb": 200,
"volume_cu_ft": 20
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "ecom.freight_class_weight_density",
"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
Volume must be strictly positive—zero or negative volume cannot define a density and fails with invalid_input rather than inventing a class.
How density becomes an NMFC freight class
Always measure cube from the outer shipping dimensions of the carton, crate, or pallet envelope actually tendered to the carrier, not the product alone, so the density the API returns matches what operations will claim.
Input contract, response fields, and error rules
Pair it with your own packaging calculator to get volume from length times width times height when you start from dimensions instead of cube. POST a JSON body with two required finite numbers: weight_lb, the total shipment weight in pounds (non-negative), and volume_cu_ft, the total cubic volume in cubic feet (must be greater than zero). Each field may arrive as a JSON number or as a numeric string; aliases such as weight, pounds, volume, cubic_feet, and cu_ft are accepted so warehouse and e-commerce systems can map existing field names without renaming pipelines. Missing fields, non-finite values, negative weight, and non-positive volume fail with invalid_input naming the problem; those failures are not billed. On success the body echoes weight_lb and volume_cu_ft, returns density_pcf rounded for stable automation, freight_class as the numeric class (for example 70 or 92.5), density_min_pcf for the lower edge of the matched band, optional density_max_pcf when the band has a finite upper edge (omitted for the open class-50 band at thirty PCF and above), a human-readable density_band string, and method set to nmfc_density_freight_class. Optional output keys are omitted rather than set to null so web and SDK clients stay simple. The endpoint does not look up NMFC item numbers, hazmat codes, or carrier exceptions—it only maps density to the reference class band.
Where a density freight class API earns its keep
E-commerce and 3PL operations use a freight class from density calculator to score cartonization choices before booking LTL: reducing void fill or consolidating SKUs can move density across a band edge and drop class enough to change landed cost. Marketplace sellers who ship oversized or lightweight goods need a quick PCF check so listing freight estimates do not underquote class 150-plus freight as if it were dense class 70. Rate engines and TMS plugins call a tiny parse API instead of embedding a brittle spreadsheet copy of the density table, keeping automation deterministic across regions and languages. Procurement and packaging engineering compare alternate materials by fixing weight and varying cube, or the reverse, and read freight_class as a side constraint next to product cost. Keep weight and volume in pounds and cubic feet for this endpoint, convert metric sources once at the edge if needed, pin density_pcf and freight_class in tests, and you get reproducible NMFC band lookups for quoting, training, and continuous improvement without standing up a full classification bureau integration.
Integration use cases
TMS and e-commerce automation
Call the API from warehouse or cart software to attach a density-based class estimate to every LTL order.
Technical questions
How do I calculate freight class from density?
Send weight_lb (pounds) and volume_cu_ft (cubic feet, must be > 0). The API returns density_pcf = weight/volume and the matching NMFC density-based freight_class band.
What does the freight class from density calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.