Sandbox calculator
An 8 by 4 foot sandbox filled 0.5 ft deep holds 16 cubic feet of sand, which is 32 bags of half a cubic foot each. Enter the inside length, width and depth in feet and get whole bags to buy. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Length
- 8
- Width
- 4
- Depth
- 0.5
- Bag cu ft
- 0.5
- Volume cu ft
- 16
- Bags
- 32
- Unit length
- ft
A backyard sandbox is a rectangular box that needs a known volume of sand, not a guess from the last hardware-store trip. This sandbox calculator multiplies interior length, interior width, and fill depth—all in feet—into cubic feet, then converts that volume into whole bags using a default bag size of half a cubic foot, the usual packed volume of a fifty-pound bag of dry play sand. Override the bag volume when your product label lists a different cubic-foot yield.
Measure the sandbox interior in feet and choose a safe fill depth
To size a rectangular sandbox fill you need three interior dimensions in the same linear unit, and this calculator uses feet so the product is already cubic feet. Measure length along the long interior wall, inside the timber or plastic, because benches, thick beams, and rounded corners shrink the free footprint that actually holds sand. Measure width the same way on the short interior wall.
Measure depth as the finished play depth you want after raking, converted to feet: six inches is 0.5 feet, four inches is about 0.333 feet, eight inches is about 0.667 feet. Typical residential boxes sit in that four-to-eight-inch band; deeper fills waste product and make digging harder for small arms. Send length, width, and depth as strictly positive finite numbers.
Irregular or L-shaped boxes can still use this tool: sum several rectangular zones in your own app, or pass an equivalent rectangle whose product matches the free fill area times depth. Re-measure after installing seats so the shopping list matches the box the children will actually use.
Cubic feet, bag volume, and how to read the response
Volume in cubic feet is length times width times depth when all three are in feet. Retail sand is sold in bags whose packed volume is typically about half a cubic foot for a common fifty-pound bag of dry play sand, so bag count is the ceiling of cubic feet divided by bag cubic feet.
The engine never returns a fractional bag: it ceilings the volume ratio, with a tiny epsilon so an exact multiple such as sixteen cubic feet over 0.5 does not float past a whole number of bags. Compaction, liner displacement, and a site waste factor stay outside this geometric result if your practice adds a small percentage after the calculator. Generic construction sand tools that start from plan area and bulk density remain separate products; this landing targets a sandbox sized in feet and paid for in bags.
What you can do with it
Backyard sandbox install or top-up
Parents enter interior length, width and fill depth in feet to know how many bags of sand to buy before a weekend install or spring top-up.
School and daycare playground maintenance
Facilities staff convert measured box footprints and target fill depths into cubic feet and whole-bag counts for seasonal sandbox replacement.
FAQ
How does the sandbox calculator work?
Volume in cubic feet is length × width × depth, with all three dimensions in feet.
What units should I use for length, width and depth?
All three are in feet. The response reports cubic feet and whole bags.
What if length, width or depth is zero or negative?
Length, width and depth must all be strictly positive; non-positive dimensions cannot define a fill and are not charged.
How large is one bag of sand in this calculator?
The default packed volume is 0.5 cubic feet per bag, typical for a fifty-pound bag of dry play sand.
Is the sandbox calculator free?
The browser tool runs free on your device.
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/sandbox \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"length":8,"width":4,"depth":0.5}'const res = await fetch("https://api.kit.forhosting.com/home/sandbox", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"length": 8,
"width": 4,
"depth": 0.5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/home/sandbox",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"length": 8,
"width": 4,
"depth": 0.5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/home/sandbox", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"length":8,"width":4,"depth":0.5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"length":8,"width":4,"depth":0.5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/home/sandbox", 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": 8,
"width": 4,
"depth": 0.5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "home.sandbox",
"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
Zero, negative, or non-numeric dimensions fail with invalid_input and are never billed, so a tape-measure typo cannot become a fake shopping list. Successful API items cost $0.002; validation failures do not consume balance.
Measure the sandbox interior in feet and choose a safe fill depth
Aliases L and len map to length, W maps to width, and d, height, and h map to depth so spreadsheets and typed forms can reuse familiar column names. Zero, negative, missing, empty, or non-finite values raise invalid_input naming the field and are not charged, because a non-positive dimension cannot define a physical volume. Extremely small or huge values outside the published stability range are also rejected so floating-point results stay meaningful on a Worker isolate.
Cubic feet, bag volume, and how to read the response
That is the geometric fill before compaction, waste, or over-dig, and it is the primary result this endpoint exists to report. Optional bag_cu_ft defaults to 0.5 and accepts aliases bag_volume and bag_size; override it when the bag you will buy lists a different yield, such as a larger bulk sack or a smaller craft bag. The response echoes length, width, depth, and bag_cu_ft; returns volume_cu_ft and bags as the quantities you shop with; labels unit_length, unit_width, and unit_depth as ft, unit_volume as cu_ft, and unit_bags as bags; and sets method to sandbox_volume_bags with a short formula string so downstream code can branch without sniffing product types. Identical inputs always produce identical JSON because the path is pure arithmetic with no network, random seed, or wall clock.
API usage, pricing, playground workflows, and practical limits
Call the free in-browser sandbox calculator for weekend builds, HOA playgrounds, school PTO boxes, and classroom volume demos without opening a spreadsheet. Remember that packed bag volume can differ from the textbook half-cubic-foot default—prefer the product sheet for the sand you will buy, and re-measure interior length and width after installing seats or rounded corners. Send a JSON body with required length, width, and depth, plus optional bag_cu_ft when the default half-cubic-foot bag does not match your product. Use the prepaid API when a renovation app, playground planner, daycare facilities tool, or property-management pipeline needs a stable contract under KIT balance at $0.002 per successful item; validation failures never consume balance after the engine rejects the request. Pair this endpoint with unit converters when drawings use metres while bag labels use cubic feet, or with lumber and liner helpers when the sand layer is only one line in a larger bill of materials. Authors shipping SDKs can map bags and volume_cu_ft straight into order lines while showing formula and method as explanatory detail for the buyer or the site supervisor reviewing the ticket. Keep metric bag sizes and non-foot drawings out of scope unless you convert outside the API; this contract is feet and cubic feet for the common North American DIY and facilities search intent.
Integration use cases
Renovation apps and material lists
Mobile and web apps recompute sand volume and bags as users change sandbox size or depth, using the same deterministic API contract for quotes.