Quilt block count calculator
A 60 by 80 quilt with 12-inch blocks takes 30 blocks, 5 across and 6 down, covering 60 by 72 and leaving 8 for borders. No partial blocks are ever planned into the grid. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Quilt width
- 60
- Quilt length
- 80
- Block width
- 12
- Block height
- 12
- Columns
- 5
- Rows
- 6
- Total blocks
- 30
- Block count
- 30
A quilt block count calculator turns finished quilt dimensions and finished block size into the three numbers every pieced top needs before you cut fabric: how many columns fit across the width, how many rows fit along the length, and the total finished blocks that layout requires. Enter the target finished quilt width and length, then the finished block width and height in the same units—inches or centimetres—or a single square block size when both faces match. The tool floor-divides each quilt span by the matching block face so you never plan a partial block into the grid, multiplies rows by columns for the purchase count, and reports covered size plus leftover border space you can absorb with borders, sashing, or a resized block. Throw-size lap quilts, twin tops, and sampler grids all share the same arithmetic.
What finished size and block layout mean for a quilt top
Quilters plan in finished measurements: the size of the top after seams are sewn, not the cut size that includes seam allowances. This calculator therefore asks for finished quilt width and finished quilt length, plus finished block width and finished block height in matching linear units. Columns equal the greatest whole number of block widths that fit into the quilt width—floor of quilt width divided by block width.
Rows equal the greatest whole number of block heights that fit into the quilt length—floor of quilt length divided by block height. Total blocks equal columns times rows, which is the count of completed pieced units you need for that rectangular grid before borders or binding. When the division is exact, leftover width and leftover length are zero and the covered rectangle matches the target.
When a little space remains, leftovers report how many units of width or length sit outside the pure block grid so you can add a border strip, grow sashing, or nudge block size until the fit is clean. Rectangular blocks are fully supported when width and height differ, which covers brick layouts and rail-fence style units once you treat each finished unit as one cell.
Teachers and shop classes care about the rejection path as much as the happy path: a zero block width is not a real face size, and a twelve-inch block cannot fit a ten-inch mini quilt without folding the design—those cases fail clearly instead of returning zero blocks under a success status.
Practical planning tips, units, borders, and related searches
Always use finished measurements after you decide seam allowance and press method; cut sizes that still include quarter-inch seams will overstate how many blocks fit. Prefer one unit system for the whole request—if you think in inches, keep inches for quilt and block faces; if you design in centimetres, stay in centimetres. When leftovers are small, many makers absorb them into outer borders rather than resizing every block; when leftovers are large, increase block size or add another row or column if the overall top can grow.
Sashing between blocks is not modelled as a separate field: if your design has sashing, fold the finished sashing share into an effective cell size or shrink the pure block faces and treat sashing as border leftover after the grid. Prefer this capability when you already know finished quilt and block sizes and only need grid counts; if you need yardage from those counts, multiply total blocks by fabric per block in a separate step.
What you can do with it
Lap and throw quilt planning
Home quilters enter target finished size and square block size to learn how many blocks to piece and whether a border will absorb leftover length.
FAQ
How do you calculate how many quilt blocks fit a size?
Divide finished quilt width by finished block width and floor to whole columns; divide quilt length by block height and floor to whole rows; multiply columns by rows for total blocks. This tool also reports leftover border space.
Should I enter finished or cut block sizes?
Enter finished sizes after seams. Cut sizes include seam allowance and would overstate how many blocks fit the target top.
What if the block is larger than the quilt?
A finished block face cannot exceed the matching quilt span, and the layout must fit at least one full row and column.
How many 12-inch blocks do I need for a 60 by 80 quilt?
You need 30 finished blocks in a layout of 5 columns by 6 rows. They cover 60 by 72, so 8 of the length is left over and can become a border or sashing.
What do I do with the leftover space after the blocks?
Absorb it with borders, sashing or a resized block. The count only uses whole blocks that fit, so the leftover width and length tell you exactly how much the rest of the design has to fill.
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/hobby/craft-quilt-block-count \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"quilt_width":60,"quilt_length":80,"block_width":12,"block_height":12}'const res = await fetch("https://api.kit.forhosting.com/hobby/craft-quilt-block-count", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"quilt_width": 60,
"quilt_length": 80,
"block_width": 12,
"block_height": 12
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/hobby/craft-quilt-block-count",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"quilt_width": 60,
"quilt_length": 80,
"block_width": 12,
"block_height": 12
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/hobby/craft-quilt-block-count", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"quilt_width":60,"quilt_length":80,"block_width":12,"block_height":12}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"quilt_width":60,"quilt_length":80,"block_width":12,"block_height":12}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/hobby/craft-quilt-block-count", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"quilt_width": 60,
"quilt_length": 80,
"block_width": 12,
"block_height": 12
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "hobby.craft_quilt_block_count",
"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 or negative sizes and blocks larger than the quilt span are rejected with invalid_input rather than inventing a layout.
What finished size and block layout mean for a quilt top
Square blocks are the common case: set both faces equal or pass block_size once and both faces inherit that value.
How to call the API and what the response contains
Values at or below about one times ten to the minus fifteen are treated as non-positive and rejected. Failed validation is never billed. POST a JSON body with quilt_width and quilt_length as required strictly positive finite numbers, plus either block_width and block_height or a single block_size for square blocks. Aliases include width, finished_width, and target_width for the quilt span; length, height, finished_length, and target_length for the long side; block_w and finished_block_width for the block face; and size or square_size for the optional square shortcut. Absolute values must stay within one trillion so intermediate products remain finite in IEEE double precision on the Worker and in the browser. If block faces exceed the quilt span in either dimension, the task fails with invalid_input naming the oversized face. On success the body echoes rounded inputs, sets columns and rows to whole layout counts, total_blocks and block_count to the same product, covered_width and covered_length to the grid footprint, leftover_width and leftover_length to residual border space, quilt_area and covered_area to planar measures, coverage_ratio to covered area over quilt area, formula to a compact equation string, message to a short English summary, and steps to ordered substitution lines you can assert in tests. Pricing is a flat $0.002 per successful request with unit item.
Practical planning tips, units, borders, and related searches
Pair examples when teaching: a sixty by eighty quilt with twelve-inch square blocks yields five columns, six rows, and thirty blocks with eight units of length leftover; a seventy by ninety quilt with ten by twelve rectangular blocks yields seven by seven and forty-nine blocks; and block_width zero demonstrates the hard invalid_input path. This landing targets people searching for a quilt block count calculator, how many quilt blocks fit a size, quilt layout rows and columns, or finished block grid planner online. It is not a fabric yardage estimator, not a binding calculator, and not a foundation-paper pattern generator. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when learners deliberately send zero faces. Round-trip checks are easy: recompute floor of width over block width by hand and confirm it equals columns, then confirm columns times rows equals total_blocks.
Integration use cases
Sampler and rectangular block grids
Designers layout non-square finished units by sending block_width and block_height separately, then buy or piece total_blocks for the columns×rows grid.
Class worksheets and craft apps
Teachers and hobby apps pin golden layouts and deliberate zero-size errors so students and clients always see the same deterministic counts.
Technical questions
Can I use square blocks with one number?
Yes. Pass block_size (or size) and both faces use that square finished size. You may also set block_width and block_height equal.
What does the quilt block count calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.