Belt length calculator
Pulleys of 200 and 100 mm with shafts 500 mm apart need 1,000 mm of straight belt plus two wrap arcs and a 5 mm correction. Enter both diameters and the center distance in one unit to get the length and wrap angles. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Large diameter
- 200
- Small diameter
- 100
- Center distance
- 500
- Min center distance
- 50
- Belt length
- 1,476.2388980385
- Length
- 1,476.2388980385
- Straights length
- 1,000
A belt length calculator answers the question every mechanic, maker, and engineering student faces before ordering a belt: how long must the belt be to wrap both pulleys at a given shaft spacing? Enter the diameter of the larger pulley, the diameter of the smaller pulley, and the center distance between the two shafts, all in the same unit, and the tool evaluates the standard open-belt length formula: twice the center distance for the two straight spans, plus pi times the sum of the diameters over two for the wrap arcs, plus the diameter difference squared over four times the center distance as the correction term. The result comes back in the same unit you supplied, together with the wrap angles on both pulleys, the minimum allowable center distance, a human-readable equation string, and ordered substitution steps you can verify by hand. Conveyor builders, 3D-printer designers, lathe restorers, HVAC technicians, and physics students all use this exact formula.
The open-belt length formula and what each term means
The formula has an intuitive decomposition. The first term, twice the center distance, accounts for the two straight spans of belt running from one pulley to the other, which is exact when the pulleys are equal in size. The second term, pi times the sum of the diameters divided by two, is half the circumference of each pulley added together; it treats the wrap as a pair of semicircles, which is exact for equal pulleys and an excellent approximation otherwise.
The third term, the diameter difference squared over four times the center distance, corrects for the geometry of unequal pulleys: the straight spans run slightly obliquely, lengthening the path, and the wrap angles shift away from exactly one hundred eighty degrees. Because the pulleys must not touch, the center distance has a hard floor: it must exceed half the difference of the diameters.
The approximation is accurate to a small fraction of a percent whenever the center distance is comfortably larger than the diameters, which covers nearly every real drive, and it is the same formula printed in machinery handbooks, V-belt catalogs, and timing-belt design guides.
Practical tips, limits, and common pitfalls
Measure the center distance between shaft axes, not between pulley edges, and measure it at the final installed position; adjustable motor mounts change the spacing as they tension the belt, so compute the length at the mid-adjustment point and check the extremes. Keep units consistent: mixing millimeter diameters with an inch center distance silently produces a plausible-looking but wrong belt length, because the solver trusts your numbers and converts nothing.
Remember what this tool is not: it computes the length of an open belt path, not a crossed belt (which uses a plus sign inside the arc term and a different formula), not a chain, and not a serpentine path around three or more pulleys. For crossed belts and multi-pulley layouts you need their dedicated formulas.
Also note that real belts are sold in discrete standard sizes—pitch lengths for timing belts, datum lengths for V-belts—so use the computed value to pick the nearest catalog size and then re-check that your tensioning range can absorb the difference. Prefer sending raw numbers rather than pre-formatted strings; string numbers are accepted only when they match a strict finite numeric pattern.
What you can do with it
Machine design and retrofit
Engineers sizing a new belt drive—or replacing a worn belt on a lathe, drill press, or blower—compute the exact open-belt length from pulley diameters and shaft spacing before ordering a catalog size.
3D printers and robotics
Makers laying out GT2/GT3 timing-belt loops on custom gantries check the required belt length and the small-pulley wrap angle to keep enough tooth engagement.
Homework and lab checks
Students verify machine-design exercises against a deterministic reference that shows every substitution step and rejects impossible geometries with a clear error.
FAQ
What happens if the center distance is too short?
The center distance must be strictly greater than half the difference of the diameters, otherwise the pulleys would overlap. Failed tasks are never charged.
Which units does the result use?
Whatever unit you supplied. The tool performs no unit conversion: if the diameters and center distance are in millimeters, the belt length is in millimeters; if they are in inches, the result is in inches.
Does this work for crossed belts or multi-pulley drives?
No. It computes the open-belt path for exactly two pulleys. Crossed belts and serpentine layouts use different formulas and need their own tools.
Where exactly do I measure the center distance?
Between the two shaft axes, not between the pulley rims, and at the final installed position. On an adjustable motor mount, calculate at the middle of the tensioning travel and then check both extremes.
How accurate is the open-belt formula?
It is within a small fraction of a percent whenever the center distance is comfortably larger than the diameters, which covers nearly every real drive. It is the same formula printed in machinery handbooks and belt catalogs.
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/phys/belt-length \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"large_diameter":200,"small_diameter":100,"center_distance":500}'const res = await fetch("https://api.kit.forhosting.com/phys/belt-length", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"large_diameter": 200,
"small_diameter": 100,
"center_distance": 500
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/phys/belt-length",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"large_diameter": 200,
"small_diameter": 100,
"center_distance": 500
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/phys/belt-length", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"large_diameter":200,"small_diameter":100,"center_distance":500}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"large_diameter":200,"small_diameter":100,"center_distance":500}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/phys/belt-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
{
"large_diameter": 200,
"small_diameter": 100,
"center_distance": 500
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "phys.belt_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.
Limits
max_abs | 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 center distance is too short—at or below half the difference of the diameters—the pulleys would overlap and the drive is impossible, so the request is rejected with a clear invalid_input error and is never charged.
The open-belt length formula and what each term means
For an open two-pulley drive—one where the belt does not cross itself between the pulleys—the classic engineering formula for belt length is L = 2C + pi(D+d)/2 + (D-d)^2/(4C), where C is the distance between the shaft centers, D the larger pulley diameter, and d the smaller one. At exactly that floor the pulley rims would just kiss, and below it they would overlap, which is physically impossible, so this calculator rejects such inputs with a documented invalid_input error instead of returning a meaningless number.
How to call the API and read the response
All three must be greater than zero and expressed in the same unit—millimeters, inches, or anything consistent—because the tool performs no unit conversion and the result inherits your unit. If you accidentally swap the two diameters the solver normalizes them internally, so the larger value is always treated as D. Formula, equation, message, and an ordered steps array document the substitution line by line for worksheets and assertion logs. Send a JSON body with three required finite numbers: large_diameter (aliases d1, large_pulley_diameter, big_diameter, driver_diameter), small_diameter (aliases d2, small_pulley_diameter, driven_diameter), and center_distance (aliases c, distance, shaft_distance, center_distance_mm). On success the response echoes the rounded inputs, reports min_center_distance (half the diameter difference, the hard floor for the spacing), publishes the result as belt_length and length, and breaks the computation into straights_length, arc_length, and correction so you can see each term of the formula. You also get wrap_angle_small_deg and wrap_angle_large_deg, the contact angles in degrees computed from the arc sine of the diameter difference over twice the center distance; the small-pulley wrap matters because it limits power transmission and grip. Failed validation—missing fields, non-finite or non-positive numbers, or a center distance at or below the floor—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item and zero marginal unit price.
Practical tips, limits, and common pitfalls
Equal diameters reduce the formula to twice the center distance plus pi times the diameter, and both wrap angles come out at exactly one hundred eighty degrees; a center distance barely above half the diameter difference approaches the rejection floor and exercises your client's error handling with the documented invalid_input path. Round-trip verification is easy: recompute the three terms by hand or in a spreadsheet and confirm they match the published belt_length within the same twelve-decimal rounding the API uses everywhere.
Technical questions
What formula does the belt length calculator use?
The standard open-belt formula L = 2C + pi*(D+d)/2 + (D-d)^2/(4C), where D and d are the pulley diameters and C is the center distance between the shafts.
Does the order of the two diameters matter?
No. The solver internally treats the larger value as D and the smaller as d, so swapping large_diameter and small_diameter yields the same belt length.