Sealant calculator
A 50-foot joint a quarter inch wide and a quarter inch deep holds 37.5 cubic inches of sealant, so you buy 3 standard 10.1-ounce tubes. Measure the joint, read width and depth from the schedule, and get whole cartridges. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Length
- 50
- Width
- 0.25
- Depth
- 0.25
- Tubes
- 3
- Tubes exact
- 2.057348592
- Length ft
- 50
- Width in
- 0.25
Construction joints are bought as cartridges, but they are specified as a bead: a length of gap, a width across the opening, and a depth of sealant after the backer rod. This calculator converts those three joint dimensions into the number of tubes you must purchase. Length is linear feet of joint; width and depth are inches, the units on most caulk-gun nozzles and ASTM C920 joint tables. Joint volume in cubic inches is length times twelve times width times depth; divide by the cartridge volume (a standard 10.1 US fluid-ounce tube is 10.1 times 231 divided by 128 cubic inches) and you have the exact tubes required. The published result rounds that exact figure up to whole cartridges because you cannot buy a fraction of a tube.
What the calculator returns and how joint volume becomes tubes
Sealant quantity here is the number of cartridges required to fill a rectangular construction joint of uniform cross-section, expressed as whole tubes you must buy and as the exact theoretical tubes before ceiling. A joint is a prism: length along the gap times width across the opening times depth of sealant after any backer rod.
Length is linear feet because that is how window perimeters, control joints, and tub surrounds are measured on a tape; width and depth are inches because ASTM C920 tables, nozzle cards, and most US caulk specifications quote those two dimensions in fractions of an inch. Cubic inches equal length times twelve times width times depth. A standard US 10.1 fluid-ounce cartridge holds exactly 10.1 times 231 divided by 128 cubic inches, because one US gallon is 231 cubic inches and one gallon is 128 fluid ounces.
Exact tubes equal joint cubic inches divided by that cartridge volume. The field tubes is the ceiling of that exact figure, never less than one when the joint is physically positive, because a store sells whole cartridges. Treat the result as a planning takeoff and add your own waste if the joint is irregular, the installer wants a buffer, or the product data sheet recommends extra for tooling loss.
Where sealant takeoffs fit for DIY, quotes, and software
Homeowners meet this problem when a bathroom recaulk needs a quarter-inch bead around a tub, when a bank of windows is measured in linear feet but the hardware aisle sells 10.1 ounce tubes, or when a control joint in a slab is specified as three-eighths by three-eighths and the question is how many cartridges to put in the cart.
Trade estimators use the same identity across dozens of jobs: tape the joint length, read width and depth from the sealant schedule or the backer-rod data sheet, convert to cubic inches, and divide by the cartridge the crew actually buys so the take-off and the purchase order stay aligned. Teachers and vocational trainers can pre-generate answer keys for modest joint sizes without trusting opaque mobile apps that switch units mid-form or forget that length is feet while width and depth are inches.
Developers call the same contract from scripts to seed deterministic test vectors for caulk calculators, to normalise user-entered sizes before a cart suggests a tube count, or to satisfy programming-challenge statements that demand whole cartridges rather than a hand-waved “about two tubes.” Product tools use the rewrite when a contractor types fifty feet by a quarter inch by a quarter inch and the UI must show a clean tube total before checkout.
What you can do with it
Window and door perimeter recaulk
Enter the taped linear feet around frames plus the specified joint width and depth to know how many 10.1 ounce tubes to buy before the ladder comes out.
Contractor expansion-joint takeoffs
Feed measured joint length, schedule width, sealant depth over backer rod, and the cartridge size on the product data sheet for a reproducible tube count on the bid.
FAQ
How are sealant tubes calculated from joint length, width, and depth?
Joint volume in cubic inches is length in feet times twelve times width in inches times depth in inches. Divide by the cartridge volume (default 10.1 US fluid ounces times 231/128 cubic inches). The field tubes is that quotient rounded up to a whole cartridge.
What happens if length, width, or depth is zero, negative, or missing?
Any joint dimension that is not a positive number cannot define a physical bead, so the tool never invents a tube count.
What cartridge size does this assume?
The default is a 10.1 US fluid-ounce tube, the common hardware-store caulk cartridge (about 300 ml).
Does this include waste, triangular beads, or backer-rod geometry?
No. It returns pure rectangular joint volume converted to whole tubes.
Is the sealant calculator free?
The browser tool is free and runs locally.
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/sealant \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"length":50,"width":0.25,"depth":0.25}'const res = await fetch("https://api.kit.forhosting.com/build/sealant", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"length": 50,
"width": 0.25,
"depth": 0.25
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/build/sealant",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"length": 50,
"width": 0.25,
"depth": 0.25
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/build/sealant", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"length":50,"width":0.25,"depth":0.25}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"length":50,"width":0.25,"depth":0.25}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/build/sealant", 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": 50,
"width": 0.25,
"depth": 0.25
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "build.sealant",
"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 joint dimension that is not a positive number fails with invalid_input so a zero-width form field never invents a free cartridge. The same arithmetic powers the free browser tool and the API at $0.002 per successful request.
What the calculator returns and how joint volume becomes tubes
The JSON also echoes length_ft, width_in, depth_in, joint_volume_in3, tube_volume_fl_oz, tube_volume_in3, linear_feet_per_tube, unit tags, the method tag, and a short formula string. There is no brand database, no triangular or circular bead model, no waste percent, and no shopping cart: the page answers only how many tubes the rectangular joint consumes with stable numbers suitable for worksheets, contractor quotes, and API consumers that must match goldens run after run.
How inputs are read, validated, and kept reproducible
A supplied cartridge size that is not a positive number is rejected the same way. Whole tubes use a ceiling that treats values extremely close to an integer as that integer, so a joint that fills two cartridges exactly never becomes three because of a 1e-15 remainder. Preferred fields are length for the joint run in feet, width for the opening in inches, and depth for the sealant thickness in inches, plus optional tube_fl_oz when you are not using the default 10.1 ounce cartridge. Aliases such as joint_length, linear_feet, length_ft, and l for length; joint_width, width_in, and w for width; joint_depth, depth_in, and d for depth; and tube_oz, cartridge_oz, or tube_volume for the cartridge size are accepted so spreadsheets, query strings, and typed forms can reuse the same contract without renaming columns. Every numeric field must be finite; any joint dimension that is zero, negative, missing, or non-numeric is rejected with invalid_input so a zero-depth form field cannot silently claim free sealant and a blank length cannot invent a joint. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing the joint-volume formula yourself.
Where sealant takeoffs fit for DIY, quotes, and software
On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split — free interactive exploration and a priced, identical API — matches the rest of the KIT tier-A catalog and lets you move from a Saturday sketch to an automated quoting pipeline without changing the mathematical result.
Integration use cases
Golden fixtures for caulk apps
Developers generate known-good whole-tube cases plus deliberate non-positive dimension rejections for unit tests and CI without hand-computing cubic inches.