Header length calculator
A 36-inch rough opening with 1.5-inch seats on both jack studs needs a 39-inch header. The calculator adds the opening and the bearing at each end into one length to mark before you cut. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Rough opening
- 36
- Bearing each
- 1.5
- Bearing left
- 1.5
- Bearing right
- 1.5
- Total bearing
- 3
- Header length
- 39
Framing a door or window starts with knowing how long the header must be before you cut lumber or order engineered stock. This header length calculator turns rough opening clear width and the bearing the header needs on the jack studs at each side into a single stock length you can mark on a tape. The standard takeoff identity is simple and deterministic: header length equals rough opening plus left bearing plus right bearing, or rough opening plus twice the seat when both jacks match. Use inches throughout or millimetres throughout—the engine never converts systems—so a thirty-six inch rough opening with one-and-a-half inch seats yields thirty-nine inches of header, and a nine-hundred millimetre opening with thirty-eight millimetre seats yields nine hundred seventy-six millimetres. Zero or negative dimensions fail with invalid input so takeoff forms and renovation apps can reject bad measurements before a cut list.
Measure the rough opening and choose bearing seats in one unit system
Rough opening clear width is the distance between the inside faces of the two jack (trimmer) studs that will support the header ends. Measure after the jacks are set, or take the planned clear width from the opening schedule and confirm it matches the door or window manufacturer rough-opening chart. Express rough opening and every bearing seat in the same linear unit—inches with inches, millimetres with millimetres—because this header length calculator never converts between systems.
A typical single two-by jack leaves about one and a half inches of seat under each end of the header; double jacks often leave about three inches per side; metric two-by stock is commonly thirty-eight millimetres per single jack. Missing bearings entirely, or supplying only one side without the other, also fails with a clear message so clients can prompt the user before a purchase order.
What you can do with it
Door and window framing takeoff
Carpenters enter rough opening width and jack seat bearing to mark header stock length before cutting or ordering multi-ply lumber.
Contractor estimating and cut lists
Estimating tools convert scheduled rough openings into header lengths with single or double jack seats for material lists and board-foot totals.
FAQ
What bearing should I use for a single 2× jack stud?
Common practice is about 1.5 inches (or about 38 mm) of seat per side for a single nominal 2× jack. Double jacks often use about 3 inches (or 76 mm) per side. Always match the jack thickness you will install.
What happens if rough opening is zero or negative?
Rough opening and every bearing seat must be strictly positive; non-positive dimensions cannot define header stock and are not charged.
Is the header length calculator free?
The browser tool runs free on your device.
What units should I use?
Any consistent linear system. Mixing inches for the opening with millimetres for bearing will produce wrong results.
Can I use a different bearing on each side of the opening?
Yes. Enter a left bearing and a right bearing instead of one value for both sides, for example when one end sits on a double jack and the other on a single. The header length is the opening plus both seats.
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/home/header-length \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"rough_opening":36,"bearing_each":1.5}'const res = await fetch("https://api.kit.forhosting.com/home/header-length", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"rough_opening": 36,
"bearing_each": 1.5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/home/header-length",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"rough_opening": 36,
"bearing_each": 1.5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/home/header-length", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"rough_opening":36,"bearing_each":1.5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"rough_opening":36,"bearing_each":1.5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/home/header-length", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"rough_opening": 36,
"bearing_each": 1.5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "home.header_length",
"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
Measure the rough opening and choose bearing seats in one unit system
Send rough_opening as a strictly positive finite number; aliases opening, opening_width, ro, rough_opening_width and clear_width map to the same field for forms that use shorter labels. For matching seats on both sides, send bearing_each (aliases bearing, jack_bearing, seat, bearing_per_side, bearing_each_side). For asymmetric posts or multi-ply seats, send both bearing_left and bearing_right instead. Zero or negative rough opening raises invalid_input and is not charged, because a non-positive opening cannot define header stock.
How header length, total bearing and bearing modes are computed
The engine adds the clear rough opening to the seat on the left jack and the seat on the right jack: header_length equals rough_opening plus bearing_left plus bearing_right. When you supply only bearing_each, both sides use that value and the response sets bearing_mode to symmetric, also echoing bearing_each for display. When you supply both bearing_left and bearing_right, those values drive the sum and bearing_mode is asymmetric; bearing_each is omitted from the success payload so optional fields never appear as null. Total_bearing is the sum of the two seats, which is twice bearing_each in the symmetric path. The response echoes rough_opening, reports bearing_left, bearing_right, total_bearing and header_length, and includes a short formula string plus method equal to header_length for stable branching in apps. Identical inputs always produce identical JSON because the path is pure arithmetic with no network, random seed or wall clock. This product does not size header plies, span tables or load grades; treat the length as the cut dimension for stock that already meets your span and code requirements, and verify openings against the door or window maker before you frame.
API usage, pricing, takeoff workflows and practical limits
Call the free in-browser header length calculator for garage doors, exterior windows, interior passage doors and classroom framing demos without opening a spreadsheet. Send a JSON body with required rough_opening and either bearing_each or the pair bearing_left and bearing_right. Use the prepaid API when a renovation app, lumber takeoff tool, framing configurator or property pipeline needs a stable contract under KIT balance at $0.002 per successful item; validation failures never consume balance after the engine rejects the request. Pair this endpoint with wall stud counters when the next step is king and jack counts, or with material estimators when you convert header length into board feet or engineered-beam order length. Remember that drywall, sheathing thickness and manufacturer RO charts can change the clear opening you must hit even when the structural header number looks settled—adjust rough_opening to the clear width the jacks will actually leave. Authors shipping SDKs can map header_length into cut lists while showing total_bearing and formula as explanatory detail for the homeowner or site supervisor reviewing the layout.
Integration use cases
Renovation apps and framing configurators
Mobile and web apps recompute header length as users change opening width or jack ply count, using the same deterministic API contract for quotes.
Technical questions
How is header length calculated from a rough opening?
header_length = rough_opening + bearing_left + bearing_right. With matching jack seats, use bearing_each so both sides equal that value and the length is rough_opening + 2 × bearing_each.