Wall framing calculator
A 10 foot wall, 8 feet high, with studs 16 inches on center and one door takes 11 studs and 3 plates, 14 pieces in all. Know what to load at the lumber yard before anyone cuts stock. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Wall length
- 120
- Wall height
- 96
- Stud spacing
- 16
- Openings
- 1
- Plate thickness
- 1.5
- Extra studs per opening
- 2
- Plate count
- 3
- Full bays
- 7
- Remainder
- 8
Framing a partition or exterior wall is a lumber takeoff, not a square-footage guess: you need a whole-piece count of studs and plates before anyone cuts stock. This wall framing calculator takes the wall length, the wall height, the on-center stud spacing, and an optional count of rough openings, then returns the stud count, the plate count, the cut stud length, and the linear footage those members represent. Studs land at both ends and on the spacing grid; extra king studs are added per opening; plates default to a bottom plate plus a double top plate.
Where a wall framing calculator earns its keep
Homeowners planning a weekend partition reach for a wall framing calculator when the lumber yard asks how many studs and how many plates, not how many studs alone and not how many square feet of drywall. Typing a ten-foot run, an eight-foot height, sixteen-inch on-center spacing, and one door opening yields a piece count and a net stud length you can compare against a unit price without opening a spreadsheet of mixed units.
Contractors bidding a simple rectangular wall pin the goldens in tests so a takeoff script and a phone check never disagree on whether nine base studs plus two kings cover a one-hundred-twenty-inch plate. Trade-school modules on rough carpentry can freeze the ten-by-eight, sixteen-on-center, one-opening case because the arithmetic is deterministic. This landing is the search for wall framing as lumber: studs and plates from length, height, spacing, and openings.
A stud-only counter answers a different query—how many verticals, with no plate line and no height—and should not share this page.
What you can do with it
Weekend partition framing takeoff
Homeowners enter plate length, wall height, and sixteen-inch on-center spacing, add a door opening, and know how many studs and plates to load before the weekend build.
Lumber yard and ecommerce cut-list tools
Retail sites compute stud and plate counts as shoppers change wall length, height, or on-center options, using the same deterministic contract for quotes and carts.
Contractor takeoff and bid automation
Estimating tools batch wall runs from floor plans, apply an openings and plate-stack policy, and emit lumber counts for purchase orders without spreadsheets.
FAQ
What units should I use for length, height, and spacing?
Any consistent linear system. Mixing feet and inches without converting will produce a wrong count.
What if stud spacing is zero or wall length is not positive?
Stud spacing must be strictly positive; zero spacing is rejected. Wall length must be a positive number. Those failures are not charged.
Is the wall framing calculator free?
The browser tool runs free on your device.
How should I count doors, windows, and the plate stack?
Set openings to the number of rough openings that need extra framing members.
How many studs do I need for a 10 foot wall at 16 inches on center?
Nine studs on the spacing grid, with one at each end. Add 2 extra studs for each door or window: with one opening that makes 11 studs, plus 3 plates for a bottom plate and a double top plate.
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/framing \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"wall_length":120,"wall_height":96,"stud_spacing":16}'const res = await fetch("https://api.kit.forhosting.com/build/framing", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"wall_length": 120,
"wall_height": 96,
"stud_spacing": 16
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/build/framing",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"wall_length": 120,
"wall_height": 96,
"stud_spacing": 16
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/build/framing", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"wall_length":120,"wall_height":96,"stud_spacing":16}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"wall_length":120,"wall_height":96,"stud_spacing":16}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/build/framing", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"wall_length": 120,
"wall_height": 96,
"stud_spacing": 16
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "build.framing",
"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
Zero spacing and a non-positive wall length are rejected with invalid_input so a typo never invents an infinite bay count. The same pure arithmetic powers the free browser tool and the API path, so a Saturday sketch matches the line a purchasing script posts later at $0.002 per successful item.
How studs, plates, and cut length are counted
A framed wall is bought as studs and plates, not as an abstract area. Stud spacing is the on-center distance between successive studs; sixteen and twenty-four are the residential defaults when you work in inches, but any strictly positive finite spacing in the same units as the length is accepted. When the wall length is an exact multiple of the spacing, the formula is length divided by spacing plus one. When a partial bay remains at the far end, the closing end stud is still counted, which is equivalent to floor of length divided by spacing plus two. Measure the plate length of the wall you are framing, end to end, in whatever linear unit your plans use, and send that value as wall_length. Measure the finished wall height—typically from the subfloor to the ceiling plane or to the top of the double plate—and send it as wall_height. The engine always plants a stud at each end of the plate, then fills intermediate positions every stud_spacing along the run. Those two cases produce full_bays, remainder (zero when the end lands on the grid), and base_studs. Openings are optional: openings defaults to zero and accepts a non-negative integer count of doors and windows that need extra king or jack members beside the on-center layout. extra_studs_per_opening defaults to two—typical for one king stud each side of a rough opening—and may be raised when your shop standard also counts jack studs. opening_studs equals openings times extra_studs_per_opening; stud_count is the sum of base_studs and opening_studs. Plates are a separate lumber family: plate_count defaults to three, representing one bottom sole plate and a double top plate, which is the common residential stack. plate_linear is plate_count times wall_length. If you send plate_thickness in the same units as height (one and a half for inch-based two-by stock), stud_length is wall_height minus plate_count times plate_thickness so the cut list matches a net stud; when plate_thickness is omitted it defaults to zero and stud_length equals the wall height. stud_linear is stud_count times stud_length; total_pieces and total_linear add the two families. The method label is always oc_studs_plus_plates so downstream logs can branch on a stable name.
What you send, which units apply, and how errors behave
If you measured the wall in inches, send spacing in inches—one hundred twenty for a ten-foot run and sixteen for standard on-center. Send three required finite numbers and optional takeoff knobs. wall_length is the plate run; aliases length, wall, and span are accepted for form labels that prefer those names. wall_height is the finished height in the same linear system; aliases height and h cover compact columns. stud_spacing is the on-center pitch in that same system; aliases spacing, oc, on_center, and centers cover common takeoff spreadsheet headers. If you work in millimetres or feet, keep every linear field in that system; the engine does not convert units, so mixing feet for length with inches for spacing will invent a nonsense stud count. openings defaults to zero. extra_studs_per_opening defaults to two and is capped at twenty. plate_count defaults to three and accepts integers from one through six so a single top plate is plate_count two rather than a second endpoint. plate_thickness defaults to zero; send one and a half only when height is in inches and you want net two-by stud length. Missing required fields, empty strings, non-numeric text, NaN, and Infinity fail with invalid_input naming the field and are not charged. A zero or negative stud_spacing fails with a message that spacing must be a positive number because zero spacing is invalid_input. A zero or negative wall_length fails because wall length is not positive. A non-positive wall_height fails the same way. If plate_count times plate_thickness meets or exceeds wall_height, the request fails so the cut list never lists a zero-length stud. On success the JSON echoes the cleaned inputs, then full_bays, remainder, base_studs, opening_studs, stud_count, stud_length, stud_linear, plate_linear, total_pieces, total_linear, plus a formula string and method oc_studs_plus_plates. API pricing is the published base of $0.002 per successful item; validation failures do not consume prepaid balance.
Where a wall framing calculator earns its keep
Remodelers choosing between sixteen-inch and twenty-four-inch on-center re-run the same length and height to see how stud_count and stud_linear move when the bay grid changes; that is a framing decision, not a sheathing decision. Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance. Keep requests small, pin stud_count, plate_count, and stud_length in tests, and you get a reproducible framing takeoff for quotes, purchase orders, and edge workers without standing up a CAD kernel of your own.
Technical questions
How does the wall framing calculator count studs and plates?
It plants studs at both ends, fills intermediate on-center positions from stud_spacing, then adds openings × extra_studs_per_opening (default two per opening). Plates default to three full-length lines (one bottom and a double top). stud_length is wall_height minus plate_count × plate_thickness.