Concrete footing calculator
Four pad footings of 2.4 × 0.6 × 0.3 m hold 1.728 m³ of concrete, 0.432 m³ each: length times width times depth, times the number of identical pads. Use it for deck piers or a row of column bases. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Length
- 2.4
- Width
- 0.6
- Depth
- 0.3
- Quantity
- 4
- Volume per footing
- 0.432
- Total volume
- 1.728
- Volume
- 1.728
- Plan area per footing
- 1.44
A concrete footing calculator turns four job-site numbers into the cubic volume of concrete you need for identical rectangular pad footings.
How the footing volume adds up
A rectangular pad footing is a simple box: a plan rectangle of length by width, poured to a given depth. Its volume is length times width times depth, as long as all three are in the same unit, so metres give cubic metres and feet give cubic feet. When a project repeats the same pad, for example four deck piers or a row of column bases, the single volume is multiplied by the number of pads. In the example, each pad of 2.4 by 0.6 by 0.3 m holds 0.432 m³, and four of them hold 1.728 m³. The plan area, 1.44 m² per pad and 5.76 m² in total, lets you check the take-off against the drawings.
Mistakes that throw off a footing pour
Depth means the thickness of the concrete pad, not the full depth of the hole if you will backfill above it or pour a stem separately. Mixing feet for the length with inches for the depth produces a number with no meaning, because nothing is converted for you. The result is the net volume: it adds nothing for spillage or over-dug sides and subtracts nothing for rebar, so apply your project's own percentage afterwards. And the count must be a whole number of identical pads, so pads of different sizes are worked out one size at a time.
How rectangular footing concrete volume is computed
A rectangular pad footing is modelled as a right prism: the plan is a rectangle of length by width, and the concrete thickness is depth. The volume of one footing is therefore length times width times depth, provided all three measurements use the same length unit—metres with metres, feet with feet, inches with inches. When the project uses several identical pads (for example four deck piers or a row of column bases with the same design), total concrete volume multiplies that single-footing prism by the integer count of footings.
That product is the net geometric volume of concrete; it does not add waste for spillage, over-excavation, or pump line residual, and it does not subtract rebar displacement, because those adjustments are project-specific percentages applied after the geometric take-off. Depth here means the thickness of the concrete pad you are pouring, not necessarily the full depth of the excavation if you will backfill above the pad or pour a stem separately.
All four inputs must be positive: a zero or negative length, width, or depth cannot define a physical pad, and a non-positive or fractional count cannot mean a whole number of identical footings. The calculator never converts units for you, so mixing feet of length with inches of depth silently produces a meaningless cubic product; convert everything first, then call.
FAQ
How is concrete footing volume calculated?
For identical rectangular pads: volume per footing = length × width × depth; total volume = that product × count. All three dimensions must use the same length unit; the result is in that unit cubed.
What happens if length, width, or depth is zero or negative?
Non-positive dimensions cannot define a physical footing, so the tool never invents a volume.
Does count have to be a whole number?
Yes. Count must be a positive integer (at least 1). Fractional footing counts are rejected.
Is the concrete footing calculator free?
The browser tool is free and runs locally.
Does the result include waste or bag counts?
No. It is the net geometric volume of the pads. Add your own waste percentage for spillage, over-excavation or pump residue afterwards, and convert to bags or truckloads as a separate step.
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/concrete-footing \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"length":2.4,"width":0.6,"depth":0.3,"count":4}'const res = await fetch("https://api.kit.forhosting.com/home/concrete-footing", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"length": 2.4,
"width": 0.6,
"depth": 0.3,
"count": 4
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/home/concrete-footing",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"length": 2.4,
"width": 0.6,
"depth": 0.3,
"count": 4
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/home/concrete-footing", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"length":2.4,"width":0.6,"depth":0.3,"count":4}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"length":2.4,"width":0.6,"depth":0.3,"count":4}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/home/concrete-footing", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"length": 2.4,
"width": 0.6,
"depth": 0.3,
"count": 4
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "home.concrete_footing",
"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.
Limits
max_dim | 1000000000000 |
min_dim | 1e-15 |
max_count | 1000000 |
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
Non-positive length, width, or depth—and a non-positive or non-integer count—are rejected with a clear invalid_input error instead of inventing a pour from zero or negative sizes.
How rectangular footing concrete volume is computed
On success the response echoes the rounded inputs, publishes volume_per_footing and total_volume (with volume as an alias of the total), plan_area_per_footing and plan_area_total for a quick sanity check against drawings, formula as the string V equals length times width times depth times count, message as a short English summary, and steps as an ordered array of substitution lines you can assert in tests or show to a client.
How to call the API and what comes back
Count must be a positive integer up to the published maximum; string forms of whole numbers are accepted when they match a strict finite numeric pattern, but fractional counts are rejected. Prefer sending numbers rather than pre-formatted strings when you control the client; when you must send strings, avoid currency symbols, unit suffixes, or thousand separators that would fail the finite-number pattern. Send a JSON body with four required fields: length (aliases footing_length, L, len, long), width (aliases footing_width, W, w, breadth), depth (aliases footing_depth, thickness, height, D, d, thick), and count (aliases quantity, n, qty, footings, num). Length, width, and depth must be finite positive numbers within the published absolute range so intermediate products remain finite in IEEE double precision on the Worker and in the browser. On success the response sets volume_per_footing to the rounded prism product, total_volume and volume to the product times count, plan_area fields to length times width (and times count), formula and message as described above, and steps as the substitution log. Failed validation—missing fields, non-finite numbers, non-positive dimensions, non-integer or non-positive count, or values outside absolute limits—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item and zero marginal unit price.
Practical tips, limits, and related searches
Measure length and width on the plan of the pad, and depth as the pour thickness from the bottom of the form to the top of the finished footing, using one consistent unit set. Keep dimensions inside the published absolute range so products cannot overflow into non-finite results the solver must reject. Prefer this capability when you already know the rectangular pad sizes and only need the pour volume; if your source is a continuous strip footing of constant section, you can still model segments as rectangles but must sum separate calls. If the engineer specifies a waste factor (for example five or ten percent), multiply total_volume yourself after the call; this tool intentionally returns the pure geometric volume so quotes stay transparent. When teaching or writing tests, pair a single-footing case (count equals one) with a multi-footing case that scales total_volume linearly, and include a deliberate zero depth or zero count to prove the invalid_input path. This landing targets people searching for a concrete footing calculator, footing volume, pad foundation concrete yardage, or length width depth count online; it is not a strip-footing trench estimator with variable width, not a slab-on-grade volume tool for whole floors, not a bag-of-concrete shopper that converts cubic metres to bag counts, and not a structural design check for soil bearing pressure. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when you deliberately send a zero width to verify error handling. Round-trip checks are easy: recompute length times width times depth by hand, multiply by count, and confirm the published total_volume matches within the same twelve-decimal rounding used for all numeric fields.
Integration use cases
Order ready-mix for deck pier pads
Homeowners enter pad length, width, depth, and the number of identical piers to get total_volume before calling a ready-mix plant or buying bags.
Estimator take-off for column footings
Builders feed design pad sizes and count into the API and attach volume_per_footing, total_volume, and steps to a transparent material quote.
Golden fixtures for construction apps
Developers generate known-good multi-pad volumes plus deliberate non-positive dimension rejections for unit tests and CI.
Technical questions
Does this add waste or convert to bags of premix?
No. It returns pure geometric volume only. Apply your own waste factor and unit conversion (m³ to yd³ or bag counts) after the call.