# Reinforced Concrete Calculator (ACI 318, Eurocode 2) (`jumblemog/concrete-design-calculator`) Actor

Check or design reinforced concrete beams and columns from plain text by ACI 318-19 or Eurocode 2: bending and shear strength, interaction diagrams, cracked section and the lightest bars that work.

- **URL**: https://apify.com/jumblemog/concrete-design-calculator.md
- **Developed by:** [Jumble Mog](https://apify.com/jumblemog) (community)
- **Categories:** AI, Automation, Developer tools
- **Security:** 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

## Reinforced Concrete Calculator (ACI 318, Eurocode 2)

**Check or design a reinforced concrete beam or column from one line of text.** Type `beam 12 x 24 in, 4 #8 bottom, f'c 4000 psi, Grade 60, Mu 250 kip-ft, Vu 40 kips, #3 stirrups at 10 in` or `column 400 x 400 mm, C30/37, 8 x 20 mm, NEd 3000 kN, MEd 150 kNm`. You get back:

- **Bending strength**: the neutral axis, the compression block, the strain in the tension steel, φ and φMn (ACI 318-19) or MRd (Eurocode 2), the minimum and maximum steel, and the utilization against your moment.
- **Shear strength**: Vc with ACI 318-19's size effect or VRd,c, the stirrups' share with Eurocode 2's variable strut angle, the maximum spacing, and the stirrup spacing you need when the shear is too high.
- **Columns**: the full axial-moment interaction diagram (nominal and design), the squash load, φPn,max with ties or spirals, and where your load sits on the diagram.
- **Bar design**: leave the bars out (or write `design`) and it picks the lightest arrangement that works, with the runners-up.
- **Cracked section**: Ig, the cracking moment, the modular ratio, the cracked neutral axis and Icr for deflection checks.
- **A chart**: the section to scale with its bars, compression block and neutral axis, next to the interaction diagram or the demand against capacity.

Rectangular beams and columns, T-beams and circular columns; top and bottom steel in one or more layers; US bars (#3 to #18), Canadian (10M to 55M) and metric (Ø6 to Ø40). US units (in, kip, kip·ft, psi) or metric (mm, kN, kN·m, MPa): results come back in the units you wrote.

It's made for:

- Structural engineers doing quick checks and sizing between full design runs.
- Engineering students working reinforced concrete problems by ACI or Eurocode.
- Contractors, detailers and estimators who want to know if a section and its bars work.
- AI agents that need real code checks instead of a guess.

![A 16 x 16 in column with 8 #9 bars analyzed by this Actor: the section to scale with its bars, the compression block shaded and the neutral axis, next to its interaction diagram with the nominal curve dashed, the design curve solid and the 500 kip, 120 kip-ft load inside it at 92% utilization](https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/concrete-design-calculator-example.png?signature=1J3L9P80vhiWS9zuaUtIV)

### How to use it

1. Write **Beams and columns**, one per entry. The form has examples.
2. Optionally set the default **design code** or the **Units**.
3. Click **Start**. Each member is a row in the results, with its summary, chart and report.

#### Writing a member

| You write | It means |
|---|---|
| `beam 300 x 500 mm`, `12 x 24 in` | Width x total depth |
| `T-beam, flange 1200 x 100 mm, web 300 x 600 mm` | Flange width x thickness, web width x total depth |
| `column 16 x 16 in`, `circular column 500 mm diameter` | A column; bars go round the perimeter |
| `4 #8 bottom, 2 #5 top`, `4 H20`, `6-25M`, `8 x 25 mm` | Bars (bottom for beams unless you say top) |
| `design`, or no bars | Pick the lightest bars that work (`using #8 bars` fixes the size) |
| `f'c 4000 psi`, `fck 30`, `C30/37` | Concrete strength |
| `Grade 60`, `fy 420 MPa`, `B500` | Bar yield strength |
| `cover 2 in`, `50 mm cover` | Clear cover to the stirrups (default 1.5 in or 40 mm) |
| `#3 stirrups at 8 in`, `H10 links @ 150 mm`, `4-leg` | Stirrups or ties |
| `Mu 250 kip-ft`, `MEd 150 kNm` | Factored moment |
| `Vu 40 kips`, `VEd 120 kN` | Factored shear |
| `Pu 500 kips`, `NEd 2000 kN`, `tension 50 kN` | Factored axial load |
| `spiral`, `lightweight`, `hogging` | Spiral column, λ = 0.75, tension on top |
| `EC2`, `Eurocode`, `ACI` | The code (C30/37, B500, MEd or VEd also mean Eurocode 2) |

Or send an object: `{"type": "column", "shape": "circle", "d": "500 mm", "bars": "8 x 25 mm", "fc": "35 MPa", "pu": "3000 kN", "mu": "200 kNm", "spiral": true}`. Fields: type, code, shape, b, h, d, bf, hf, cover, fc, fy, fyt, bars, bottom, top, barSize, stirrups, spacing, legs, spiral, mu, vu, pu, lambda, negative, design, alphaCC, gammaC, gammaS, units, title, text.

### Examples

- `beam 10 x 22.5 in, 3 #8 bottom, f'c 4000 psi, Grade 60, Mu 180 kip-ft, Vu 30 kips, #3 stirrups at 8 in` → φMn 192.3 kip·ft (φ 0.9, εt 0.0093): OK (94%); φVn 44 kips: OK (68%).
- `beam 300 x 500 mm, C30/37, 4 H20 bottom, MEd 200 kNm` → MRd 215.5 kN·m (x/d 0.259): OK (93%).
- `design a beam 300 x 600 mm, C30/37, for MEd 250 kNm` → Use 6 Ø16 bottom: MRd 257.8 kN·m (97%).
- `column 16 x 16 in, 8 #9, Pu 500 kips, Mu 120 kip-ft` → φPn,max 688 kips, P0 1,323 kips; the load is at 92% of the interaction diagram.
- `design beam 14 x 28 in for Mu 400 kip-ft, Vu 60 kips` → 5 #8 bottom, and the shear needs 2-leg #3 stirrups at 6 in.

### 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 reinforced concrete beam (ACI 318)

```json
{"members": ["beam 10 x 22.5 in, 3 #8 bottom, f'c 4000 psi, Grade 60, Mu 180 kip-ft, Vu 30 kips, #3 stirrups at 8 in"]}
```

Result: φMn 192.3 kip·ft (φ 0.9, εt 0.0093): OK at 94%; φVn 44 kips: OK at 68%.

#### How to design the reinforcement for a concrete beam (Eurocode 2)

```json
{"members": ["design a beam 300 x 600 mm, C30/37, for MEd 250 kNm"]}
```

Result: use 6 Ø16 bottom, for MRd 257.8 kN·m (97%). In US units, `design beam 14 x 28 in for Mu 400 kip-ft, Vu 60 kips` gives 5 #8 bottom and 2-leg #3 stirrups at 6 in.

#### How to check a concrete column with an interaction diagram

```json
{"members": ["column 16 x 16 in, 8 #9, Pu 500 kips, Mu 120 kip-ft"]}
```

Result: φPn,max 688 kips and P0 1,323 kips; the load is at 92% of the interaction diagram, which is drawn in the chart.

#### How to let an AI agent check concrete members

Add this Actor to the [Apify MCP server](https://mcp.apify.com) with `https://mcp.apify.com/?tools=jumblemog/concrete-design-calculator`. The agent passes the beam or column as one line and answers with the capacities and utilizations from ACI 318-19 or Eurocode 2, with the intermediate values to check by hand.

### FAQ

**Which codes does it follow?** ACI 318-19 in US units and Eurocode 2 in metric. The code is picked from the units and names you use (`#8`, `Grade 60` or `C30/37`, `H20`), or set `code`.

**Can it design the steel for me?** Yes. Start the line with `design` and give the moment and shear, and it picks the bars and stirrups.

**Does it check shear?** Yes: Vc with ACI 318-19's size effect or VRd,c, the stirrups' share and the spacing you need.

**Is it a stamped design?** No. The results are engineering estimates for the stated assumptions; a licensed engineer should check any design against the code.

### Input

| Field | What it is |
|---|---|
| `members` | The beams and columns, as lines of text or objects (up to 200 per run) |
| `code` | Default code for requests that don't show one: `aci` (ACI 318-19) or `ec2` (Eurocode 2) |
| `units` | For numbers without a unit: `mm` or `in` |
| `charts` | Draw a chart for each member (default on) |

### Output

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

```json
{
  "request": 1, "status": "ok", "type": "beam", "code": "ACI 318-19", "title": "Beam 12 x 24 in, 4 #8 bottom",
  "summary": "φMn 274.5 kip·ft (φ 0.9, εt 0.0089) for Mu 250: OK (91%); φVn 46.03 kip for Vu 40: OK (87%).",
  "flexure": {"c": 5.4671, "a": 4.6471, "epsT": 0.008866, "phi": 0.9, "mn": 304.96, "phiMn": 274.47,
              "section": "tension-controlled", "asMin": 0.865, "mu": 250.0, "utilization": 0.9109},
  "shear": {"vc": 32.824, "vs": 28.545, "phiVn": 46.027, "vcMethod": "simplified (Av ≥ Av,min)", "sMax": 10.812,
            "stirrups": "2-leg #3 at 10 in", "vu": 40.0, "utilization": 0.8691},
  "imageUrl": "https://api.apify.com/v2/key-value-stores/.../records/001-Beam-12-x-24-in-4-8-bottom.png"
}
```

Items also have `units`, `section`, `materials`, `reinforcement` (bars, steel area and ratio, effective depth), `cracking` (beams), `column` (columns: P0, the design axial limit, the check and the interaction points) and `design` (when it picked the bars). Every item has `summary`, `warnings`, `notes` (the method and assumptions), a Markdown `report` and links to the chart and report. A member that can't be computed has `"status": "failed"` and the reason in `error`, and isn't billed.

### How it works

1. **Reading**: each line is read for the shape and size, bars, materials, stirrups and loads; numbers carry their units, and the code is taken from what you wrote.
2. **Bars** are placed inside the cover and stirrups with at least the minimum clear spacing, in more layers when they don't fit in one.
3. **Strength**: strain compatibility with a uniform compression block (ACI: 0.85f'c over β1·c, εcu 0.003; Eurocode 2: η·fcd over λ·x, εcu3) and elastic-perfectly plastic bars. The neutral axis is found for each axial load, and bars inside the block subtract the concrete they displace.
4. **ACI factors**: φ from the tension steel's strain (Table 21.2.2), φPn,max = 0.80φP0 with ties or 0.85φP0 with spirals; Eurocode 2 uses γc 1.5, γs 1.15 and αcc 1.0 (all changeable), and the minimum eccentricity for columns.
5. **Shear**: ACI 318-19 22.5 (with the size effect when stirrups are below the minimum) or Eurocode 2 6.2 with cot θ from 2.5 down to 1.
6. **Design** tries each bar size with the fewest bars that work and keeps the lightest, honouring εt ≥ 0.004 (ACI), x/d ≤ 0.45 (EC2) and the column steel limits.

Results are engineering estimates for the stated assumptions; a licensed engineer should check any design against the code.

### Pricing

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

### Speed

A member takes well under a second, plus the chart. A run through the API answers in about 10 to 20 seconds, including the cloud container starting.

### Tips and limits

- **Short columns** only: slenderness (ACI 6.6.4 moment magnification, EC2 5.8 second-order effects) isn't included; bending is about one axis (no biaxial bending).
- **Bending axis**: compression is at the top for positive moments; write `hogging` or `negative moment` for tension on top.
- **Not covered**: deflection limits and crack widths (the cracked properties are given for your own check), torsion, development lengths and laps, prestressing, and seismic detailing.
- **Shear in columns** includes the axial load's benefit; columns get ties as their stirrups.
- **Limits**: 200 members 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 `members` as plain text and read `summary`, `flexure`, `shear`, `column` and `warnings`. A direct API call that waits for the answer:

```bash
curl -X POST "https://api.apify.com/v2/acts/jumblemog~concrete-design-calculator/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"members": ["beam 12 x 24 in, 4 #8 bottom, f'\''c 4000 psi, Grade 60, Mu 250 kip-ft, Vu 40 kips"]}'
```

`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/concrete-design-calculator").call(run_input={
    "members": [{"type": "column", "b": "400 mm", "h": "400 mm", "code": "ec2", "fc": "30 MPa", "pu": "2000 kN",
                 "mu": "150 kNm", "design": True}],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["summary"])
```

### Credits

- Geometry: [Shapely](https://github.com/shapely/shapely) (BSD-3-Clause).
- 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).
- Methods: ACI 318-19, *Building Code Requirements for Structural Concrete*; EN 1992-1-1:2004, *Eurocode 2: Design of concrete structures*; Wight and MacGregor, *Reinforced Concrete: Mechanics and Design*.

# Actor input Schema

## `members` (type: `array`):

One beam or column per entry, as a line of text or an object. Give the size ('beam 300 x 500 mm', '12 x 24 in', 'T-beam, flange 1200 x 100 mm, web 300 x 600 mm', 'circular column 500 mm diameter'), the bars ('4 #8 bottom, 2 #5 top', '4 H20', '8 x 25 mm', '6-25M'; leave them out or write 'design' to get the lightest bars), the materials (f'c 4000 psi or C30/37; Grade 60 or B500 or fy 420 MPa), the cover (default 1.5 in or 40 mm), stirrups ('#3 stirrups at 8 in', 'H10 links @ 150 mm', '4-leg') and the loads ('Mu 200 kip-ft' or 'MEd 150 kNm', 'Vu 40 kips' or 'VEd 120 kN', 'Pu 500 kips' or 'NEd 2000 kN', 'tension 50 kN'). Eurocode 2 is used when the text says EC2 or uses C30/37, B500, MEd or VEd; ACI 318-19 otherwise. Also: 'spiral', 'lightweight', 'hogging' (tension on top). Object fields: type (beam or column), code (aci or ec2), shape (rectangle, tee, circle), b, h, d (circle diameter), bf, hf, cover, fc, fy, fyt, bars, bottom, top, barSize, stirrups, spacing, legs, spiral, mu, vu, pu, lambda, negative, design, alphaCC, gammaC, gammaS, units, title, text.

## `code` (type: `string`):

For requests that don't show which code they use.

## `units` (type: `string`):

For numbers written without a unit. Inches, kips, psi or #-sized bars in the text switch to US units on their own.

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

The section to scale with its bars, compression block and neutral axis, next to the interaction diagram (columns) or demand against capacity (beams).

## Actor input object example

```json
{
  "members": [
    "beam 12 x 24 in, 4 #8 bottom, f'c 4000 psi, Grade 60, Mu 250 kip-ft, Vu 40 kips, #3 stirrups at 10 in",
    "beam 300 x 500 mm, C30/37, B500, 4 H20 bottom, MEd 200 kNm, VEd 120 kN, H8 links at 200 mm",
    "column 16 x 16 in, 8 #9, Pu 500 kips, Mu 120 kip-ft",
    "design a beam 300 x 600 mm, C30/37, for MEd 250 kNm",
    {
      "type": "column",
      "shape": "circle",
      "d": "500 mm",
      "bars": "8 x 25 mm",
      "fc": "35 MPa",
      "fy": "420 MPa",
      "pu": "3000 kN",
      "mu": "200 kNm",
      "spiral": true
    }
  ],
  "code": "aci",
  "units": "mm",
  "charts": true
}
```

# Actor output Schema

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

One row per member: 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 = {
    "members": [
        "beam 12 x 24 in, 4 #8 bottom, f'c 4000 psi, Grade 60, Mu 250 kip-ft, Vu 40 kips, #3 stirrups at 10 in",
        "beam 300 x 500 mm, C30/37, B500, 4 H20 bottom, MEd 200 kNm, VEd 120 kN, H8 links at 200 mm",
        "column 16 x 16 in, 8 #9, Pu 500 kips, Mu 120 kip-ft",
        "design a beam 300 x 600 mm, C30/37, for MEd 250 kNm",
        {
            "type": "column",
            "shape": "circle",
            "d": "500 mm",
            "bars": "8 x 25 mm",
            "fc": "35 MPa",
            "fy": "420 MPa",
            "pu": "3000 kN",
            "mu": "200 kNm",
            "spiral": true
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jumblemog/concrete-design-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 = { "members": [
        "beam 12 x 24 in, 4 #8 bottom, f'c 4000 psi, Grade 60, Mu 250 kip-ft, Vu 40 kips, #3 stirrups at 10 in",
        "beam 300 x 500 mm, C30/37, B500, 4 H20 bottom, MEd 200 kNm, VEd 120 kN, H8 links at 200 mm",
        "column 16 x 16 in, 8 #9, Pu 500 kips, Mu 120 kip-ft",
        "design a beam 300 x 600 mm, C30/37, for MEd 250 kNm",
        {
            "type": "column",
            "shape": "circle",
            "d": "500 mm",
            "bars": "8 x 25 mm",
            "fc": "35 MPa",
            "fy": "420 MPa",
            "pu": "3000 kN",
            "mu": "200 kNm",
            "spiral": True,
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jumblemog/concrete-design-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 '{
  "members": [
    "beam 12 x 24 in, 4 #8 bottom, f'\''c 4000 psi, Grade 60, Mu 250 kip-ft, Vu 40 kips, #3 stirrups at 10 in",
    "beam 300 x 500 mm, C30/37, B500, 4 H20 bottom, MEd 200 kNm, VEd 120 kN, H8 links at 200 mm",
    "column 16 x 16 in, 8 #9, Pu 500 kips, Mu 120 kip-ft",
    "design a beam 300 x 600 mm, C30/37, for MEd 250 kNm",
    {
      "type": "column",
      "shape": "circle",
      "d": "500 mm",
      "bars": "8 x 25 mm",
      "fc": "35 MPa",
      "fy": "420 MPa",
      "pu": "3000 kN",
      "mu": "200 kNm",
      "spiral": true
    }
  ]
}' |
apify call jumblemog/concrete-design-calculator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jumblemog/concrete-design-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/TrL9E1jV8DxgiZlYs/builds/reGfPJEFP9wclyrxX/openapi.json