Spiral staircase calculator
A 3000 mm rise in a 900 mm radius with 250 mm treads gives 23 treads and a stair that turns slightly more than 360 degrees. You also get the handrail length and the riser height before ordering plate. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Total rise
- 3,000
- Radius
- 900
- Tread depth
- 250
- Tread count
- 23
- Total rotation deg
- 366.0563691114
- Total rotation rad
- 6.3888888889
- Handrail length
- 6,485.5608855364
A spiral staircase wraps treads around a centre pole or an open well so a full floor-to-floor rise fits inside a compact circular plan instead of a long straight flight. Builders, architects, loft converters, and metal-stair fabricators need three layout numbers before they order plate, set a jig, or check headroom: how many treads the helix carries, how far the stair rotates in plan, and how long the helical handrail must be. This spiral staircase calculator takes the total rise, the radius of the walking line or of the handrail, and the tread depth along that radius, then returns the integer tread count, the total rotation angle in degrees and radians, the helix length of the handrail, and the matching riser height.
How tread count, rotation and handrail follow from rise, radius and going
A spiral staircase is a circular helix: each tread sits on a plan circle of radius R and the nosings climb a total rise H. Unrolling the helix onto a rectangle makes the geometry elementary. The plan circumference is two times pi times R.
The integer tread count N is the nearest whole number of goings that fill that circumference, at least one, so N equals max of 1 and the rounded value of 2πR divided by D. Keeping the requested going rather than stretching treads to fill exactly 360 degrees, each tread subtends the angle D over R radians. The total rotation is therefore N times D over R radians, or that quantity times 180 over pi in degrees.
A count that rounded up slightly over-fills one turn; a count that rounded down slightly under-fills it, which is the honest result of insisting on a chosen going. The walking length along the helix in plan is N times D. The handrail, modelled as a helix of the same radius and the same total rise, has length equal to the hypotenuse of that walking length and H: the square root of (N times D) squared plus H squared.
The riser on each tread is H divided by N, because a spiral typically lands on the upper floor with the last riser, so the number of risers equals the number of treads. Revolutions equal total rotation in radians divided by 2π. All lengths share the unit you sent — millimetres, metres, inches, or feet — and the calculator never converts units.
Send the walking-line radius if you care about the path underfoot; send the outer or handrail radius if you are buying rail stock. The same helix formula serves both questions.
Where a spiral staircase calculator earns its keep
Loft conversions and mezzanines are the daily case: a circular well has to swallow a full storey rise without a straight flight eating the room, and the first numbers a joiner or a steel shop needs are tread count, rotation, and rail length. Prefabricated metal spirals are sold by diameter and floor-to-floor height; feeding the walking radius and a chosen going returns how many treads the kit must carry and how long to order the helical rail before the galvanizer runs.
Timber and masonry wells still need the same helix: rotation tells you whether the top nosing faces the landing door or fights it, and the riser height flags a pitch that will fail a comfort check even if the going itself is legal. Curriculum authors and LMS auto-graders pin goldens so a 3000 by 900 by 250 millimetre spiral stays 23 treads. The tool is a constant-radius circular helix, not a straight flight, not a winder stair, and not a helical stair of varying radius; those are different search intents.
It also does not apply building-code walk-line offsets, minimum headroom cones, or fire-escape width rules. If you later need a straight-flight riser count, a stringer-notch layout, or a circular-arch soffit, treat those as the stair and arch pages they already are rather than overloading this spiral-staircase landing.
What you can do with it
Loft and mezzanine wells
Feed floor-to-floor rise, well radius and a chosen going to get tread count, rotation toward the landing door, and helical rail length before you cut the opening.
Prefabricated metal spiral kits
Diameter and storey height become radius, rise and going; the shop gets how many treads the kit must carry and how much helical rail to order.
Checking pitch and rotation on drawings
Riser height flags an uncomfortable pitch; total rotation shows whether the top nosing faces the door or fights the landing wall.
FAQ
How is the spiral staircase tread count computed?
Tread count N is the nearest integer of goings that fill the plan circumference: N = max(1, round(2πR / D)). Rotation is N·D/R radians and the handrail is the helix sqrt((N·D)² + H²).
What happens if tread depth is zero or negative?
A spiral cannot be laid out from a non-positive going; failed validation is not billed.
Is radius the walking line or the handrail?
Whichever helix you want the length of. Send the walking-line radius for the path underfoot, or the outer or handrail radius if you are buying rail stock. The same formula applies.
What units does the spiral staircase calculator use?
Any consistent linear unit: millimetres, metres, inches, or feet. All three inputs must share that unit. The calculator never converts; rotation is returned in degrees and radians.
Why does my spiral stair turn a little more than a full circle?
Because the tread count is rounded to the nearest whole number while your tread depth is kept. With 23 treads of 250 mm on a 900 mm radius, the walking line is 5750 mm, slightly longer than one turn.
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/build/spiral-staircase \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"total_rise":3000,"radius":900,"tread_depth":250}'const res = await fetch("https://api.kit.forhosting.com/build/spiral-staircase", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"total_rise": 3000,
"radius": 900,
"tread_depth": 250
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/build/spiral-staircase",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"total_rise": 3000,
"radius": 900,
"tread_depth": 250
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/build/spiral-staircase", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"total_rise":3000,"radius":900,"tread_depth":250}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"total_rise":3000,"radius":900,"tread_depth":250}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/build/spiral-staircase", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"total_rise": 3000,
"radius": 900,
"tread_depth": 250
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "build.spiral_staircase",
"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
min_length | 1e-15 |
max_length | 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
Tread depth must be a strictly positive length; a zero or negative going is rejected with invalid_input and is not billed.
How tread count, rotation and handrail follow from rise, radius and going
The going that the foot actually travels is the arc length of one tread along that circle, which this calculator calls tread_depth D. Results except the integer tread count are rounded to twelve decimal places so goldens, widgets, and API clients never disagree on a three-metre rise in a nine-hundred-millimetre well.
What you send, which units to use, and how validation fails
All three must be finite positive lengths in the same unit. Zero or negative rise or radius fail the same way. Failed tasks are not billed. Upper limits are generous finite lengths; the hard geometric requirement is that every input be strictly positive. The same input always produces the same rounded output, which is the contract estimating sheets, CNC templates, and edge workers rely on when they pin a three-metre loft spiral in a nine-hundred-millimetre well. Send three required numeric fields named total_rise, radius, and tread_depth. Aliases rise, height, total_height, and floor_height are accepted for total_rise; r, R, and walking_radius for radius; going, tread, depth, and tread_going for tread_depth, so a form that already says going does not need a rename. Strings that parse as finite numbers are accepted the same as JSON numbers. On success the response echoes the cleaned inputs and publishes tread_count as the integer number of treads, total_rotation_deg and total_rotation_rad as the helix sweep, handrail_length as the helix hypotenuse, riser_height as rise over N, revolutions as the sweep in turns, walking_length as N times D, plan_circumference as 2πR, and formula as the identity that produced them. A worked millimetre case: total_rise 3000, radius 900, tread_depth 250 yields 23 treads, a little more than one full turn because 23 goings of 250 millimetres slightly over-fill the 1800π millimetre circumference, a riser of 3000 over 23, and a handrail of the square root of 5750 squared plus 3000 squared. A zero, negative, or missing tread_depth fails with invalid_input naming that field, which is the product contract: a spiral cannot be laid out from a non-positive going. Successful API calls use the published base of $0.002 per item.
Technical questions
What does the spiral staircase calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.