Bicycle gear ratio calculator
A 50-tooth chainring with an 11-tooth cog turns the rear wheel more than 4 times per crank revolution, while 32 with 36 turns it less than once: enter both tooth counts to get the exact ratio and whether the gear is hard or easy. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Chainring teeth
- 50
- Sprocket teeth
- 11
- Gear ratio
- 4.5454545455
- Ratio
- 4.5454545455
- Ratio string
- 50/11
Cyclists, bike-fitters and component shops constantly compare gearing setups: how hard is a fifty-eleven road gear compared with a compact thirty-four twenty-eight, or which cassette cog makes a mid-compact crank climb-friendly? This capability answers that with transparent arithmetic—no telemetry, no power meter and no hidden rolling-radius assumptions. You pass two positive tooth counts: the front chainring and the rear sprocket (cog). The service returns the gear ratio as chainring divided by sprocket, a compact ratio string such as fifty slash eleven, a short message classifying harder versus easier gears, and step-by-step substitution so the result is auditable.
What bicycle gear ratio means in practice
On a bicycle, the drivetrain multiplies cadence into wheel rotation through two toothed components connected by the chain: the front chainring on the crankset and a rear sprocket on the freehub or fixed hub. Gear ratio in the cycling convention is simply the number of chainring teeth divided by the number of rear sprocket teeth. A fifty-tooth chainring paired with an eleven-tooth cog yields roughly four point five five, a tall road gear for high speed on the flat.
A thirty-two-tooth chainring with a thirty-six-tooth cassette cog yields about zero point eight nine, an easy climbing gear where one crank revolution turns the wheel less than once. Higher ratios demand more force per pedal stroke and cover more ground per revolution; lower ratios reduce force and slow the bike for steep grades or technical trails. Tooth counts are whole numbers on real hardware, but the library accepts any positive finite number so batch scripts and approximate planning still work.
The output does not invent wheel diameter, tyre size or gear inches; those need extra geometry. It isolates the pure ratio so you can compare cassettes, cranksets and 1x versus 2x layouts on equal terms before you layer development or metres-of-development formulas.
Where it fits in cycling and product workflows
Bike shops and online configurators let customers pick a crankset and cassette and need an instant ratio table for every combination before quoting a build. Coaching apps store an athlete’s current gearing and compare planned swaps—for example moving from an eleven-twenty-eight cassette to an eleven-thirty-four—without requiring a ride file. Mechanics teaching apprentices can show why a compact crank with a wide-range cassette covers more climbing range than a traditional fifty-thirty-four with a short cassette by listing ratios side by side.
Adventure and bikepacking planners evaluate bailout gears for loaded climbs using the lower end of the cassette only. The browser path is free for single checks: enter fifty and eleven and confirm the tall road ratio; enter thirty-four and twenty-eight and see the easier climbing figure.
What you can do with it
Shop build configurators
Map every chainring and cassette cog pair to a gear ratio table when a customer picks components for a new road or gravel bike.
Coaching gearing comparisons
Compare an athlete’s current tallest and easiest gears with a proposed crank or cassette swap using stable ratio numbers.
Catalogue and marketing charts
Regenerate drivetrain gearing charts from tooth-count product data so technical pages stay consistent with the parts list.
FAQ
What does it cost?
The same calculation runs free in your browser on this page.
Does this include gear inches or development?
No. It returns only the pure tooth-count gear ratio. Multiply by your wheel diameter or circumference offline if you need gear inches or metres of development.
How is this different from a general gear ratio calculator?
Industrial gear tools often use driven/driver and optional shaft speeds. This tool is named and documented for bicycle chainring and rear sprocket counts in cycling order.
Which is harder to pedal, 50/11 or 34/28?
50/11. Its higher ratio covers more ground per crank revolution but asks for more force on each stroke. With 34/28 the wheel turns only a little more than once per revolution, which suits climbing.
Why is the ratio chainring divided by cog and not the other way round?
Because that is how riders and bike shop manuals quote gearing. Calculators for industrial gearboxes often use the opposite order, so their numbers will not match a cycling chart.
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/sport-bike-gear-ratio \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"chainring_teeth":50,"sprocket_teeth":11}'const res = await fetch("https://api.kit.forhosting.com/hobby/sport-bike-gear-ratio", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"chainring_teeth": 50,
"sprocket_teeth": 11
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/hobby/sport-bike-gear-ratio",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"chainring_teeth": 50,
"sprocket_teeth": 11
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/hobby/sport-bike-gear-ratio", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"chainring_teeth":50,"sprocket_teeth":11}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"chainring_teeth":50,"sprocket_teeth":11}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/hobby/sport-bike-gear-ratio", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"chainring_teeth": 50,
"sprocket_teeth": 11
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "hobby.sport_bike_gear_ratio",
"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 bicycle gear ratio means in practice
Unlike industrial gear-pair calculators that often report driven over driver for reduction boxes, bicycle riders and shop manuals almost always quote chainring over cog, which is why this capability uses that order and names the fields chainring_teeth and sprocket_teeth.
How to call the API and read the response
There is no network hop, model call or randomness, so latency stays in the pure edge-parse band. Pair the ratio with your own wheel circumference offline if you need development distance, or feed batches of chainring and cog pairs from a product catalogue to rank gearing options. Send two required fields: chainring_teeth as a positive number of teeth on the front ring (aliases chainring, front_teeth, front, ring_teeth and chainring_t are accepted) and sprocket_teeth as a positive number of teeth on the rear cog (aliases sprocket, cog_teeth, rear_teeth, rear, cog and cassette_teeth). Missing either field fails immediately with invalid_input naming the field; zero, negative or non-finite values likewise raise invalid_input and are not charged. Price for a successful API request is $0.002 per item.
Where it fits in cycling and product workflows
Frame and component manufacturers publish gearing charts for gravel, road and e-bike lines; regenerating those charts from tooth-count tables with deterministic JSON keeps marketing pages and technical PDFs in sync. The API path costs $0.002 per successful request and is billed per item, which keeps bulk catalogue generators and mobile onboarding scripts cheap while still covering edge execution. Because results are deterministic, audit logs can store the full response and re-run it years later without drift, and regression suites pin exact expected JSON for every common road and mountain combination you care about.
Technical questions
How is gear_ratio computed?
gear_ratio = chainring_teeth / sprocket_teeth using the cycling convention (front ring over rear cog). Higher values are harder/taller gears.
Why was my request rejected?
Both chainring_teeth and sprocket_teeth must be positive finite numbers. Missing, zero, negative or non-numeric values return invalid_input and are not charged.