Beads per length calculator
A 180 mm bracelet holds exactly 30 beads of 6 mm with nothing left over. Enter the finished length in mm, cm or inches, the bead size and any knots or clasp, and get a whole-bead count before you order. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Length
- 180
- Bead diameter
- 6
- Length mm
- 180 mm
- Knot gap
- 0
- Clasp length
- 0
- Usable length mm
- 180
Jewelry makers still need one honest integer before they cut cord or buy a hank: how many beads of a known diameter actually sit along the finished, strung length of a necklace, bracelet, or anklet. This beads per length calculator accepts the target strung length in millimetres, centimetres, or international inches, the bead diameter in millimetres, an optional knot or spacer gap in millimetres, and an optional clasp-and-findings length in millimetres. It converts the strand into millimetres, subtracts the clasp, then packs whole beads with gaps only between neighbouring beads so the count never overshoots the usable wire or cord. The path is pure finite arithmetic with no network calls, no random waste fudge, and no date-dependent shortcuts, so the same measurements always produce the same shopping count.
Where a beads-per-length figure earns its keep
Makers meet this math when a client asks for an eighteen-inch necklace in eight millimetre stones and the listing never states how many beads to order, when a memory-wire bracelet must close after a fifteen millimetre lobster clasp, or when pearl knotting adds half a millimetre between neighbours and yesterday’s no-gap count no longer fits.
Developers call the same contract from scripts to seed deterministic test vectors for craft calculators, to normalize a storefront estimator before checkout, or to satisfy programming challenges that demand a packed integer rather than a hand-waved guess. Classroom and workshop demos use the calculator when learners measure a wrist, choose a six millimetre round, optionally enter a knot and a clasp, and compare the predicted count against a sample strand they already own.
Product pages use the breakdown when a designer types length and diameter and the UI must show how many beads sit next to the leftover millimetres for a spacer decision.
What you can do with it
Necklace and bracelet commissions
Enter the finished strand length and the millimetre bead size to get a shopping count before you order a hank or a gemstone strand.
FAQ
Why is the result a whole number instead of a fraction?
You cannot string a fraction of a bead.
How many 6 mm beads fit in a 180 mm bracelet?
Exactly 30, with 0 mm left over, when there are no knots and no clasp to subtract. Add a knot gap or a clasp length and the count drops, because those millimeters never hold a bead.
How do knots between beads change the count?
Each knot adds its width between two neighboring beads, but not after the last one, since the cord runs from that bead into the clasp. So a strand of beads with knots holds fewer beads than the same length without them.
Should I include the clasp in the length?
Enter the finished length as worn, then give the clasp and end findings their own length in millimeters. The calculator subtracts that part first and fills only the remaining strand with beads.
Can I enter the length in inches?
Yes. The finished length can be in millimeters, centimeters or inches, using 25.4 mm per inch. The bead size, the knot gap and the clasp always stay in millimeters, as bead catalogs list them.
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-beads-per-length \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"length":180,"bead_diameter":6}'const res = await fetch("https://api.kit.forhosting.com/hobby/craft-beads-per-length", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"length": 180,
"bead_diameter": 6
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/hobby/craft-beads-per-length",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"length": 180,
"bead_diameter": 6
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/hobby/craft-beads-per-length", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"length":180,"bead_diameter":6}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"length":180,"bead_diameter":6}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/hobby/craft-beads-per-length", 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": 180,
"bead_diameter": 6
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "hobby.craft_beads_per_length",
"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
What bead count along a strung length actually means
A strung length is the finished measurement of the jewelry as worn: the necklace that lists as eighteen inches, the bracelet that must close at one hundred eighty millimetres, the anklet that sits at twenty-five centimetres. Beads occupy that length along their holes, so the relevant size is the catalog diameter in millimetres, not the hole diameter and not the outer circumference. If you place N identical beads with a small knot or spacer only between neighbours, the occupied run is N times the diameter plus N minus one times the gap; there is no gap after the last bead because the wire goes from that bead into the clasp. The clasp, jump rings, and crimps eat a further millimetre budget that never receives a bead, so the usable strand is the converted length minus clasp_length. This calculator returns that usable length, the pitch equal to diameter plus gap, the integer bead_count, the covered run, and the leftover remainder in millimetres, plus a method tag pack_beads_and_inter_bead_gaps and a short formula string you can quote in a pattern note. There is no brand bead database, no silent conversion of an eight millimetre bead into inches unless you asked, and no invented waste percentage: the engine converts, subtracts, and floor-divides inside a supported numeric range or rejects the input with invalid_input. Round shopping bags up at the supplier if hanks are sold in fixed counts; the API keeps the exact mathematical packing so automation stays reproducible.
Input contract, units, and how the packing stays reproducible
Provide length as a positive finite number in the unit you choose, then set unit to mm by default, cm, or in for the international inch of 25.4 millimetres. Computation uses floor division with a tiny epsilon so exact multiples such as one hundred eighty millimetres over six millimetres become thirty beads without a floating-point shortfall. Provide bead_diameter as a positive millimetre size — six and eight millimetres are common glass rounds; seed beads can be entered by their measured diameter. Optional knot_gap defaults to zero and must be non-negative when present; optional clasp_length is also millimetres and defaults to zero. Aliases such as strand_length and necklace_length for length, diameter and bead_size_mm for bead diameter, length_unit for unit, gap and spacer for the knot, and clasp or findings for the clasp are accepted so spreadsheets and typed forms can reuse the same contract. Missing length or bead_diameter, non-positive geometry, an unknown unit, a negative gap or clasp, and a clasp that is not smaller than the converted strand all fail with invalid_input naming the problem and are not billed. Pair the free browser run on this page with the priced API when a jewelry pipeline must emit the same strand count the designer saw on screen.
Where a beads-per-length figure earns its keep
Shop tools can pre-generate bead_count, covered_length_mm, and remainder_mm for standard choker, princess, and tennis lengths without trusting opaque apps that silently switch inches and millimetres. 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 bench plan to an automated pipeline without changing the mathematical result.
Integration use cases
Knotted pearls and spacer gaps
Pass a positive knot_gap so the engine packs N beads and N−1 knots, then read remainder_mm to decide whether a tiny spacer still fits.
Shop estimators and craft software
Generate reproducible bead_count, covered_length_mm, and remainder_mm figures for product pages, kits, and jewelry CAD notes.
Technical questions
How do I calculate how many beads fit on a necklace?
Send length (with unit mm, cm, or in), bead_diameter in millimetres, and optionally clasp_length and knot_gap in millimetres. The API returns bead_count = floor((usable_mm + knot_gap) / (bead_diameter + knot_gap)) where usable_mm is the converted length minus the clasp.
What units does the beads per length calculator use?
length uses unit mm (default), cm, or the international inch of 25.4 mm. bead_diameter, knot_gap, and clasp_length are always millimetres, matching jewelry catalog sizes.
Do knots and clasps change the bead count?
Yes. clasp_length is subtracted first. knot_gap is placed only between neighbouring beads, so N beads use N diameters and N−1 gaps. A zero gap reduces the formula to floor(usable_mm / bead_diameter).
What does the beads per length calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.