Mortar joint volume calculator
500 bricks measuring 0.19 by 0.057 by 0.09 m laid with 10 mm joints need 0.11565 cubic metres of mortar in their bed and head joints. Enter the brick size, joint width and count, plus an optional waste margin. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Unit length
- 0.19
- Unit height
- 0.057
- Unit depth
- 0.09
- Joint width
- 0.01
- Waste percent
- 0
- Mortar per unit
- 0.0002313
- Mortar volume net
- 0.11565
- Waste volume
- 0
Ordering or mixing mortar for a brick or block wall starts with the volume that actually fills the bed and head joints, not a vague bag guess. This mortar joint volume calculator takes the face length, face height and wall-direction depth of one masonry unit, the planned joint width, and the number of units, then returns the cubic volume of mortar needed to fill those joints using a standard bed-and-head attribution per unit. You keep one linear unit system end to end—metres yield cubic metres, feet yield cubic feet—and optionally add a waste percent for site overage without inventing a separate bag field. Use the result for DIY garden walls, contractor takeoffs that already know brick size, and schedules where joint thickness is a design input rather than a pre-known mortar-per-brick figure.
Where a mortar joint volume calculator earns its keep
Homeowners building a garden wall, planter, or veneer often know the brick size printed on the pallet and the joint gap their guide recommends, but they do not yet know a catalogue mortar-per-unit figure. Feeding those dimensions into a joint volume calculator produces a cubic volume they can compare with bag yield tables or hand-mix recipes. If you already know mortar volume per brick and only need bags, use the separate mortar calculator landing that multiplies count by a pre-known per-unit volume.
If you need wall area from length and height, brick count from wall area, or grout weight for tiles, treat those as separate search intents and landings rather than overloading this mortar joint volume page.
What you can do with it
DIY garden wall from brick size and joint gap
Enter brick length, height and depth, the planned joint width and brick count, add a small waste percent, and order or mix mortar from the returned cubic volume.
Contractor takeoff with specified joint thickness
Feed each run’s unit size, joint width and unit count through the same formula so purchase volumes match the joint specification on the drawings.
FAQ
What units should I use for dimensions?
Any one linear system end to end (metres, millimetres, or feet). Volume is returned in the cube of that unit. Do not mix metres with millimetres in the same request.
What happens if the unit count is negative?
A negative brick or block count is non-physical. Zero units is allowed and returns zero mortar volume.
Does this include bag counts or mortar type?
Convert volume to bags with a bag-yield tool (or home.mortar when you already know volume per unit). Mortar type (N, S, M) is outside scope.
What does it cost?
The browser tool is free and runs locally.
Does the volume include collar joints, frogs or brick cores?
No. It covers the bed and head joints of a single-wythe wall only. Collar joints between wythes, filled frogs or cores and any conversion to bag weight are not part of the result.
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/home/mortar-joint-volume \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"unit_length":0.19,"unit_height":0.057,"unit_depth":0.09,"joint_width":0.01,"units":500}'const res = await fetch("https://api.kit.forhosting.com/home/mortar-joint-volume", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"unit_length": 0.19,
"unit_height": 0.057,
"unit_depth": 0.09,
"joint_width": 0.01,
"units": 500
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/home/mortar-joint-volume",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"unit_length": 0.19,
"unit_height": 0.057,
"unit_depth": 0.09,
"joint_width": 0.01,
"units": 500
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/home/mortar-joint-volume", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"unit_length":0.19,"unit_height":0.057,"unit_depth":0.09,"joint_width":0.01,"units":500}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"unit_length":0.19,"unit_height":0.057,"unit_depth":0.09,"joint_width":0.01,"units":500}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/home/mortar-joint-volume", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"unit_length": 0.19,
"unit_height": 0.057,
"unit_depth": 0.09,
"joint_width": 0.01,
"units": 500
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "home.mortar_joint_volume",
"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
The same pure function powers the free browser tool and the paid API, so a phone estimate matches the line item a quoting script posts later. Non-positive dimensions, a non-positive joint width, or a negative unit count fail with a clear invalid_input message instead of a silent nonsense volume.
How joint mortar volume is computed from unit size and joint width
Start from the geometry every masonry estimator uses when the unit size and joint thickness are known but a pre-tabulated mortar-per-brick figure is not. Attribute one bed joint and one head joint share to each unit. The bed joint share is the course length of the unit plus one joint width, times the unit depth into the wall, times the joint thickness. The head joint share is the unit face height times the same depth times the joint thickness. Zero units is allowed and yields zero mortar volume, which is useful for empty placeholder rows in multi-run schedules. This model covers single-wythe bed and head joints only; it does not add collar-joint volume between wythes, does not fill frogs or cores, and does not convert bagged mix mass—those are separate product intents. Adding those two contributions is algebraically identical to the compact product mortar_per_unit equals unit_depth times joint_width times the sum of unit_length, unit_height and joint_width, which counts the small joint-intersection prism only once. Multiply by the unit count to obtain mortar_volume_net. When waste_percent is greater than zero, scale the net volume by one plus waste_percent over one hundred so mortar_volume includes intentional overage for droppage, uneven beds, and cutting. When waste_percent is omitted or zero, net and total volume match. The pipeline is deterministic floating-point arithmetic with no random seeds, no wall-clock timestamps, and no network calls, so identical inputs always produce identical JSON. Unit dimensions and joint_width must be strictly positive because a zero-thickness joint or a zero-size brick is non-physical for a fill estimate. Unit count must not be negative: a negative brick or block count is rejected with invalid_input.
What you send and what you get back
Another useful check is one thousand blocks at two hundred by one hundred by four hundred millimetres with a ten millimetre joint and ten percent waste, keeping all linear inputs in millimetres so volume is in cubic millimetres, or converting everything to metres first for cubic metres. Send five required finite numbers: unit_length for the face length of one brick or block along the course, unit_height for the face height, unit_depth for the depth of the unit into the wall, joint_width for the mortar joint thickness, and units for the brick or block count. Optionally send waste_percent as a non-negative overage percent and precision as an integer from zero to fifteen for decimal places in the response. Missing required fields, non-numeric strings, NaN, and Infinity fail with invalid_input and are not charged. When any linear dimension or joint_width is zero or negative the request fails with a message that the field must be positive, so clients can correct dimensions before retrying. When units is negative the request fails with a message that the unit count cannot be negative. On success the response echoes cleaned inputs, mortar_per_unit, mortar_volume_net, waste_volume, mortar_volume, the precision used, a unit_note reminder to keep one linear system, the method label bed_and_head_joint_per_unit, and a short formula string for documentation. Classic checks include five hundred modular units at length zero point one nine, height zero point zero five seven, depth zero point zero nine and joint width zero point zero one with default waste: mortar_per_unit is zero point zero zero zero two three one three cubic units and total mortar volume is zero point one one five six five cubic units. Pricing for successful API calls is the published base of $0.002 per item; validation failures do not consume prepaid balance.
Where a mortar joint volume calculator earns its keep
Masonry and hardscape crews building purchase schedules from takeoffs that list unit size, joint specification and count need a deterministic endpoint that separates net joint fill from optional waste so overstock stays intentional and auditable. Design studios specifying ten-millimetre versus twelve-millimetre joints can re-run the same unit count with a new joint_width and see how fill volume moves without reopening a spreadsheet full of fragile cell formulas. 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.
Integration use cases
Compare joint thickness options
Hold unit size and count fixed, vary joint_width, and quantify how fill volume changes before locking the specification.
Technical questions
How does this mortar joint volume calculator work?
It attributes one bed and one head joint share per unit: mortar_per_unit = unit_depth × joint_width × (unit_length + unit_height + joint_width), then multiplies by units and optional waste percent.