Quilt yardage calculator
A 60 by 80 inch quilt with 12-inch blocks and a 0.25-inch seam needs 30 blocks cut at 12.5 inches, just under three and a half yards of 42-inch fabric. Take a real shopping number to the fabric store. 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 size
- 12
- Seam allowance
- 0.25
- Fabric width
- 42
- Columns
- 5
- Rows
- 6
- Block count
- 30
This quilt yardage calculator converts finished quilt width, finished quilt length, a finished square block size, and a seam allowance into fabric yardage and a block count you can take to the shop. It first asks how many whole blocks fit across the quilt and how many whole rows fit along the length, then multiplies those integers so you know how many pieced units the top needs. Each finished block is enlarged by seam allowance on every side to a cut size, those cuts are packed onto strips as wide as the usable bolt, and the strip length is divided by thirty-six to report linear yards.
What quilt yardage and block count mean before you buy cloth
Quilt yardage is the length of bolt-width cloth you should order for the pieced top once every finished block has been enlarged by seam allowance and packed onto strips. It is not the finished quilt area by itself, and it is not a layout sketch: it is a shopping number in linear yards of a stated usable width, plus the integer block count that produced that number. This calculator answers both in one closed form.
Columns equal the greatest whole number of finished blocks that fit into quilt width. Rows equal the greatest whole number that fit into quilt length. Block count is columns times rows, the count of pieced units the grid requires before borders or binding.
Cut size is block size plus twice the seam allowance, because each finished edge loses one seam when it is sewn to its neighbour. Those cut squares are then laid across the usable bolt: blocks per strip is the floor of fabric width divided by cut size, strips is the ceiling of block count divided by that packing, fabric inches is strips times cut size, and yardage is that length divided by thirty-six.
Covered width and covered length report the finished grid footprint; leftovers report the border space left when the division is not exact. There is no hidden waste percent, no backing or batting layer, and no binding strip: the engine either packs the pieced top or it rejects the input. If you only need rows and columns without fabric, use a dedicated block-count layout helper; this page is the quilt yardage landing.
Where quilt yardage planning fits in sewing, teaching, and software
People meet quilt-yardage math when a shop quotes a sixty-by-eighty throw and nobody can say whether that is three yards of cloth or six, when a class must order a bolt before Saturday, or when a teacher asks students to convert a finished size, a block face, and a quarter-inch seam into a purchase length.
Home sewers can pre-check a sixty-by-eighty top of twelve-inch squares with a quarter-inch seam before they treat the fabric aisle as a sunk cost, and workrooms can compare an eight-inch grid against a ten-inch grid without opaque spreadsheet macros. Contest and homework practice often needs a fast, offline source of strip-packed yards so solutions can be checked without a bolt chart under time pressure.
Product and education tools use the split when a learner types a quilt size and the interface must show a clean yardage figure beside the echoed inputs. Pair it with a layout-only block-count helper when you already know the grid and only need rows and columns, or with a fabric-weight converter when the shopping question is ounces rather than yards.
What you can do with it
Order fabric before piecing a quilt top
Turn finished quilt size, block size, and seam allowance into block count and linear yards of bolt-width cloth before you buy a cut.
Homework and sewing-class worksheets
Generate a reproducible yardage figure from a finished size, a square block, and a seam, including the strip-packing step.
FAQ
What does the quilt yardage calculator cost?
It is free in your browser on this page.
How is fabric yardage defined?
Numeric fields are rounded to ten decimal places.
What seam allowance should I use?
A quarter inch (0.25) is the usual piecing seam. Enter the allowance you actually sew. Zero is allowed and means the cut equals the finished face.
Does this include backing, batting, or binding?
No. The result is yardage for the pieced top only, packed on the stated usable bolt width (default 42 inches). Backing, batting, binding, and sashing are out of scope.
What if the blocks do not fit the quilt size exactly?
Only whole blocks are counted, and the space left over is reported as room for borders. An 80-inch length with 12-inch blocks fits 6 rows and leaves 8 inches.
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/life/quilt \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"quilt_width":60,"quilt_length":80,"block_size":12,"seam_allowance":0.25}'const res = await fetch("https://api.kit.forhosting.com/life/quilt", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"quilt_width": 60,
"quilt_length": 80,
"block_size": 12,
"seam_allowance": 0.25
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/life/quilt",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"quilt_width": 60,
"quilt_length": 80,
"block_size": 12,
"seam_allowance": 0.25
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/life/quilt", 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_size":12,"seam_allowance":0.25}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"quilt_width":60,"quilt_length":80,"block_size":12,"seam_allowance":0.25}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/life/quilt", 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_size": 12,
"seam_allowance": 0.25
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "life.quilt",
"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_abs_value | 1000000000000 |
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
If the block is larger than the quilt in either span, the request is rejected with invalid_input instead of inventing a layout or a fabric order.
What quilt yardage and block count mean before you buy cloth
A block larger than either quilt span is invalid_input, because a twelve-inch block cannot sit inside a ten-inch mini quilt.
How quilt, block, seam, and bolt fields are read so results stay reproducible
Optional leading plus signs and scientific notation on numeric strings are allowed when they parse as finite decimals; embedded spaces, hex prefixes, and non-numeric tokens are rejected with a message that names the field so a bad cell does not become a wrong cut list. Quilt width, quilt length, block size, and fabric width must each be strictly greater than zero. Computation uses ordinary floating-point arithmetic, then rounds each non-integer field to ten decimal places so goldens stay stable across runtimes. The preferred field for the short span is quilt_width, but aliases width, quilt_w, finished_width, and target_width are accepted so a form, a query string, or a spreadsheet column can reuse the same contract without renaming cells. Length prefers quilt_length, with aliases length, height, quilt_h, quilt_l, finished_length, and target_length. The finished square face prefers block_size, with aliases size, finished_block_size, square_size, and block. Seam allowance prefers seam_allowance, with aliases seam, sa, and allowance. Usable bolt width prefers fabric_width, with aliases bolt_width, usable_width, and wof; when that field is omitted the engine uses forty-two, the usual usable width of quilting cotton measured in inches. Seam allowance may be zero, which means the cut equals the finished face, but a negative fold is invalid_input. All five quantities share one length unit for the request; yardage is meaningful in yards only when that unit is the inch, because the last step divides strip length by thirty-six. Pair the free browser run on this page with the priced API when you need that identical mathematical result inside an automated quote or inventory pipeline without re-implementing the strip rule yourself.
Where quilt yardage planning fits in sewing, teaching, and software
Developers call the same contract from scripts to seed deterministic test vectors for sewing calculators, to normalize user-entered sizes before a quote demo, or to satisfy a product statement that demands yardage and block_count fields rather than a hand-waved estimate. 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 tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the mathematical result.
Integration use cases
Quote tools and test fixtures
Normalize quilt and block inputs into stable yardage and block_count fields for product interfaces and continuous-integration assertions.
Technical questions
What happens if the block is larger than the quilt?
The input is rejected with invalid_input. block_size must not exceed quilt_width or quilt_length, because a finished block cannot be larger than the quilt.