Floor tile calculator
A 20 m² room laid with 0.6 m tiles and 10% waste needs 62 tiles, which is 7 boxes of 10. Enter room area, tile size, waste and tiles per box to buy whole boxes with no shortfall or overstock. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Room area
- 20
- Tile length
- 0.6
- Tile width
- 0.6
- Waste percent
- 10
- Tiles per box
- 10
- Tile area
- 0.36
- Waste factor
- 1.1
- Waste area
- 2
- Area with waste
- 22
Planning a new floor is easy to under-buy and expensive to over-buy when you guess box counts by eye. This floor tile calculator turns four practical numbers into a clear shopping list: the area of the room, the length and width of one tile, a waste percentage for cuts and breakage, and how many tiles come in each box from your supplier. It multiplies the tile edges into a footprint, inflates the room area by the waste factor, divides to get an exact tile count, then ceilings that count and the box count so you never order a fractional tile. Keep room area and tile edges in one unit system—square metres with metres, or square feet with feet—and treat the waste percent as the allowance your installer recommends for the pattern and room shape you chose.
How the tile count is worked out
The calculation starts from a simple idea: the tiles you need are the floor area divided by the area of one tile. One tile's footprint is its length times its width, so a 0.6 m by 0.6 m tile covers 0.36 m². Before dividing, the room area is raised by the waste allowance: 10% turns 20 m² into 22 m². That gives an exact count of about 61.1 tiles, which is rounded up to 62 because shops sell whole tiles. The tiles are then divided by the number per box and rounded up again, so 6.2 boxes becomes 7.
Mistakes that leave you short or overstocked
The most common error is mixing units: room area and tile edges must come from the same system, square metres with metres or square feet with feet. Another is leaving out the waste allowance, which is what covers cuts around cabinets, diagonal layouts and broken pieces; zero only fits a perfect rectangle with no cuts. Guessing box counts by eye is the third trap: it tends to under-buy, which is costly to fix halfway through the job, or to leave full boxes on the shelf. For a whole house, run each room on its own so the order matches the estimate room by room.
What you can do with it
DIY room shopping list
Measure the floor area, enter tile size and the store’s tiles-per-box, add the waste percent your installer suggests, and buy whole boxes without shortfall or bulk overstock.
Contractor room-by-room estimates
Feed each room’s area and SKU carton count into the same formula so purchase orders match the estimate and every ceil step is auditable.
FAQ
What happens if tile size is zero or negative?
Tile length and tile width must both be strictly positive; a zero or negative size would make coverage undefined or non-physical.
Which units should I use?
Any consistent pair: square metres with metres, or square feet with feet. Do not mix systems.
Why is waste percent required?
Cuts, pattern matching, and breakage almost always need extra material. Use 0 only for a perfect rectangle with no cuts; 10 is a common starting point for standard layouts.
What does it cost?
The browser tool is free and runs locally.
How much waste should I add for floor tiles?
Use the allowance your installer recommends for your pattern and room shape. It covers cuts around cabinets, diagonal layouts, broken pieces and extras from the same shade lot; entering 10 means you plan for 110% of the bare floor.
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/floor-tiles \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"room_area":20,"tile_length":0.6,"tile_width":0.6,"waste_percent":10,"tiles_per_box":10}'const res = await fetch("https://api.kit.forhosting.com/home/floor-tiles", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"room_area": 20,
"tile_length": 0.6,
"tile_width": 0.6,
"waste_percent": 10,
"tiles_per_box": 10
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/home/floor-tiles",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"room_area": 20,
"tile_length": 0.6,
"tile_width": 0.6,
"waste_percent": 10,
"tiles_per_box": 10
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/home/floor-tiles", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"room_area":20,"tile_length":0.6,"tile_width":0.6,"waste_percent":10,"tiles_per_box":10}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"room_area":20,"tile_length":0.6,"tile_width":0.6,"waste_percent":10,"tiles_per_box":10}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/home/floor-tiles", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"room_area": 20,
"tile_length": 0.6,
"tile_width": 0.6,
"waste_percent": 10,
"tiles_per_box": 10
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "home.floor_tiles",
"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 quote you generate on a phone matches the line item a script posts later. Zero or negative tile sizes are rejected with a clear invalid_input message instead of a silent divide-by-zero.
How the floor tile count and box formula works
Start from the coverage identity used on every retail floor-tile estimator: the number of tiles needed is the floor area you must cover divided by the area of one tile, then rounded up because shops sell whole tiles. Room area and tiles per box must also be positive; waste percent must be non-negative so a zero-waste perfect rectangle remains expressible without inventing negative material. Write tile_area equals tile_length times tile_width, using the same linear unit that sits under your room_area square unit so metres pair with square metres and feet pair with square feet. Next apply the waste allowance as a multiplicative factor: waste_factor equals one plus waste_percent divided by one hundred, so ten percent waste means you plan for one hundred ten percent of the bare room. Multiply room_area by that factor to obtain area_with_waste—the effective coverage target after cuts around cabinets, diagonal layouts, broken pieces, and shade-lot extras. Divide area_with_waste by tile_area to produce tiles_exact, a real number that may have a fractional part. Purchase quantity tiles_needed is the ceiling of tiles_exact, and boxes_needed is the ceiling of tiles_needed divided by tiles_per_box. The response also echoes intermediates (tile_area, waste_factor, waste_area, area_with_waste, tiles_exact, boxes_exact) and spare_area_vs_room so you can audit the math against a hand calculation on the packing slip. 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. Tile length and tile width must both be strictly positive: zero or negative size is rejected with invalid_input because a zero footprint would make the ratio undefined and a negative footprint is non-physical.
What you send and what you get back
All five fields are required. Send five finite numbers: room_area for the floor plan coverage in square units, tile_length and tile_width for one tile edge pair in matching linear units, waste_percent as the extra material percentage (for example ten for a ten percent allowance), and tiles_per_box as the package count printed on the carton. Missing fields, non-numeric strings, NaN, and Infinity fail with invalid_input and are not charged. When tile_length or tile_width is zero or negative the request fails with a message that tile size must be positive, so clients can correct dimensions before retrying instead of receiving Infinity tiles. On success the response echoes cleaned inputs, tile_area, waste_factor, waste_area, area_with_waste, tiles_exact, integer tiles_needed, cleaned tiles_per_box, boxes_exact, integer boxes_needed, spare_area_vs_room (how much area the purchased tile set covers beyond the bare room), a unit_note reminder to keep one unit system, and a short formula string for documentation. Classic checks include a twenty square-metre room with zero-point-six by zero-point-six metre tiles, ten percent waste, and ten tiles per box: tile area is zero-point-three-six, area with waste is twenty-two, tiles_exact is about sixty-one point one, tiles_needed is sixty-two, and boxes_needed is seven. Pricing for successful API calls is the published base of $0.002 per item; validation failures do not consume prepaid balance.
Where floor tile calculators show up in real work
Homeowners renovating kitchens, bathrooms, and hallways need a trustworthy box count before driving to a big-box store or placing an online order, especially when large-format porcelain has a high unit price and a long lead time. If you later need wall tile with door and window deductions, grout joint layout grids, adhesive coverage by trowel notch, or underlayment roll lengths, treat those as separate search intents and landings rather than overloading this floor tile and box calculator page. Flooring contractors build room schedules from measured floor areas and manufacturer carton sizes; a single deterministic endpoint that ceilings both tiles and boxes reduces spreadsheet drift between the estimator and the purchasing clerk. Interior designers comparing three tile SKUs for the same plan can swap only tile_length, tile_width, and tiles_per_box while holding room_area and waste_percent fixed, then rank total boxes and spare coverage without re-deriving the waste math each time. Property managers planning multi-unit refreshes feed a batch of room areas through the API and attach boxes_needed to purchase orders so overstock stays intentional rather than accidental. 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
SKU comparison for designers
Hold room area and waste fixed, swap tile length, width, and tiles per box across candidate products, and compare boxes_needed and spare coverage side by side.
Technical questions
How does this floor tile calculator work?
It multiplies tile length by width for tile_area, inflates room_area by (1 + waste_percent/100), divides for an exact tile count, then ceilings tiles and boxes so you order whole packages only.