Price per linear foot calculator
A piece 12 feet 6 inches long that costs 240 is 12.5 feet, so it works out at 19.2 per linear foot. Compare contractor totals, remnant tags and cut lists on the same running-foot basis. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Price
- 240
- Feet
- 12
- Inches
- 6
- Length ft
- 12.5
- Length in
- 150
- Price per linear foot
- 19.2
- Precision
- 10
Fence installers, flooring shops, fabric retailers, and millwork suppliers still price many goods by the running foot, yet the number on a quote, remnant tag, or invoice is almost always a total for a measured piece. This price per linear foot calculator converts that total and a length given in whole feet plus leftover inches into a single unit price you can compare across vendors, leftover rolls, and cut lists. The engine is deterministic finite arithmetic: inches become a twelfth of a foot, those feet add to the whole-foot part, and the total price is divided by that length. A board twelve feet six inches long that costs two hundred forty currency units is twelve and a half feet, so the unit price is nineteen point two per linear foot.
What to send: total price, feet, and leftover inches
Feet is the whole-foot part of the tape measure and may be zero when you only have leftover inches, for example a remnant tagged eighteen inches. Price, feet, and inches must be non-negative and inside the published magnitude ceiling. A zero price is valid and simply yields a zero unit price when the length is positive.
Missing price or missing feet fails before any division. The production example uses two hundred forty for price, twelve for feet, and six for inches so a probe that copies the contract always computes a real unit price.
Where unit price per running foot earns its keep
Contractors compare fence, baseboard, crown, and pipe quotes that arrive as totals for odd lengths instead of a published rate per foot. Flooring and carpet shops convert remnant tags into a fair running-foot price before they sit next to a full roll. Fabric and awning work does the same when a bolt is sold as a measured cut rather than a listed dollar-per-yard card.
Homeowners checking a millwork invoice can confirm the implied rate matches the verbal quote, and estimators can normalize several supplier totals onto one linear-foot basis before they pick a vendor. Pair this calculator with area or waste estimators when you still need coverage, and with generic unit-price comparison tools when you are shopping packaged goods rather than a measured run.
What you can do with it
Fence and millwork quotes
Turn a contractor total and a tape reading in feet and inches into a comparable price per linear foot before you accept the bid.
Remnants, fabric, and trim
Normalize leftover rolls and custom cuts to a running-foot rate so a short piece can be compared with a full stick or bolt.
FAQ
How do I calculate price per linear foot?
Send the total price, the feet part of the length, and leftover inches (optional, default zero). The unit price is price divided by (feet + inches/12).
What happens if the total length is zero?
Price per linear foot is undefined when feet + inches/12 equals zero, so a zero run is rejected and not charged.
Can I send more than twelve inches?
Yes. Extra inches are converted into additional feet. Fourteen feet and fifteen inches becomes fifteen and a quarter feet before the division.
Is the price per linear foot calculator free?
The browser tool runs free on your device.
Does this convert currency or add tax?
No. It only divides the price you supply by the converted length. Keep every total in one currency and add tax yourself if you need a landed rate.
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/price-per-linear-foot \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"price":240,"feet":12}'const res = await fetch("https://api.kit.forhosting.com/life/price-per-linear-foot", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"price": 240,
"feet": 12
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/life/price-per-linear-foot",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"price": 240,
"feet": 12
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/life/price-per-linear-foot", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"price":240,"feet":12}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"price":240,"feet":12}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/life/price-per-linear-foot", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"price": 240,
"feet": 12
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "life.price_per_linear_foot",
"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_abs_value | 1000000000000000 |
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
When the converted length is zero the request fails with invalid input because a unit price is undefined without a positive run.
What to send: total price, feet, and leftover inches
Send a JSON body with a required price and a required feet field, plus an optional inches field that defaults to zero when omitted. Price is the total you were quoted or charged for the piece, roll, or run; aliases cost, amount, total, and total_price map to the same value so checkout rows and supplier invoices can keep familiar keys. Aliases ft, length_feet, and length_ft are accepted. Inches is the leftover fraction of a foot; aliases in, length_inches, and length_in are accepted, and values above twelve are converted rather than rejected so a cut list that says fourteen feet fifteen inches still works. Every field may arrive as a JSON number or as a numeric string; empty strings, hex prefixes, and non-finite tokens fail with invalid_input naming the field.
How price per linear foot is computed and when length zero fails
The unit price is then the total price divided by that length. Negative components are rejected for the same honesty: a unit price for a purchase is not a signed ledger. A worked case is price two hundred forty, feet twelve, inches six: length is twelve point five feet and the unit price is nineteen point two per linear foot. The calculator first turns the tape reading into decimal feet: length_ft equals feet plus inches divided by twelve. That is the same conversion a lumber yard uses when a board is marked twelve feet six inches and billed as twelve and a half feet. The response echoes the validated price, feet, and inches, reports length_ft and the equivalent length_in, and returns price_per_linear_foot as the primary figure, plus a formula string and a method tag price_div_length_ft so clients can branch without sniffing shapes. If feet plus inches over twelve is zero or smaller than a tiny epsilon, the request is rejected with invalid_input because price per linear foot is undefined when the run has no length; that is the classic trap when both fields are left at zero or a feed sends a blank cut.
Where unit price per running foot earns its keep
Developers call the prepaid endpoint from takeoff tools, checkout helpers, and classroom worksheets that must not reimplement the twelve-inches-to-a-foot conversion in every language. 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. The product promise is a transparent price over length_ft ratio, not live scraping of lumber-yard catalogs or tax-inclusive landed cost.
Integration use cases
Estimating apps and worksheets
Call a deterministic prepaid endpoint from takeoff software, homework drills, and CI fixtures instead of dividing by twelve in every client.