Concrete block fill calculator
One hundred 16 by 8 by 8 inch two-core blocks take about 1.226 cubic yards of grout. Enter your block count and size to order fill for a grouted wall, pilaster or fence column by volume, not by guess. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Blocks
- 100
- Length
- 16
- Width
- 8
- Height
- 8
- Cores
- 2
- Shell thickness
- 1.25
- Web thickness
- 1
- Core length
- 6.5
- Core width
- 5.5
Hollow concrete masonry units — CMU, cinder blocks, and similar hollow blocks — are laid with empty cores that later take grout or concrete for compressive strength, rebar embedment, and code-required fully grouted walls. Ordering the right ready-mix or bagged fill starts from a volume in cubic yards, not from a block count alone. This concrete block fill calculator takes the number of blocks, each unit’s length, width, and height in inches, and how many cores run through each block, then returns the grout fill volume in cubic yards plus the matching cubic-foot and cubic-inch totals. Face-shell and web thicknesses follow an ASTM C90-inspired scale from an 8-by-16-inch reference so the cores stay rectangular and physically inside the block.
How hollow-block fill volume is computed in cubic yards
Start from the rectangular-core model used on grouted CMU and cinder-block walls: each hollow block is a rectangular prism of length, width, and height in inches, with a fixed number of through-cores that later take grout or concrete. Face shells sit on the two long faces in the wall-thickness direction. Cubic yards equal that cubic-inch total divided by 46,656, because a cubic yard is 36 inches on a side.
Cubic feet equal the same total divided by 1,728. A classic check is one hundred 16-by-8-by-8-inch two-core stretchers: shells 1.25 inches, webs 1.00 inch, cores 6.5 by 5.5 by 8 inches, 572 cubic inches per block, and about 1.226 cubic yards for the hundred. The path is deterministic floating-point arithmetic with no random seeds, no wall-clock timestamps, and no network.
What you send and what you get back
Send five required finite positive numbers. blocks is how many hollow units you will grout; fractional counts are allowed when a course is incomplete. length, width, and height are the outer block dimensions in inches, matching the US CMU convention where a common stretcher is 16 by 8 by 8. cores is how many through-voids each block has; two-core stretchers use 2 and some units use 3. Example: one hundred blocks, length 16, width 8, height 8, cores 2 is the textbook 8-inch stretcher takeoff.
Zero blocks, a negative width, or cores large enough that the webs eat the length all fail closed. Wire the free browser form for a jobsite check, then call the identical contract from scripts for multi-wall schedules without reimplementing the core geometry.
Where a concrete block fill calculator earns its keep
Masons and general contractors reach for a concrete block fill calculator when a load-bearing CMU wall, pilaster, or fence column must be fully grouted and the ready-mix desk asks for cubic yards, not a block count. Knowing how many units sit on the wall, the nominal inch size, and whether the block is two-core or three-core yields a grout volume you can compare against a truck minimum and a bagged-grout backup without opening a spreadsheet of void percentages.
Residential remodelers filling cinder-block basement walls or garden columns use the same numbers to size a small mixer and avoid a short load on a Saturday. Structural and inspection notes that call for grouted cores around vertical rebar need a volume that is reproducible from the same five fields the inspector can read off the submittal, not a black-box app that hides shell assumptions.
Estimating desks that already use a block-count landing for “how many blocks do I need” still need a second, distinct fill volume for the grout line item; those are different search intents and should not share a page. Trade-school modules on masonry takeoff can pin the classic one-hundred 8-inch stretcher case in tests because the arithmetic is deterministic. If you only need to count blocks from wall area, that is a different calculator.
What you can do with it
Fully grouted CMU wall takeoff
Enter block count, 16×8×8 inch stretchers, and two cores to get cubic yards of grout before you call the ready-mix plant.
Cinder-block column or pilaster fill
Size the mixer for a garden column or fence pier from how many hollow units you stacked and how many cores each unit has.
FAQ
How does this concrete block fill calculator work?
It derives rectangular core size from block length, width, and height in inches plus core count, using ASTM C90-inspired face-shell and web thicknesses, then multiplies by block count and converts cubic inches to cubic yards (÷ 46,656).
What units are the block dimensions in?
Inches, the usual US CMU / cinder-block convention (a common stretcher is 16 × 8 × 8).
How are core sizes estimated if I only know how many cores the block has?
Face shells scale from 1.25 in on an 8 in unit; webs scale from 1.00 in on a 16 in stretcher. Each core is (length − (cores+1)×web) / cores by (width − 2×shell) by height.
What does it cost?
The browser tool is free and runs locally.
How much grout do 100 standard 8 inch blocks need?
About 1.226 cubic yards. Each 16 by 8 by 8 inch two-core block has cores of 6.5 by 5.5 by 8 inches, 572 cubic inches per block, so one hundred blocks hold 57,200 cubic inches of fill.
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/build/concrete-block-fill \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"blocks":100,"length":16,"width":8,"height":8,"cores":2}'const res = await fetch("https://api.kit.forhosting.com/build/concrete-block-fill", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"blocks": 100,
"length": 16,
"width": 8,
"height": 8,
"cores": 2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/build/concrete-block-fill",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"blocks": 100,
"length": 16,
"width": 8,
"height": 8,
"cores": 2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/build/concrete-block-fill", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"blocks":100,"length":16,"width":8,"height":8,"cores":2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"blocks":100,"length":16,"width":8,"height":8,"cores":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/build/concrete-block-fill", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"blocks": 100,
"length": 16,
"width": 8,
"height": 8,
"cores": 2
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "build.concrete_block_fill",
"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
Any input that is not a finite positive number fails with invalid_input instead of a silent nonsense yardage. The same pure function powers the free browser tool and the paid API, so a jobsite phone check matches the line a purchasing script posts later.
How hollow-block fill volume is computed in cubic yards
Their thickness scales from the ASTM C90-inspired 1.25-inch shell on an 8-inch-wide unit, so shell_thickness equals 1.25 times width divided by 8. Webs sit across the length: there are cores plus one webs, meaning two ends plus the dividers between cavities, and web_thickness equals 1.00 times length divided by 16, matching a one-inch web on a 16-inch stretcher. Each core is then a rectangular void: core_width equals width minus two shells, core_length equals length minus cores-plus-one times web, all divided by cores, and core_height equals the block height because cores run the full course. Volume per core is core_length times core_width times core_height in cubic inches; multiply by cores for one block and by the block count for the job. Any input that is not a finite positive number is rejected with invalid_input, and a core count that would make core_length or core_width non-positive is rejected because those cores would not fit inside the block.
What you send and what you get back
Missing fields, empty strings, non-numeric text, NaN, Infinity, zero, and negative values fail with invalid_input naming the field and are not charged — the contract is that every input must be a positive number. On success the JSON echoes the cleaned inputs, the derived shell_thickness and web_thickness, the rectangular core_length, core_width, and core_height, volume_per_core_in3 and volume_per_block_in3, then fill_volume_in3, fill_volume_ft3, and the primary fill_volume_yd3 in cubic yards, plus a unit_note, a formula string, and method rectangular_cmu_core_fill_yd3 so logs can document the algorithm. API pricing is the published base of $0.002 per successful item; validation failures do not consume prepaid balance.
Where a concrete block fill calculator earns its keep
Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance. Keep requests small, pin fill_volume_yd3 in tests, and you get reproducible yardage for quotes, purchase orders, and edge workers without standing up a CAD kernel of your own.
Integration use cases
Rebar-grouted basement or retaining wall
Convert a hollow-block schedule into fill_volume_yd3 so the grout line item matches the cores that receive vertical steel.
Technical questions
What happens if a count or dimension is zero or negative?
The request fails with invalid_input. blocks, length, width, height, and cores must all be finite positive numbers; a non-positive value would make fill volume non-physical or zero.