Board foot calculator
A board 1 inch thick, 6 inches wide and 8 feet long is 4 board feet, or 576 cubic inches at 144 per board foot. Enter your stick sizes and piece count before you order at the yard. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Thickness
- 1
- Width
- 6
- Length
- 8
- Pieces
- 1
- Board feet
- 4
- Cubic inches
- 576
- Cubic feet
- 0.3333
This board foot calculator converts a piece of lumber into the North American board-foot volume used on mill tickets, yard invoices, and framing take-offs. Enter thickness in inches, width in inches, and length in feet; the engine multiplies those three dimensions by the optional piece count and divides by twelve, which is the identity that one board foot equals a slab one inch thick, twelve inches wide, and one foot long. A one-by-six eight-foot board is four board feet; a two-by-four eight-foot stick is five and one-third board feet. The work is pure deterministic arithmetic with no network calls, no sampling, and no date-dependent shortcuts.
Where board-foot take-offs fit in yards, shops, and software
Homeowners meet this calculation when a deck, shed, or interior trim list must be priced from a yard that still quotes by the board foot, or when a weekend materials run should not under-order after the stick sizes are already chosen. Framers and small contractors use the same numbers to turn a cut list of two-by stock into a mill tally before they call the yard, then apply their own waste factor on top of the pure volume.
Estimators embed the contract in take-off tools so a schedule of thickness, width, length, and piece count becomes board-foot totals without a spreadsheet full of hidden cells and mixed units. Product and education tools show learners why a one-by-twelve ten-foot board is ten board feet and why doubling thickness doubles volume at the same face size. This is not a spray-foam board-foot kit estimator and not a deck-board count from area: those are different search intents with different inputs.
Pair it with a nominal-to-actual lumber helper when you need dressed sizes first, and keep site judgement for species, grade, moisture, and dollars per thousand that your quote requires beyond the pure board-foot identity.
What you can do with it
DIY lumber take-off
Convert thickness, width, and length on a weekend cut list into board feet before you order at the yard.
Trade quotes and mill tallies
Turn stick schedules into reproducible board-foot totals for written framing and millwork quotes.
FAQ
What does the board foot calculator cost?
It is free in your browser on this page.
How is board-foot volume defined?
One board foot is 144 cubic inches, equivalent to 1 in × 12 in × 1 ft.
What happens if a dimension is zero or negative?
Thickness, width, length, and pieces must each be a positive number.
Does this convert a nominal 2×4 to the actual 1.5×3.5 size?
No. The engine uses the numbers you send. Convert nominal to actual first if you want dressed volume, then pass those inches here.
Is this the same as spray-foam board feet?
No. Spray-foam board feet measure insulation kit volume. This tool computes lumber board feet from thickness, width, and length.
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/build/board-foot \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"thickness":1,"width":6,"length":8}'const res = await fetch("https://api.kit.forhosting.com/build/board-foot", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"thickness": 1,
"width": 6,
"length": 8
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/build/board-foot",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"thickness": 1,
"width": 6,
"length": 8
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/build/board-foot", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"thickness":1,"width":6,"length":8}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"thickness":1,"width":6,"length":8}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/build/board-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
{
"thickness": 1,
"width": 6,
"length": 8
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "build.board_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.
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
Every dimension must be a finite strictly positive number: zero or negative thickness, width, length, or piece count is rejected as invalid_input instead of a hollow zero.
What a board foot is and what the response contains
A board foot is the North American lumber volume equal to one hundred forty-four cubic inches: a rectangular solid one inch thick, twelve inches wide, and twelve inches long, or any other stick whose product of dimensions matches that volume. Yards, mills, and framing take-offs still price many species and grades by the board foot rather than by the cubic metre, so a reliable conversion from stick size to board-foot volume is the first number on a quote. Optional pieces, defaulting to one, scales a single stick into a line item without a second pass. There is no species table, no moisture factor, no nominal-to-actual shrink, and no dollars-per-thousand rate baked into the core number: you get volume so you can apply your own grade, waste, and mill rate after the pure geometry is known. This calculator accepts thickness in inches, width in inches, and length in feet — the three measures printed on a typical dimensional-lumber ticket — and returns board_feet as thickness times width times length times pieces, all divided by twelve. The response echoes the parsed thickness, width, length, and pieces, reports board_feet rounded to the requested precision, and also returns cubic_inches and cubic_feet so you can cross-check the same volume in other units. The unit tag is board_foot, cubic_inches_per_board_foot is the constant one hundred forty-four, and a short formula string restates the identity for audit. Rejected cases include missing fields, non-finite values, magnitudes above the supported ceiling, and any dimension or piece count that is not a strictly positive number.
How thickness, width, length, and precision stay reproducible
Prefer thickness for the inch measure of the face-to-face depth, with aliases thickness_in, t, and T so forms and query strings can reuse the same contract. Width accepts width plus aliases width_in, w, and W, always in inches, never in millimetres unless you have already converted. Length accepts length plus length_ft, length_feet, l, and L, always in feet; sending inches in that field would inflate the result by twelve and is a caller error, not a unit the engine guesses. Optional pieces, with aliases quantity, qty, count, and n, defaults to one and must be strictly positive when sent so a stack or a take-off line can be scaled without a spreadsheet. Optional precision, with aliases decimals and dp, chooses decimal places for every numeric field in the response, defaulting to four and capped at fifteen so JSON goldens stay stable across runtimes. Computation forms board_feet as the product of thickness, width, length, and pieces divided by twelve, cubic_inches as thickness times width times length-in-inches times pieces, and cubic_feet as cubic inches over one thousand seven hundred twenty-eight. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline. Failed validation is not billed, and nothing is stored after the response returns, which is the same split the rest of the tier-A catalog uses for interactive checks versus scripted take-offs.
Where board-foot take-offs fit in yards, shops, 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 phone check at the yard to an automated pipeline without changing the mathematical result.
Integration use cases
Estimating software and CI fixtures
Generate deterministic board_feet values for unit tests, property checks, and automated take-off pipelines.