Roof dead load calculator
Architectural asphalt shingles on 7/16 OSB over 2x6 rafters at 16 inches, plus felt, come to a dead load of 5.9 psf. Choose the covering, deck, rafter size and spacing, add optional layers, and see each layer's weight and the total. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Roofing type
- Asphalt architectural
- Sheathing type
- osb_7_16
- Rafter size
- 2x6
- Rafter spacing in
- 16
- Underlayment psf
- 0.5
- Roof area sqft
- 1,500
- Roofing psf
- 2.5
- Sheathing psf
- 1.4
- Framing plf
- 2
- Framing psf
- 1.5
A roof dead load calculator turns the permanent materials of a roof assembly into a single pounds-per-square-foot figure that structural checks, beam tables, and preliminary designs actually use. Enter a roofing material type, deck sheathing type, rafter or joist size, and on-center spacing; optional underlayment, insulation, ceiling finish, and miscellaneous permanent loads stack on top. The tool returns each layer in psf, the framing contribution from lumber weight per linear foot distributed over spacing, the structure subtotal, and the total dead load. When you also supply roof area, it multiplies dead load by area to estimate total permanent weight in pounds. Custom material types accept measured manufacturer weights instead of table presets.
What roof dead load means and which layers count
Dead load is the permanent weight of construction materials that will remain on the structure for the life of the building. Live loads, snow, wind, and temporary construction loads are separate categories and are not computed here; this capability focuses only on the self-weight side of a load combination. Unit weight is expressed in pounds per square foot of roof surface so you can compare assemblies, feed span tables, or seed a more detailed analysis model.
Framing weight is often the least intuitive term: a board has weight per linear foot from its cross section and density, and that line load becomes a uniform psf when you divide by the on-center spacing converted to feet. This calculator uses that standard distribution—plf times twelve divided by spacing in inches—together with typical residential covering and sheathing tables so a homeowner or estimator can get a defensible starting number without a materials database.
Preset values are typical handbook estimates, not a substitute for manufacturer data sheets when a jurisdiction or engineer of record requires exact unit weights. When you already know those exact values, select custom types or pass override psf fields so the arithmetic still produces a clean, reproducible total.
Practical tips, limits, and related searches
Pick presets that match the products on the plans, then sanity-check the total against local experience: light asphalt and OSB roofs often land near ten to fifteen psf of structure before ceiling finishes, while clay tile or slate can double the covering term alone. Measure spacing on center, not clear spacing, and use the same roof surface basis you will use for live or snow load so combinations stay consistent.
Ceiling drywall only belongs in this total when it is supported by the roof or ceiling joists you are checking; floor assemblies and partition loads belong elsewhere. This landing targets people searching for a roof dead load calculator, roof weight per square foot, sheathing and rafter contribution, or permanent roof load for structural checks; it is not a snow load map, not a live load code lookup, and not a full ASCE load combination engine.
Prefer this capability when you already know materials and spacing and need a transparent psf breakdown; use companion tools for pitch, shingle count, or sheathing sheet takeoffs.
What you can do with it
Preliminary structural checks for residential reroofs
Designers enter new covering, existing deck, and framing size/spacing to estimate dead load psf before comparing member capacity or deflection under updated permanent weight.
Estimator worksheets and bid assumptions
Estimators convert plan materials into a documented permanent roof load, optionally times roof area, so weight-sensitive crane, haul, or retrofit notes stay consistent across quotes.
FAQ
How do you calculate roof dead load in psf?
Sum the unit weights of roofing, sheathing, framing, and any optional permanent layers. Framing psf is typically lumber plf × 12 ÷ on-center spacing in inches.
Does this include snow or live load?
No. It estimates permanent dead load only. Combine the result with separate live, snow, and wind values per your applicable code.
Is the roof dead load calculator free?
The browser tool is free and runs locally.
How is the weight of the rafters turned into psf?
The weight of one rafter per linear foot is multiplied by 12 and divided by the spacing in inches. A 2x6 at about 2 lb per linear foot, spaced 16 inches apart, adds 1.5 psf.
Can I use the manufacturer's weights instead of the presets?
Yes. The presets are typical handbook values, so when a data sheet or your engineer gives exact unit weights, choose the custom option or type your own psf for that layer and the total updates.
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/roof-dead-load \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"roofing_type":"asphalt_architectural","sheathing_type":"osb_7_16","rafter_size":"2x6","rafter_spacing_in":16}'const res = await fetch("https://api.kit.forhosting.com/home/roof-dead-load", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"roofing_type": "asphalt_architectural",
"sheathing_type": "osb_7_16",
"rafter_size": "2x6",
"rafter_spacing_in": 16
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/home/roof-dead-load",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"roofing_type": "asphalt_architectural",
"sheathing_type": "osb_7_16",
"rafter_size": "2x6",
"rafter_spacing_in": 16
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/home/roof-dead-load", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"roofing_type":"asphalt_architectural","sheathing_type":"osb_7_16","rafter_size":"2x6","rafter_spacing_in":16}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"roofing_type":"asphalt_architectural","sheathing_type":"osb_7_16","rafter_size":"2x6","rafter_spacing_in":16}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/home/roof-dead-load", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"roofing_type": "asphalt_architectural",
"sheathing_type": "osb_7_16",
"rafter_size": "2x6",
"rafter_spacing_in": 16
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "home.roof_dead_load",
"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 or negative framing spacing is rejected with a clear invalid_input error.
How to call the API and read the response
Roofing and sheathing types are closed enums covering common asphalt, wood, metal, tile, slate, built-up, and membrane systems plus plywood and OSB thicknesses, a none deck option, and custom. Rafter size accepts nominal two-by members through two-by-twelve or custom. Spacing must be a strictly positive finite number in inches. Send a JSON body with four primary fields: roofing_type (aliases roofing, covering), sheathing_type (aliases sheathing, deck), rafter_size (aliases framing_size, joist_size), and rafter_spacing_in (aliases spacing_in, oc_in, spacing). Optional non-negative numbers roofing_psf, sheathing_psf, and framing_psf override presets or satisfy custom types; underlayment_psf, insulation_psf, ceiling_psf, and misc_psf default to zero when omitted; roof_area_sqft optionally triggers total weight. On success the response echoes normalized types and rounded layer weights, framing_plf and framing_psf, additional_psf as the sum of optional layers, structure_psf as roofing plus sheathing plus framing, dead_load_psf as the full permanent unit load, a components array for UI tables, formula and message summary strings, and ordered steps suitable for teaching or regression asserts. Failed validation—missing required enums, unknown enum tokens, non-finite numbers, negative weights, zero spacing, or custom without a weight—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item.
Practical tips, limits, and related searches
If the roof is a manufactured truss system with a published self-weight, prefer rafter_size custom plus framing_psf instead of forcing a two-by size that does not describe the truss. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when integrators deliberately send a zero spacing to exercise the error path. Round-trip checks are easy: recompute framing as plf times twelve over spacing and sum every layer by hand to confirm dead_load_psf within the same fixed rounding used in the published steps.
Integration use cases
Teaching and automated unit tests for load stacks
Instructors and developers generate known asphalt-OSB-2x6 cases plus deliberate zero-spacing rejections as deterministic golden examples for API and classroom checks.
Technical questions
What happens when rafter spacing is zero?
Framing unit load is undefined. This tool returns invalid_input instead of dividing by zero.
Can I enter manufacturer unit weights instead of presets?
Yes. Choose custom roofing, sheathing, or rafter size and supply roofing_psf, sheathing_psf, or framing_psf, or pass those fields as overrides on a preset type.