Nominal lumber size converter
See what a stamped board really measures: the 2 in a 2×4 dresses to 1.5 inches, or 38.1 mm, under the standard North American dry softwood rules. Start from the called size, a tape reading in inches or a metric measurement. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 2
- Source unit: nominal_in
- nominal_in
- From unit
- nominal_in
- Nominal in
- 2
- Actual in
- 1.5
- Actual mm
- 38.1
A nominal lumber size converter answers the everyday jobsite question: when the stamp says two by four, what size do you actually get after planing and drying? Enter a called size in nominal inches, a tape-measured dressed thickness in actual inches, or a metric reading in millimetres, centimetres, or mils; the tool returns nominal inches, dressed actual inches, millimetres, centimetres, and mils using the standard North American dry softwood dressing rules and the exact factor one inch equals twenty-five point four millimetres. That mapping is what framing diagrams, cut lists, and mixed SI–imperial BOMs need when a supplier quotes two-by stock while a CNC table wants millimetres.
What nominal versus actual lumber sizes mean
In North American softwood construction, lumber is sold under a nominal or called size such as one by six or two by four, while the piece you receive after kiln drying and surfacing four sides is smaller.
Industry practice for dry surfaced softwood follows a simple piecewise rule on each cross-section leg: a one-inch nominal board dresses to three-quarters of an inch; sizes greater than one inch and less than eight inches lose one half inch (so two becomes one and one half, four becomes three and one half, six becomes five and one half); and sizes of eight inches and wider lose three quarters of an inch (so eight becomes seven and one quarter, ten becomes nine and one quarter, twelve becomes eleven and one quarter).
Those dressed figures are the actual inches you should use for layout, pocket screws, and CAD solids. Converting actual inches to millimetres multiplies by the exact international inch of twenty-five point four millimetres, which keeps mixed-unit drawings honest. This tool converts a single cross-section dimension at a time—the thickness leg or the width leg—so a full two-by-four call maps to one and one half by three and one half inches after you convert each leg.
It does not encode species, grade, moisture content specials, green rough-sawn allowances, engineered I-joist catalogs, or metric softwood standards that use different call sizes. Treat the result as the common dry S4S softwood reference used on US and Canadian job sites, then confirm product sheets when you buy exotic hardwoods or specialty millwork that advertise full-sawn dimensions.
What you can do with it
Cut lists and framing diagrams
Map stamped two-by and one-by call sizes to dressed actual inches and millimetres before drafting wall sections, stud layouts, and CNC panels.
Mixed SI and imperial BOMs
Convert tape-measure millimetre readings back to nominal inches when ordering US softwood stock from a metric shop drawing.
FAQ
What is the actual size of a 2×4?
For dry surfaced North American softwood, each leg uses the dressing rule: 2″ nominal dresses to 1½″ actual, and 4″ nominal dresses to 3½″ actual, so a 2×4 is typically 1½″ × 3½″ (about 38.1 × 88.9 mm).
How does this tool convert nominal inches to millimetres?
It first applies the dry softwood dressing rule to get actual inches, then multiplies by the exact factor 25.4 mm per inch.
Does this work for green rough lumber or hardwoods?
The default dressing rules match common dry S4S softwood.
Is the nominal lumber size converter free?
The browser tool is free and runs locally.
How much smaller does a wide board get after dressing?
Boards 8 inches and wider lose three quarters of an inch, so a nominal 8 ends up seven and a quarter inches. Sizes above 1 and below 8 lose half an inch, and a 1-inch board dresses to 0.75.
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/conv/lumber-size \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":2,"from":"nominal_in"}'const res = await fetch("https://api.kit.forhosting.com/conv/lumber-size", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 2,
"from": "nominal_in"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/lumber-size",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 2,
"from": "nominal_in"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/lumber-size", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":2,"from":"nominal_in"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":2,"from":"nominal_in"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/lumber-size", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"value": 2,
"from": "nominal_in"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.lumber_size",
"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
nominal_min | 0.5 |
nominal_max | 24 |
max_abs | 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
Unknown unit names and sizes outside the published band are rejected with a clear invalid_input error so automation never invents a phantom board.
How to call the API and what comes back
When from is mm, cm, or mils (with common spellings such as millimetre, centimetre, and thou), value is a positive linear size in that unit and is treated as the dressed actual measure before inverting to nominal inches. Absolute magnitudes must stay within the published limit of one million. Send a JSON body with two required fields: value, a finite number, and from, a unit string. When from is nominal_in (aliases include nominal, nom, called size, and rough inches), value is the called size in inches between one half and twenty-four inclusive. When from is actual_in (aliases include actual, dressed, net, S4S, inch, and inches), value is a positive dressed thickness or width in inches. On success the response echoes rounded value and from, sets nominal_in and actual_in for the inch pair, actual_mm, actual_cm, and actual_mils for metric and fine English measures, nominal_min and nominal_max for the published band, formula to the dressing and millimetre expressions, message to a one-line English summary, steps to an ordered array of substitution lines, and supported_units to the five canonical unit ids. Failed validation—missing fields, non-finite numbers, non-positive dressed measures, sizes outside the half-to-twenty-four nominal band, or an unknown unit string—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item and zero marginal unit price.
Practical tips, limits, and related searches
Keep values inside the published nominal band so results stay on the everyday framing and finish stock range this page advertises. Prefer sending from as one of the five canonical tokens nominal_in, actual_in, mm, cm, or mils when you control the client; free-form aliases exist for human forms but automation should stay on the short ids. Convert each leg of a two-by board separately: call with value two and from nominal_in for thickness, then value four and from nominal_in for width, and assemble the pair in your cut list. Round-trip checks are easy: convert nominal two from nominal_in, read actual_mm of thirty-eight point one, then call again with that millimetre value and from equal to mm and confirm nominal_in returns two within the published rounding. Green rough lumber and some hardwood mills leave stock closer to full nominal; if your supplier ships rough sawn, do not assume the dry S4S deduction applies—measure the actual face and enter from actual_in or mm instead. This landing targets people searching for a nominal lumber size converter, two-by-four actual dimensions in millimetres, dressed softwood size chart, or called size versus true size online; it is not a board-foot calculator, not a span table, and not a hardwood full-sawn chart. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when you deliberately probe unknown units or range edges.
Integration use cases
Unit tests for lumber catalogs
Generate known-good 2×4 / 2×8 / 1×6 fixtures plus deliberate unknown-unit and out-of-range rejections for commerce and CAD converters.
Technical questions
What units are supported?
Canonical units are nominal_in, actual_in, mm, cm, and mils. Common aliases such as nominal, dressed, S4S, inch, millimetre, and thou are accepted. Unknown names return invalid_input.