# Concrete Mix Design & Volume Calculator (ACI 211) (`jumblemog/concrete-mix-calculator`) Actor

Concrete mix design by ACI 211.1 from plain text (water, cement, sand, stone and air per yd³ or m³, w/c, batch weights), and concrete volume for slabs, footings, columns and post holes with the bags or ready-mix to order.

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

## Concrete Mix Design & Volume Calculator (ACI 211)

**Design a concrete mix by ACI 211.1, or work out how much concrete a slab, footing, column or post holes take and how many bags to buy, from one line of text.** Ask `4000 psi driveway concrete, 3/4 in stone, 4 in slump` or `10x12 ft slab 4 in thick` and you get back:

- **The mix per cubic yard and per cubic meter**: water, cement, fly ash, sand and stone weights, the water-cement ratio, the air content, cement sacks and the ratio by weight, proportioned by the ACI 211.1 absolute volume method.
- **The right strength margin and exposure rules**: the required average strength f'cr of ACI 318 when there's no test record, entrained air and the w/c limit for freeze-thaw and de-icing salts (ACI 318 Table 19.3.2.1).
- **Batch weights** corrected for wet sand and stone, and the totals for the whole pour (`for 10 cubic yards`).
- **The concrete volume** of a slab, footing, wall, column or post holes (minus the posts), with waste, in ft³, yd³ and m³, the 40, 60 and 80 lb premix bags or 25 kg bags it takes, and the ready-mix to order.
- **A chart** and a **Markdown report** with every number.

It's made for:

- Homeowners and contractors pricing a slab, patio, footing or fence posts.
- Engineers, ready-mix and precast producers, testing labs and students who want a starting mix to trial-batch.
- AI agents, estimating tools and construction apps that need concrete quantities or proportions they can cite.

![A chart made by this Actor for a 4,000 psi air-entrained patio mix with 20% fly ash: the share of the volume taken by water, cement, fly ash, air, sand and stone, and the weights per cubic yard: 305 lb water, 635 lb cement, 159 lb fly ash, 1,037 lb sand and 1,701 lb stone](https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/concrete-mix-calculator-example.png?signature=13ewf6PqskKRJjYBbX70c)

### How to use it

1. Write **Mixes and pours**, one per entry. The form has examples.
2. Optionally change the **Default waste** added to pours (10%).
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 |
|---|---|
| `4000 psi`, `30 MPa`, `C25/30` | The specified 28-day strength f'c |
| `3/4 in stone`, `20 mm aggregate`, `#57 stone` | The nominal maximum aggregate size (default 3/4 in) |
| `4 in slump`, `100 mm slump` | The slump (default 4 in) |
| `air entrained`, `non-air`, `6% air` | Air entrainment (on by default for exterior concrete) |
| `driveway`, `de-icing salts`, `parking garage` | Severe freeze-thaw exposure (F2: w/c ≤ 0.45) |
| `patio`, `sidewalk`, `exterior` | Moderate freeze-thaw exposure (F1: w/c ≤ 0.55) |
| `footing`, `interior`, `basement floor` | No freeze-thaw exposure |
| `FM 2.6`, `rodded 105 pcf` | Sand fineness modulus and stone dry-rodded unit weight (defaults 2.70 and 100 lb/ft³) |
| `20% fly ash`, `w/c 0.45` | Fly ash share of the binder; a w/c limit |
| `sand moisture 5%`, `gravel moisture 1%` | Moisture-corrected batch weights |
| `no overdesign` | Proportion for f'c itself instead of f'cr |
| `for 10 cubic yards`, `8 m3` | Batch totals for a volume |
| `10x12 ft slab 4 in thick`, `400 sq ft 4 in thick`, `3 x 4 m slab, 100 mm thick` | A slab, patio or footing |
| `footing 20 ft long 16 in wide 8 in deep` | A footing or wall |
| `column 12 in diameter 10 ft tall x 4` | Round columns or piers |
| `12 post holes 10 in diameter 3 ft deep with 4x4 posts` | Post holes, with the posts subtracted |
| `5% waste`, `no waste` | Waste on a pour (default 10%) |

A pour with a strength (`20x24 ft garage slab 4 in thick, 4000 psi`) also gets the mix and the batch for the whole pour. The same as an object: `{"shape": "footing", "length": "40 ft", "width": "20 in", "depth": "10 in", "strength": 3000}` or `{"strengthMpa": 30, "size": 0.75, "slump": 3, "moistureFine": 5, "volumeM3": 8}`.

### Examples

- `3500 psi, non-air-entrained, 1-1/2 in stone, 3 to 4 in slump, FM 2.8, no overdesign` → the ACI 211.1 worked example: w/c 0.62, 300 lb water, 480 lb cement, 1,321 lb sand and 1,917 lb stone per yd³, 1% air.
- `4000 psi driveway concrete, 3/4 in stone, 4 in slump` → air-entrained for de-icing salts: f'cr 5,200 psi, w/c 0.38, 6% air, 794 lb cement per yd³, with a warning that ACI 318 asks for 4,500 psi in class F2.
- `30 MPa, 20 mm aggregate, 75 mm slump, sand moisture 5%, for 8 m3` → per m³ 202 kg water, 457 kg cement, 676 kg sand, 1,009 kg stone, with wet-sand batch weights and 3,656 kg of cement for 8 m³.
- `10x12 ft slab 4 in thick` → 1.63 yd³ with 10% waste: 74 bags of 80 lb mix, or 1.75 yd³ of ready-mix.
- `12 post holes 10 in diameter 3 ft deep with 4x4 posts` → 0.675 yd³: 31 bags of 80 lb mix.

### How-to examples

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

#### How to design a concrete mix by ACI 211.1

```json
{"requests": ["3500 psi, non-air-entrained, 1-1/2 in stone, 3 to 4 in slump, FM 2.8, no overdesign"]}
```

Result: The ACI 211.1 worked example: w/c 0.62, 300 lb water, 480 lb cement, 1,321 lb sand and 1,917 lb stone per yd³, 1% air.

#### How to calculate concrete for a slab

```json
{"requests": ["10x12 ft slab 4 in thick"]}
```

Result: 1.63 yd³ with 10% waste: 74 bags of 80 lb mix, or 1.75 yd³ of ready-mix.

#### How to count bags of concrete for post holes

```json
{"requests": ["12 post holes 10 in diameter 3 ft deep with 4x4 posts"]}
```

Result: 0.675 yd³: 31 bags of 80 lb mix.

#### How to let an AI agent work out a concrete mix or pour

Add this Actor to the [Apify MCP server](https://mcp.apify.com) with `https://mcp.apify.com/?tools=jumblemog/concrete-mix-calculator`. The agent writes the job the way a builder says it ("4000 psi driveway concrete, 3/4 in stone") and passes on the mix weights, volume and bag counts instead of guessing them.

### FAQ

**What can it calculate?** ACI 211.1 mix designs (water, cement, sand and stone per cubic yard or cubic metre) and pour volumes for slabs, post holes and other shapes, with premix bag counts and ready-mix yards.

**Does it work in metric?** Yes. Write `30 MPa, 20 mm aggregate, 75 mm slump` and the mix comes back in kg per m³.

**How much waste does it add?** 10% on pours unless the request or the `waste` field says otherwise.

**Can I pour straight from the mix design?** Treat it as a starting point. ACI 211.1 expects trial batches to adjust the water for slump and yield.

**How many can I run at once?** Up to 200 mixes or pours 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` | Mixes or pours, as lines of text or objects (up to 200 per run) |
| `waste` | Waste % on pours when a request doesn't say (default 10) |
| `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": "mix", "title": "4,000 psi concrete mix",
  "summary": "4,000 psi air-entrained mix, 3/4 in stone, 4 in slump: w/c 0.38, per yd³ 305 water, 794 cement, 1,035 sand, 1,701 stone (lb/yd³), 6% air.",
  "mix": {"specifiedStrength": 4000, "designStrength": 5200, "designBasis": "f'c + 1,200 psi", "airEntrained": true,
          "exposure": "severe", "maxAggregate": "3/4 in", "slump": 4, "wc": 0.384, "airPercent": 6,
          "perYd3": {"water": 305, "cement": 794.3, "sand": 1035, "coarse": 1701},
          "perM3Kg": {"water": 180.9, "cement": 471.2, "sand": 613.8, "coarse": 1009},
          "unitWeight": 142.0, "cementSacksPerYd3": 8.45, "ratioByWeight": "1 : 1.30 : 2.14 (w/c 0.38)"},
  "batch": null,
  "units": {"mass": "lb", "volume": "ft³ / yd³ / m³", "length": "in", "strength": "psi"},
  "imageUrl": "https://api.apify.com/v2/key-value-stores/.../records/001-4-000-psi-concrete-mix.png"
}
```

A pour has `shape` and `volume` (net and with-waste ft³, yd³ and m³, `bags` for 40, 60, 80 lb and 25 kg, `readyMixYd3`, `readyMixM3`, `trucks`), plus `mix` and `batch` when it has a strength. Every item has `warnings`, `notes` (every assumption and default), 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. **Strength**: without a test record, the mix is proportioned for f'cr = f'c + 1,000 psi (under 3,000), f'c + 1,200 psi (3,000-5,000) or 1.10 f'c + 700 psi (ACI 318 26.4.3).
2. **Water and air** from ACI 211.1 Table 6.3.3 for the slump band and aggregate size; air by exposure for air-entrained concrete.
3. **w/c** from Table 6.3.4(a), interpolated; the freeze-thaw limit or your limit if lower. Cement = water ÷ w/c (less the fly ash share).
4. **Stone** = Table 6.3.6 dry-rodded volume (by size and sand FM) × 27 ft³ × unit weight. **Sand** fills the rest of the 27 ft³ by absolute volume, from the specific gravities.
5. **Moisture**: wet sand and stone weigh more and carry free water, taken off the mixing water.
6. **Pours**: length × width × thickness, π/4 × diameter² × height, or the hole minus the post; bags at 0.60 ft³ per 80 lb.

### Pricing

You pay one low price per request, at the price shown on this page: a mix design, or a pour's volume (a pour with a strength counts as a mix). 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 request takes milliseconds. A run through the API answers in about 10 seconds, including the cloud container starting.

### Tips and limits

- **A mix design is a starting point.** ACI 211.1 expects trial batches to adjust the water for the slump and the yield; use your aggregates' test data for a closer first batch.
- **Normal-weight concrete** with water-reducing admixtures left out; high-strength concrete (design strengths past the table by more than 1,000 psi) needs ACI 211.4.
- **Premix bag yields** vary a little by brand; the counts round up.
- **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`, `mix`, `volume` and `warnings`. A direct API call that waits for the answer:

```bash
curl -X POST "https://api.apify.com/v2/acts/jumblemog~concrete-mix-calculator/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"requests": ["20x24 ft garage slab 4 in thick, 4000 psi", "8 post holes 12 in diameter 42 in deep with 6x6 posts"]}'
```

`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-mix-calculator").call(run_input={
    "requests": [{"strength": 4500, "size": 1, "slump": 3, "exposure": "moderate", "volumeYd3": 40}],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["summary"])
```

### Credits

- Method: ACI 211.1-91 (reapproved 2009), *Standard Practice for Selecting Proportions for Normal, Heavyweight, and Mass Concrete*, and ACI 318-19 26.4.3 and Table 19.3.2.1. This Actor is not affiliated with the American Concrete Institute.
- 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 mix or pour per entry, as a line of text or an object. Mix: the strength ('4000 psi', '30 MPa', 'C25/30') and any of: aggregate size ('3/4 in stone', '20 mm', '#57 stone'), slump ('4 in slump', '100 mm slump'), 'air entrained' or 'non-air', the use or exposure ('driveway' or 'de-icing salts' = severe, 'patio' or 'exterior' = moderate, 'footing' or 'interior' = none), sand fineness modulus ('FM 2.6'), stone dry-rodded unit weight ('rodded 100 pcf'), '6% air', '20% fly ash', 'w/c 0.45', 'sand moisture 5%', 'gravel moisture 1%', 'no overdesign', and a volume ('for 10 cubic yards', '8 m3') for batch totals. Pour: a slab, footing, wall, patio ('10x12 ft slab 4 in thick', '400 sq ft 4 in thick'), column ('12 in diameter 10 ft tall x 4') or post holes ('12 post holes 10 in diameter 3 ft deep with 4x4 posts'), with '5% waste' (10% by default); add a strength to get the mix and batch too. Object fields: type (mix, volume), strength, strengthMpa, size, slump, airEntrained, air, exposure, fm, roddedWeight, sgCement, sgFine, sgCoarse, absorptionFine, absorptionCoarse, moistureFine, moistureCoarse, flyAsh, wcMax, overdesign, volumeYd3, volumeM3, shape, length, width, depth, diameter, height, count, areaFt2, areaM2, post, waste, title, text.

## `waste` (type: `integer`):

Extra concrete added to pours when a request doesn't say (10% by default).

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

A mix's share of the volume and weights per cubic yard, or a pour's volume and the premix bags it takes.

## Actor input object example

```json
{
  "requests": [
    "4000 psi driveway concrete, 3/4 in stone, 4 in slump",
    "3500 psi, non-air-entrained, 1-1/2 in stone, 3 to 4 in slump, FM 2.8, no overdesign",
    "30 MPa, 20 mm aggregate, 75 mm slump, sand moisture 5%, for 8 m3",
    "10x12 ft slab 4 in thick",
    "12 post holes 10 in diameter 3 ft deep with 4x4 posts",
    {
      "shape": "footing",
      "length": "40 ft",
      "width": "20 in",
      "depth": "10 in",
      "strength": 3000
    }
  ],
  "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": [
        "4000 psi driveway concrete, 3/4 in stone, 4 in slump",
        "3500 psi, non-air-entrained, 1-1/2 in stone, 3 to 4 in slump, FM 2.8, no overdesign",
        "30 MPa, 20 mm aggregate, 75 mm slump, sand moisture 5%, for 8 m3",
        "10x12 ft slab 4 in thick",
        "12 post holes 10 in diameter 3 ft deep with 4x4 posts",
        {
            "shape": "footing",
            "length": "40 ft",
            "width": "20 in",
            "depth": "10 in",
            "strength": 3000
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jumblemog/concrete-mix-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": [
        "4000 psi driveway concrete, 3/4 in stone, 4 in slump",
        "3500 psi, non-air-entrained, 1-1/2 in stone, 3 to 4 in slump, FM 2.8, no overdesign",
        "30 MPa, 20 mm aggregate, 75 mm slump, sand moisture 5%, for 8 m3",
        "10x12 ft slab 4 in thick",
        "12 post holes 10 in diameter 3 ft deep with 4x4 posts",
        {
            "shape": "footing",
            "length": "40 ft",
            "width": "20 in",
            "depth": "10 in",
            "strength": 3000,
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jumblemog/concrete-mix-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": [
    "4000 psi driveway concrete, 3/4 in stone, 4 in slump",
    "3500 psi, non-air-entrained, 1-1/2 in stone, 3 to 4 in slump, FM 2.8, no overdesign",
    "30 MPa, 20 mm aggregate, 75 mm slump, sand moisture 5%, for 8 m3",
    "10x12 ft slab 4 in thick",
    "12 post holes 10 in diameter 3 ft deep with 4x4 posts",
    {
      "shape": "footing",
      "length": "40 ft",
      "width": "20 in",
      "depth": "10 in",
      "strength": 3000
    }
  ]
}' |
apify call jumblemog/concrete-mix-calculator --silent --output-dataset

```

## MCP server setup

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