# Deck Framing Calculator (Joists, Beams, Posts) (`jumblemog/deck-calculator`) Actor

Deck framing from plain text: joist size and spacing, beam size and post count, post size, footing size, ledger lag screw spacing and a materials list for a wood deck by NDS and AWC DCA 6, plus deck joist span tables.

- **URL**: https://apify.com/jumblemog/deck-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

## Deck Framing Calculator (Joists, Beams, Posts)

**Size the joists, beam, posts and footings of a wood deck, with the ledger bolt spacing and a lumber list, from one line of text.** Ask `12x16 deck, 4 ft high, attached, 2x10 joists 16 oc, southern pine` or `span table for hem-fir deck joists` and you get back:

- **Joists**: the smallest size that spans the deck at your spacing (or a check of the size you name), its longest span and what limits it, and the longest cantilever.
- **The beam and posts**: a built-up (2) or (3) ply 2x8, 2x10 or 2x12 beam on the fewest posts, the post spacing, the load on each post and whether a 4x4 or a 6x6 carries it.
- **Footings**: the round or square footing size for your soil, and the concrete bags to fill them.
- **The ledger**: 1/2" lag screw and through-bolt spacing for an attached deck (IRC Table R507.9.1.3(1)), or a second beam for a freestanding deck.
- **A materials list**: joists, ledger, rim, beam plies, posts, hangers, ties, post bases, concrete, deck boards in the stock length with the least waste, screws and the guard you need above 30".
- **A to-scale framing plan** and a **Markdown report**.

It's made for:

- Homeowners and DIY builders planning a deck and its shopping list.
- Deck builders, contractors and lumber yards quoting decks and checking spans.
- AI agents and home-improvement apps that need deck framing numbers they can show their work for.

![A framing plan made by this Actor for a 16 by 12 ft attached deck, 6 ft high: 2x8 joists at 16 inches on center spanning 10 ft from the ledger to a (2) 2x10 beam on three 4x4 posts 8 ft apart, with a 2 ft cantilever](https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/deck-calculator-example.png?signature=kbHFGNkTCCo0nBuuCY1G)

### How to use it

1. Write **Decks and span tables**, one per entry. The form has examples.
2. Optionally change the **Default species** (southern pine) or the **Default soil bearing** (1,500 psf).
3. Click **Start**. Each request is a row in the results, with its summary, drawing and report.

#### What you can write

| You write | It means |
|---|---|
| `12x16 deck`, `16 ft wide, 12 ft out from the house` | The deck size; in `12x16` the short side is read as the distance out from the house |
| `4 ft high`, `2 ft off the ground`, `ground level` | Height of the deck surface (3 ft by default) |
| `attached` (default), `freestanding` | A ledger on the house, or a second beam |
| `2 ft cantilever` | Joists running past the beam (up to 1/4 of their span) |
| `2x8 joists`, `16 oc`, `12 in on center` | Joist size (chosen for you when left out) and spacing (16" by default) |
| `(2) 2x10 beam`, `3-ply 2x12 beam`, `double 2x10 beam` | The beam |
| `6x6 posts`, `4 posts`, `posts 8 ft apart` | Post size and how many |
| `southern pine`, `Douglas fir`, `hem-fir`, `SPF`, `No.1` | Species and grade (No.2 by default) |
| `5/4 decking`, `2x6 decking`, `composite` | Deck boards |
| `2000 psf soil`, `42 in frost depth` | Soil bearing and footing depth |
| `60 psf live`, `50 psf snow` | A heavier live or snow load (40 psf by default) |
| `span table for hem-fir joists`, `how far can a 2x8 joist span at 24 oc` | A joist span table |

The same as an object: `{"width": "20 ft", "projection": "10 ft", "height": "6 ft", "beam": "(3) 2x12", "posts": 3, "species": "SPF"}`.

### Examples

- `12x16 deck, 4 ft high, attached, 2x10 joists 16 oc, southern pine` → 2x10 joists spanning 12'-0" (up to 14'-0"), a (2) 2x10 beam on three 4x4 posts 8'-0" apart, 3,000 lb per post on 20" footings, ledger lags at 15" on center; 13 joists and 26 deck boards 16 ft long.
- `freestanding 14 x 20 ft deck 2 ft off the ground, hem-fir, composite decking` → 2x12 joists spanning 14'-0", two (3) 2x12 beams on three posts each, 24" footings.
- `span table for hem-fir deck joists` → at 16" on center 2x6 8'-8", 2x8 11'-1", 2x10 13'-7", 2x12 15'-9", the same as the DCA 6 table.

### How-to examples

These are examples from **Examples** above, written as complete inputs; the result lines are from their runs.

#### How to size deck joists, beam and posts

```json
{"requests": ["12x16 deck, 4 ft high, attached, 2x10 joists 16 oc, southern pine"]}
```

Result: 2x10 joists spanning 12'-0" (up to 14'-0"), a (2) 2x10 beam on three 4x4 posts 8'-0" apart, 3,000 lb per post on 20" footings, ledger lags at 15" on center; 13 joists and 26 deck boards 16 ft long.

#### How to frame a freestanding deck

```json
{"requests": ["freestanding 14 x 20 ft deck 2 ft off the ground, hem-fir, composite decking"]}
```

Result: 2x12 joists spanning 14'-0", two (3) 2x12 beams on three posts each, 24" footings.

#### How to look up a deck joist span table

```json
{"requests": ["span table for hem-fir deck joists"]}
```

Result: At 16" on center 2x6 8'-8", 2x8 11'-1", 2x10 13'-7", 2x12 15'-9", the same as the DCA 6 table.

#### How to let an AI agent frame a deck

Add this Actor to the [Apify MCP server](https://mcp.apify.com) with `https://mcp.apify.com/?tools=jumblemog/deck-calculator`. The agent writes the deck in one line ("12x16 deck, 4 ft high, attached") and passes on the joist, beam, post and footing sizes with the lumber list instead of guessing them.

### FAQ

**What does it size?** Joists, the built-up beam, posts, footings and ledger fasteners for a rectangular wood deck, with a materials list and a framing plan.

**Which rules does it follow?** The AWC DCA 6 deck guide and NDS 2018 lumber values, with ledger fastener spacing from the IRC.

**Which lumber does it know?** Southern pine, Douglas fir-larch, hem-fir and SPF in No.2 or No.1 grade.

**Does it replace a permit review?** No. Local codes, snow loads and frost depths differ, so check with your building department.

**How many can I run at once?** Up to 200 decks or span tables per run, each as a line of text or an object. A request that can't be computed isn't billed.

**Does it work with Zapier, Make or n8n?** Yes. Call the Actor with its Apify app or an HTTP request and pass the results on.

### Input

| Field | What it is |
|---|---|
| `requests` | Decks or span tables, as lines of text or objects (up to 200 per run) |
| `species` | Lumber species when a request doesn't say (SP, DF-L, HF or SPF) |
| `soil` | Soil bearing in psf when a request doesn't say (1,500) |
| `charts` | Draw each deck or span table (default on) |

### Output

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

```json
{
  "request": 1, "status": "ok", "type": "deck", "title": "16'-0\" × 12'-0\" attached deck framing",
  "summary": "16'-0\" × 12'-0\" attached deck, 4'-0\" high, Southern Pine No.2: 2x10 joists at 16\" on center spanning 12'-0\" (up to 14'-0\"), a beam of (2) 2x10 on 3 4x4 posts 8'-0\" apart, 20\" round footings for 3,000 lb per post. ...",
  "deck": {"width": 192, "projection": 144, "height": 48, "attached": true, "area": 192, "joistSpan": 144, "species": "Southern Pine"},
  "joists": {"size": "2x10", "spacing": 16, "span": 144, "maxSpan": 168.3, "governs": "bending", "use": 0.855, "count": 13, "buyLength": "12 ft"},
  "beam": {"size": "(2) 2x10", "postsPerBeam": 3, "postSpacing": 96, "maxSpan": 104.7, "load": 300},
  "posts": {"size": "4x4", "count": 3, "height": 29.5, "load": 3000, "capacity": 13500},
  "footings": {"count": 3, "roundDiameter": 20, "squareSide": 18, "depth": 12, "bags80lb": 11},
  "ledger": {"size": "2x10", "lagScrewSpacing": 15, "throughBoltSpacing": 29},
  "materials": [{"item": "Joists", "size": "2x10 × 12 ft", "quantity": 13}, "..."],
  "units": {"length": "in", "load": "lb", "lineLoad": "plf", "area": "ft²", "pressure": "psf"}
}
```

Each item also has `decking` and `dimensions` (the key lengths in feet and inches). A span table has `lumber` and `spans` (each size at 12, 16 and 24 in: max span, what governs, max cantilever). Every item has `warnings`, `notes` (every assumption and default), a Markdown `report` and links to the drawing 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. **Loads**: 40 psf live + 10 psf dead (or your loads), as in the AWC *DCA 6* deck guide.
2. **Lumber**: NDS 2018 values for No.2 (or No.1) lumber, wet service, incised for the western species, joists as repetitive members.
3. **Joists**: the longest simple span by bending, shear and deflection L/360 under live load, capped at 18 ft. These match the DCA 6 span table.
4. **Beam**: a simple span between posts carrying half the joist span plus the cantilever; the fewest posts, then the lightest beam that works.
5. **Posts and footings**: the post load against the NDS column capacity over the post height, and the footing area = load ÷ soil bearing.
6. **Ledger and materials**: the IRC fastener table by joist span; boards with 3/16" gaps in the stock length with the least waste.

### Pricing

You pay one low price per request, at the price shown on this page: a deck, or a span table. The drawing 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 request takes milliseconds. A run through the API answers in about 10 seconds, including the cloud container starting.

### Tips and limits

- **Check with your building department.** This follows the DCA 6 method and the IRC tables, but local codes, snow loads and frost depths differ, and many places want a permit and an inspection.
- **Rectangular decks** with one beam (or two, freestanding) and posts set out evenly; multi-level decks, angled corners, stairs, hot tubs and roofs over the deck aren't laid out.
- **Ledgers** go on a solid rim joist, never on brick veneer or hung from a cantilevered floor.
- **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`, `joists`, `beam`, `posts`, `footings`, `materials` and `warnings`. A direct API call that waits for the answer:

```bash
curl -X POST "https://api.apify.com/v2/acts/jumblemog~deck-calculator/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"requests": ["14x20 deck, 5 ft high, attached, composite decking", "how far can a 2x10 joist span at 12 oc"]}'
```

`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/deck-calculator").call(run_input={
    "requests": [{"width": "24 ft", "projection": "14 ft", "height": "8 ft", "species": "DF-L", "post": "6x6"}],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["summary"])
```

### Credits

- Method: AWC *National Design Specification (NDS) for Wood Construction* 2018 and the AWC *Prescriptive Residential Wood Deck Construction Guide* (DCA 6); ledger fasteners and guards from the *International Residential Code* 2021 (R507.9.1.3, R312.1). This Actor is not affiliated with the AWC or the ICC.
- Drawings: [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 deck or span table per entry, as a line of text or an object. Deck: the size ('12x16 deck': the short side is read as the distance out from the house, or say '16 ft wide, 12 ft out'), and any of: height ('4 ft high', default 3 ft), 'attached' (default, with a ledger) or 'freestanding', cantilever ('2 ft cantilever'), joists ('2x8 joists', '16 oc'), beam ('(2) 2x10 beam', '3-ply 2x12 beam'), posts ('6x6 posts', '4 posts', 'posts 8 ft apart'), species (southern pine (default), Douglas fir, hem-fir, SPF) and grade (No.2 default, No.1), decking (5/4, 2x6, composite), soil ('2000 psf soil', default 1,500), frost depth ('42 in frost'), loads ('60 psf live', '50 psf snow'). Span table: 'span table for hem-fir joists', 'how far can a 2x8 joist span at 24 oc'. Object fields: type (deck, span), width, projection, height, cantilever, spacing, joist, beam, beamPlies, post, posts, postSpacing, species, grade, decking, attached, freestanding, soil, live, dead, snow, frost, title, text.

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

Lumber species when a request doesn't say (southern pine by default).

## `soil` (type: `integer`):

Allowable soil bearing pressure for footings when a request doesn't say (1,500 psf by default, the IRC presumptive value for clay).

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

A to-scale framing plan with the joists, beam, posts and ledger, or a bar chart of joist spans.

## Actor input object example

```json
{
  "requests": [
    "12x16 deck, 4 ft high, attached, 2x10 joists 16 oc, southern pine",
    "freestanding 14 x 20 ft deck 2 ft off the ground, hem-fir, composite decking",
    "16 ft wide, 12 ft out from the house, 8 ft high, 2 ft cantilever, douglas fir, 42 in frost depth",
    "span table for hem-fir deck joists",
    {
      "width": "20 ft",
      "projection": "10 ft",
      "height": "6 ft",
      "beam": "(3) 2x12",
      "posts": 3,
      "species": "SPF"
    }
  ],
  "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`):

Drawings (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": [
        "12x16 deck, 4 ft high, attached, 2x10 joists 16 oc, southern pine",
        "freestanding 14 x 20 ft deck 2 ft off the ground, hem-fir, composite decking",
        "16 ft wide, 12 ft out from the house, 8 ft high, 2 ft cantilever, douglas fir, 42 in frost depth",
        "span table for hem-fir deck joists",
        {
            "width": "20 ft",
            "projection": "10 ft",
            "height": "6 ft",
            "beam": "(3) 2x12",
            "posts": 3,
            "species": "SPF"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jumblemog/deck-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": [
        "12x16 deck, 4 ft high, attached, 2x10 joists 16 oc, southern pine",
        "freestanding 14 x 20 ft deck 2 ft off the ground, hem-fir, composite decking",
        "16 ft wide, 12 ft out from the house, 8 ft high, 2 ft cantilever, douglas fir, 42 in frost depth",
        "span table for hem-fir deck joists",
        {
            "width": "20 ft",
            "projection": "10 ft",
            "height": "6 ft",
            "beam": "(3) 2x12",
            "posts": 3,
            "species": "SPF",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jumblemog/deck-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": [
    "12x16 deck, 4 ft high, attached, 2x10 joists 16 oc, southern pine",
    "freestanding 14 x 20 ft deck 2 ft off the ground, hem-fir, composite decking",
    "16 ft wide, 12 ft out from the house, 8 ft high, 2 ft cantilever, douglas fir, 42 in frost depth",
    "span table for hem-fir deck joists",
    {
      "width": "20 ft",
      "projection": "10 ft",
      "height": "6 ft",
      "beam": "(3) 2x12",
      "posts": 3,
      "species": "SPF"
    }
  ]
}' |
apify call jumblemog/deck-calculator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jumblemog/deck-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/8K4dCPhtzB4grmXod/builds/77gNqLda8rJP7DTDT/openapi.json
