# Wood Beam, Joist & Post Calculator (NDS) (`jumblemog/wood-member-calculator`) Actor

NDS 2018 wood member design from plain text: check sawn lumber, glulam, LVL and PSL joists, rafters, beams, headers, studs and posts (bending, shear, bearing, deflection, column buckling), find the maximum span, or pick the smallest size that works.

- **URL**: https://apify.com/jumblemog/wood-member-calculator.md
- **Developed by:** [Jumble Mog](https://apify.com/jumblemog) (community)
- **Categories:** AI, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Wood Beam, Joist & Post Calculator (NDS)

**Check a wood joist, rafter, beam, header, stud or post by the NDS 2018, find how far it can span, or pick the smallest size that works, from one line of text.** Ask `2x10 DF-L No.2 floor joists at 16 in o.c., span 14 ft, 40 psf live, 10 psf dead`, `(2) 2x12 header, span 8 ft, 200 plf dead, 300 plf snow` or `what size beam, span 16 ft, tributary 12 ft, 40 psf live, 15 psf dead` and you get back:

- **Every check with its ratio**: bending (with beam stability CL and glulam volume CV), shear, bearing, live or snow deflection and total deflection for beams; compression with column stability CP, bending from wind on studs (NDS 3.9.2) and plate bearing for studs and posts.
- **Each load combination** of ASCE 7-16 (ASD) with its load duration factor CD (0.9 dead, 1.0 floor live, 1.15 snow, 1.25 roof live, 1.6 wind), and every other factor: size CF, wet service CM, incising Ci, repetitive member Cr.
- **Forces and capacities**: maximum moment, shear and reaction with their allowables, the bearing length needed, deflections as L/x, or the allowable axial load.
- **Maximum span**: the longest span or height that passes, with a span table at 12, 16, 19.2 and 24 in spacing for joists and rafters.
- **Selection**: the smallest sawn lumber, built-up lumber, LVL, PSL or glulam member that passes, with alternatives.
- **A chart** and a **Markdown report** for each request.

Materials: visually graded **Douglas Fir-Larch, Hem-Fir and Spruce-Pine-Fir** dimension lumber (Select Structural, No.1, No.2, Stud) from 2x4 to 4x16, single or built up from 2 to 5 plies; **glulam** 24F-V4, 24F-V8 and 24F-1.8E; **LVL** 2.0E and 1.9E and **PSL** 2.0E with typical published values.

It's made for:

- Builders, remodelers, deck builders and DIYers sizing a header, beam, joist or post, and checking a span-table answer for their own loads.
- Engineers, architects and students who want a fast NDS check with every factor shown.
- AI agents and building or estimating apps that need wood member sizes they can explain.

![A chart made by this Actor for 2x8 Hem-Fir No.2 floor joists under 40 psf live and 10 psf dead: maximum span 11'-11" at 16 in on center, limited by live-load deflection at L/360, and 13'-2", 11'-2" and 10'-0" at 12, 19.2 and 24 in spacing](https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/wood-member-calculator-example.png?signature=1ERzSzxp04mCksk9H4MoD)

### How to use it

1. Write **Members**, one per entry. The form has examples.
2. Optionally set a **Default species** and **Default grade** for lumber (Douglas Fir-Larch No.2 otherwise).
3. Click **Start**. Each request is a row in the results, with its summary, chart and report.

#### What you can write

| You write | It means |
|---|---|
| `2x10`, `(2) 2x12`, `double 2x10`, `3-ply 2x12`, `4x4` | Sawn lumber, single or built up |
| `5-1/8 x 18 glulam`, `1-3/4 x 11-7/8 LVL 2-ply`, `3-1/2 x 11-7/8 PSL` | Glulam, LVL or PSL (width x depth, inches) |
| `DF-L`, `Hem-Fir`, `SPF`, `No.2`, `#1`, `SS`, `Stud`, `24F-V8`, `LVL 1.9E` | Species, grade or stress class |
| `joist`, `rafter`, `beam`, `header`, `stud`, `post` | How the member is used |
| `span 14 ft`, `12'-6" span`, `8 ft tall`, `span 4.2 m` | Span (beams) or height (studs and posts) |
| `40 psf live, 10 psf dead`, `30 psf snow`, `20 psf roof live`, `1.9 kPa live` | Area loads |
| `16 in o.c.` (joists, rafters, studs), `tributary 12 ft` (beams) | The width that area loads act on |
| `300 plf snow`, `4.4 kN/m dead` | Line loads on a beam or on a stud wall |
| `6000 lb dead, 8000 lb live` | Axial loads on a post (or a midspan point load on a beam) |
| `wind 25 psf` | Wind pressure on studs (bending, with 0.6W) |
| `unbraced 8 ft`, `unbraced`, `bearing 3 in`, `L/480`, `total L/240`, `K = 2`, `wet`, `incised` | Options |
| `maximum span ...`, `max height ...` | The longest span or height |
| `what size ...`, `select ...`, `max depth 11.25 in`, `LVL`, `glulam` | Selection |

The same as an object: `{"size": "2x12", "role": "joist", "spacing": 16, "length": "16 ft", "areaLoads": {"D": 10, "L": 40}, "species": "HF"}` or `{"type": "select", "role": "header", "length": "6 ft", "lineLoads": {"D": 300, "S": 500}}`.

### Examples

- `2x10 DF-L No.2 floor joists at 16 in o.c., span 14 ft, 40 psf live, 10 psf dead` → OK at 0.84 in bending: M = 1,714 lb-ft against 2,029 lb-ft (Fb' = 900 × CF 1.1 × Cr 1.15 = 1,139 psi); live deflection L/577.
- `maximum span of 2x8 Hem-Fir No.2 floor joists, 40 psf live, 10 psf dead` → 11'-11" at 16 in o.c., limited by L/360; 13'-2" at 12 in, 11'-2" at 19.2 in, 10'-0" at 24 in.
- `(2) 2x12 header, span 8 ft, 200 plf dead, 300 plf snow` → OK at 0.74 in bending under D + S (CD 1.15); needs 1.1 in of bearing.
- `what size beam, span 16 ft, tributary 12 ft, 40 psf live, 15 psf dead` → (2) 1-3/4 x 14 LVL 2.0E at 0.89; also (4) 1-3/4 x 11-1/4 LVL or a 3-1/8 x 15 glulam.
- `4x4 DF-L No.2 post, 8 ft tall, 3000 lb dead, 3500 lb live` → OK at 0.93: CP = 0.366, allowable load 6,960 lb.
- `5-1/8 x 18 glulam beam, span 22 ft, 300 plf dead, 600 plf snow, unbraced 11 ft, bearing 4 in` → OK at 0.92 with CL 0.964 and CV 0.956.

### How-to examples

Each example is a complete input; the results are from runs of the Actor (also listed under **Examples**).

#### How to check a floor joist span (NDS)

```json
{"requests": ["2x10 DF-L No.2 floor joists at 16 in o.c., span 14 ft, 40 psf live, 10 psf dead"]}
```

Result: OK at 0.84 in bending, with M = 1,714 lb-ft against 2,029 lb-ft (Fb' = 900 × CF 1.1 × Cr 1.15 = 1,139 psi) and a live load deflection of L/577.

#### How to find the maximum span of a joist

```json
{"requests": ["maximum span of 2x8 Hem-Fir No.2 floor joists, 40 psf live, 10 psf dead"]}
```

Result: 11'-11" at 16 in o.c., limited by L/360, with a span table: 13'-2" at 12 in, 11'-2" at 19.2 in and 10'-0" at 24 in.

#### How to size a beam or header (lumber, LVL or glulam)

```json
{"requests": ["what size beam, span 16 ft, tributary 12 ft, 40 psf live, 15 psf dead", "(2) 2x12 header, span 8 ft, 200 plf dead, 300 plf snow"]}
```

Result: a (2) 1-3/4 x 14 LVL 2.0E at 0.89, or (4) 1-3/4 x 11-1/4 LVL or a 3-1/8 x 15 glulam; and the header OK at 0.74 in bending under D + S (CD 1.15), needing 1.1 in of bearing.

#### How to let an AI agent size wood framing

Add this Actor to the [Apify MCP server](https://mcp.apify.com) with `https://mcp.apify.com/?tools=jumblemog/wood-member-calculator`. The agent passes the member as one line and answers with the NDS checks and factors, instead of reading a span table from memory.

### FAQ

**Which woods does it know?** Douglas Fir-Larch, Hem-Fir and Spruce-Pine-Fir dimension lumber (Select Structural, No.1, No.2, Stud), single or built up, plus glulam, LVL and PSL with typical published values.

**Which checks does it do?** Bending with beam stability, shear, bearing and deflection for beams; compression with column stability for posts and studs; with the NDS 2018 adjustment factors.

**Can it pick the size for me?** Yes. Ask "what size beam" and it gives the smallest member that passes, with alternatives.

**Is it a stamped calculation?** No. It's a design aid; local codes, span tables and a licensed engineer have the final word.

### Input

| Field | What it is |
|---|---|
| `requests` | Members, as lines of text or objects (up to 200 per run) |
| `species`, `grade` | Defaults for sawn lumber when a request doesn't name them |
| `charts` | Draw a chart for each request (default on) |

### Output

One dataset item per request, also saved together in the run's `OUTPUT` record:

```json
{
  "request": 1, "status": "ok", "type": "check", "title": "2x10 DF-L No.2 joist check",
  "summary": "2x10 DF-L No.2 joist spanning 14'-0\" is OK: governing bending at 0.84 (D + L, CD 1); shear 0.26, live deflection (L/360) 0.62, total deflection (L/240) 0.48. ...",
  "checks": [{"check": "Bending", "ratio": 0.844, "ok": true, "actual": 961.3, "allowable": 1138, "unit": "psi", "basis": "D + L, CD 1"},
             {"check": "Live deflection (L/360)", "ratio": 0.624, "ok": true, "actual": 0.2912, "allowable": 0.4667, "unit": "in", "basis": "L/577"}],
  "member": {"name": "2x10 DF-L No.2", "material": "sawn lumber", "species": "Douglas Fir-Larch", "width": 1.5, "depth": 9.25, "S": 21.39, "...": "..."},
  "factors": {"CD": 1.0, "CF (Fb)": 1.1, "CM (Fb)": 1.0, "Ci (Fb)": 1.0, "Cr": 1.15, "CL": 1.0},
  "forces": {"maxMoment": 1714, "allowableMoment": 2029, "maxReaction": 489.6, "bearingNeeded": 0.522, "...": "..."},
  "deflection": {"transient": 0.291, "total": 0.337, "spanOverTransient": 577, "...": "..."},
  "units": {"stress": "psi", "length": "ft", "dimension": "in", "force": "lb", "moment": "lb-ft", "lineLoad": "plf"},
  "imageUrl": "https://api.apify.com/v2/key-value-stores/.../records/001-2x10-DF-L-No-2-joist-check.png"
}
```

Items also have `combinations` (every load combination with its forces and stresses), `loads` (the line loads on the member, self-weight included), `slenderness` for studs and posts, `maxSpan` and `spanTable` for spans, `alternatives` for selections, `warnings`, `notes` (every assumption), a Markdown `report` and links to the chart and report. A request that can't be computed has `"status": "failed"` and the reason in `error`, and isn't billed.

### How it works

1. **Design values** from the NDS Supplement (Table 4A for lumber, 5A for glulam) are multiplied by the adjustment factors of NDS chapters 2 to 5 for each ASD load combination (ASCE 7-16 2.4.1), with CD set by the shortest load in it.
2. **Beams** are simple spans: bending with CL (NDS 3.3.3) and CV for glulam, shear at a distance d from the support, bearing on Fc⊥, and deflection under the largest transient load and under that plus half the dead load for creep (the full dead load when wet).
3. **Studs and posts**: compression with CP (NDS 3.7.1) about both axes, wind bending combined by NDS 3.9.2, and plate bearing.
4. **Area loads** become line loads by the spacing or the tributary width, and the member's self-weight is added to the dead load.
5. **Maximum span** searches the span to the inch; **selection** checks every standard size and keeps the smallest that passes (sawn lumber first, then LVL or PSL, then glulam for beams and posts).

### Pricing

You pay one low price per request, at the price shown on this page. The chart and report are included. Requests that can't be computed are never charged. If you set a maximum cost per run, the Actor stops before a request that wouldn't fit.

### Speed

A check takes milliseconds and a selection well under a second. A run through the API answers in about 10 seconds, including the cloud container starting.

### Tips and limits

- **This is a design aid, not a stamped calculation.** Loads, spans and support conditions are your input; local codes, span tables and a licensed engineer have the final word.
- **Simple spans only**: no cantilevers, continuous spans, or point loads other than at midspan. Notches, holes, connections, fire and vibration aren't checked.
- **Not included**: Southern Pine (its values are size-specific), timbers 5x5 and larger, MSR/MEL lumber, I-joists and engineered products other than the typical LVL and PSL values given (use your manufacturer's values for those).
- **Deflection limits** default to L/360 live and L/240 total for floors and L/240 and L/180 for roofs; give your own with `L/480` or `total L/360`.
- **Beam bracing**: joists and rafters are taken as braced by the sheathing, and beams as braced along the top unless you write `unbraced` or `unbraced 8 ft`.
- **Limits**: 200 requests per run.

### For AI agents and developers

This Actor works with the [Apify MCP server](https://mcp.apify.com), so AI agents can call it as a tool. Pass `requests` as plain text and read `summary`, `checks` and `warnings`. A direct API call that waits for the answer:

```bash
curl -X POST "https://api.apify.com/v2/acts/jumblemog~wood-member-calculator/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"requests": ["what size header, span 6 ft, 300 plf dead, 500 plf snow"]}'
```

`run-sync` instead returns the run's `OUTPUT`: the status, the counts and every result as JSON.

In Python, with the `apify-client` package:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("jumblemog/wood-member-calculator").call(run_input={
    "requests": [{"type": "span", "size": "2x10", "role": "joist", "areaLoads": {"D": 10, "L": 40}, "species": "SPF"}],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["summary"])
```

### Credits

- Method: ANSI/AWC NDS 2018, *National Design Specification for Wood Construction*, and its Supplement design values; ASCE 7-16 load combinations; IBC Table 1604.3 deflection limits. This Actor is not affiliated with the American Wood Council.
- Charts: [Vega-Lite](https://vega.github.io/vega-lite/) and [vl-convert](https://github.com/vega/vl-convert) (BSD-3-Clause), with the [Inter](https://rsms.me/inter/) font (SIL Open Font License).

# Actor input Schema

## `requests` (type: `array`):

One member per entry, as a line of text or an object. The member: '2x10', '(2) 2x12' or 'double 2x10', '4x4', '5-1/8 x 15 glulam', '1-3/4 x 11-7/8 LVL' (2-ply), '3-1/2 x 11-7/8 PSL'; its species and grade ('DF-L No.2', 'Hem-Fir No.1', 'SPF Stud', '24F-V8', 'LVL 1.9E'); its use (joist, rafter, beam, header, stud, post); the span or height ('span 14 ft', '8 ft tall', "12'-6""); the loads ('40 psf live, 10 psf dead', '300 plf snow', '6000 lb dead' axial or at midspan, 'wind 25 psf'), with '16 in o.c.' spacing or 'tributary 12 ft' for area loads on a beam; and options: 'unbraced 8 ft', 'bearing 3 in', 'L/480', 'total L/240', 'wet', 'incised', 'K = 2'. 'maximum span ...' finds the longest span or height; 'what size ...' picks the smallest member ('max depth 11.25 in', 'LVL' or 'glulam' to choose the material). Object fields: type (check, span or select), size, plies, material, width, depth, species, grade, glulamClass, sclGrade, role, roof, spacing, areaLoads, lineLoads, pointLoads ({D, L, Lr, S, W}), pointAt, length, unbraced, bearing, wet, incised, liveLimit, totalLimit, k, weakBraced, tributary, maxDepth, title, text.

## `species` (type: `string`):

For sawn lumber when a request doesn't name one (Douglas Fir-Larch if left empty).

## `grade` (type: `string`):

For sawn lumber when a request doesn't name one (No.2 if left empty).

## `charts` (type: `boolean`):

Each check's ratio of actual to allowable, the maximum span at each joist spacing, or the members that pass a selection.

## Actor input object example

```json
{
  "requests": [
    "2x10 DF-L No.2 floor joists at 16 in o.c., span 14 ft, 40 psf live, 10 psf dead",
    "(2) 2x12 header, span 8 ft, 200 plf dead, 300 plf snow",
    "maximum span of 2x8 Hem-Fir No.2 floor joists, 40 psf live, 10 psf dead",
    "what size beam, span 16 ft, tributary 12 ft, 40 psf live, 15 psf dead",
    "4x4 DF-L No.2 post, 8 ft tall, 3000 lb dead, 3500 lb live",
    "2x6 studs at 16 in o.c., 10 ft tall, 400 plf dead, 600 plf live, wind 25 psf",
    {
      "size": "5-1/8 x 18 glulam",
      "role": "beam",
      "length": "22 ft",
      "lineLoads": {
        "D": 300,
        "S": 600
      },
      "unbraced": "11 ft",
      "bearing": 4
    }
  ],
  "charts": true
}
```

# Actor output Schema

## `results` (type: `string`):

One row per request: the summary and chart.

## `output` (type: `string`):

The OUTPUT record: every result in one JSON object.

## `files` (type: `string`):

Charts (PNG and SVG) and Markdown reports in the run's key-value store.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "requests": [
        "2x10 DF-L No.2 floor joists at 16 in o.c., span 14 ft, 40 psf live, 10 psf dead",
        "(2) 2x12 header, span 8 ft, 200 plf dead, 300 plf snow",
        "maximum span of 2x8 Hem-Fir No.2 floor joists, 40 psf live, 10 psf dead",
        "what size beam, span 16 ft, tributary 12 ft, 40 psf live, 15 psf dead",
        "4x4 DF-L No.2 post, 8 ft tall, 3000 lb dead, 3500 lb live",
        "2x6 studs at 16 in o.c., 10 ft tall, 400 plf dead, 600 plf live, wind 25 psf",
        {
            "size": "5-1/8 x 18 glulam",
            "role": "beam",
            "length": "22 ft",
            "lineLoads": {
                "D": 300,
                "S": 600
            },
            "unbraced": "11 ft",
            "bearing": 4
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jumblemog/wood-member-calculator").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "requests": [
        "2x10 DF-L No.2 floor joists at 16 in o.c., span 14 ft, 40 psf live, 10 psf dead",
        "(2) 2x12 header, span 8 ft, 200 plf dead, 300 plf snow",
        "maximum span of 2x8 Hem-Fir No.2 floor joists, 40 psf live, 10 psf dead",
        "what size beam, span 16 ft, tributary 12 ft, 40 psf live, 15 psf dead",
        "4x4 DF-L No.2 post, 8 ft tall, 3000 lb dead, 3500 lb live",
        "2x6 studs at 16 in o.c., 10 ft tall, 400 plf dead, 600 plf live, wind 25 psf",
        {
            "size": "5-1/8 x 18 glulam",
            "role": "beam",
            "length": "22 ft",
            "lineLoads": {
                "D": 300,
                "S": 600,
            },
            "unbraced": "11 ft",
            "bearing": 4,
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jumblemog/wood-member-calculator").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "requests": [
    "2x10 DF-L No.2 floor joists at 16 in o.c., span 14 ft, 40 psf live, 10 psf dead",
    "(2) 2x12 header, span 8 ft, 200 plf dead, 300 plf snow",
    "maximum span of 2x8 Hem-Fir No.2 floor joists, 40 psf live, 10 psf dead",
    "what size beam, span 16 ft, tributary 12 ft, 40 psf live, 15 psf dead",
    "4x4 DF-L No.2 post, 8 ft tall, 3000 lb dead, 3500 lb live",
    "2x6 studs at 16 in o.c., 10 ft tall, 400 plf dead, 600 plf live, wind 25 psf",
    {
      "size": "5-1/8 x 18 glulam",
      "role": "beam",
      "length": "22 ft",
      "lineLoads": {
        "D": 300,
        "S": 600
      },
      "unbraced": "11 ft",
      "bearing": 4
    }
  ]
}' |
apify call jumblemog/wood-member-calculator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jumblemog/wood-member-calculator"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ArSkv6pt9F66WoLU9/builds/IUNHJTybr8Nsif4Zr/openapi.json
