Gear ratio RPM calculator
A 1000 rpm motor turning a 20-tooth gear that drives a 40-tooth gear gives a ratio of 2 and 500 rpm at the output. Enter the input speed and both tooth counts to size a reduction for a gearbox or robot. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Input rpm
- 1,000
- Driving teeth
- 20
- Driven teeth
- 40
- Gear ratio
- 2
- Output rpm
- 500
This gear ratio RPM calculator finds the output shaft rotational speed of a simple two-gear mesh from the input gear rpm and the tooth counts on the driving and driven gears. Enter a finite input speed together with two positive integer tooth counts; the engine returns output rpm from the pitch-circle identity that linear velocities match at the mesh, so output rpm equals input rpm times driving teeth over driven teeth, equivalently input rpm divided by the driven-to-driving tooth ratio. A larger driven gear is a reduction (output turns slower); a smaller driven gear is an overdrive (output turns faster); equal teeth leave rpm unchanged. Fractional, zero, or negative tooth counts are rejected because they do not describe a cut gear, and a non-finite input rpm is rejected instead of producing Infinity or NaN.
What gear-ratio RPM means for a two-gear mesh
In a simple external mesh the driving gear is the input wheel that a motor, crank, or upstream shaft turns, and the driven gear is the output wheel that follows through the shared pitch-circle contact. When GR is greater than one the pair is a speed reduction: the output shaft turns slower than the input and, neglecting losses, ideal torque multiplies by GR. When GR is less than one the pair is an overdrive: the output turns faster.
When the two gears have equal integer tooth counts, GR is one and output rpm equals input rpm. This calculator reports signed rotational speed, not rotation sense: an external spur pair reverses direction while an internal mesh does not, but both share the same magnitude formula. Tooth counts must be positive integers because a manufactured gear cannot have zero, negative, or fractional teeth; sketches that show scaled fractions still have to be realized as whole teeth on metal.
Input rpm must be a finite number so the product never becomes Infinity or NaN; zero input speed is a valid idle case that yields zero output speed, and a negative input speed is treated as reverse rotation with a negative output.
What you can do with it
Hobby gearbox and robotics shaft speed
Makers plug pinion and spur tooth counts with a nameplate motor rpm to estimate output shaft speed when picking a reduction stage without opening CAD.
FAQ
What if the input rpm is zero or negative?
Zero input rpm is valid and yields zero output rpm (idle). A negative input rpm is treated as reverse rotation and returns a negative output rpm. Non-finite values (NaN, Infinity) are rejected.
Does a larger driven gear increase or decrease output rpm?
A smaller driven gear is an overdrive: output turns faster. Equal teeth leave rpm unchanged.
What does the gear ratio RPM calculator cost?
The browser tool is free and runs locally.
Does the result show which way the output turns?
No. It gives the speed with its sign, not the direction of rotation. An external spur pair reverses direction and an internal mesh does not, but both use the same speed formula.
Can I calculate a gear train with several stages?
Not in one go. The calculator handles one mesh between two gears. For a compound train, work out each pair separately and use the output speed of one stage as the input of the next.
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/gear-ratio-rpm \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"input_rpm":1000,"driving_teeth":20,"driven_teeth":40}'const res = await fetch("https://api.kit.forhosting.com/phys/gear-ratio-rpm", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"input_rpm": 1000,
"driving_teeth": 20,
"driven_teeth": 40
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/phys/gear-ratio-rpm",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"input_rpm": 1000,
"driving_teeth": 20,
"driven_teeth": 40
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/phys/gear-ratio-rpm", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"input_rpm":1000,"driving_teeth":20,"driven_teeth":40}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"input_rpm":1000,"driving_teeth":20,"driven_teeth":40}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/phys/gear-ratio-rpm", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"input_rpm": 1000,
"driving_teeth": 20,
"driven_teeth": 40
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "phys.gear_ratio_rpm",
"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
What gear-ratio RPM means for a two-gear mesh
Each full revolution of the driving gear advances exactly as many teeth as that gear has, so the driven gear must rotate by driving_teeth over driven_teeth of a revolution. Angular speeds therefore scale with the reciprocal of tooth counts: output_rpm equals input_rpm times driving_teeth divided by driven_teeth. That identity is the same as dividing the input speed by the gear ratio GR, defined here as driven_teeth over driving_teeth, which is the ratio named in the search this page answers. Compound trains, belt ratios, and planetary carriers are out of scope: multiply stage ratios offline or call this endpoint once per mesh.
Input contract, response shape, and error behaviour
Both tooth counts must be whole numbers greater than zero; a zero tooth count, a negative count, a non-integer such as twelve point five, or a non-numeric string is rejected rather than silently truncated. POST a JSON body with three required fields. input_rpm (aliases rpm_in, driver_rpm, n_in, and input_speed) is the driving-shaft speed in revolutions per minute; it must be a finite number, and missing, empty, NaN, or infinite values fail with invalid_input naming the field. driving_teeth (aliases driver_teeth, pinion_teeth, n1, and driving) is the positive integer tooth count on the input gear. driven_teeth (aliases gear_teeth, n2, and driven) is the positive integer tooth count on the output gear. Absolute magnitudes stay within the published limit of one trillion so the quotient remains finite in IEEE double precision on the Worker and in the browser. On success the response echoes the rounded input_rpm, driving_teeth, and driven_teeth, sets gear_ratio to driven_teeth over driving_teeth, sets output_rpm to input_rpm times driving_teeth over driven_teeth, and includes the closed formula string. Failed validation returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item. Prefer JSON numbers when you control the client; numeric strings that match a strict finite decimal pattern are accepted so paste-from-spreadsheet paths keep working without opening the door to arbitrary text.
Where a gear-ratio RPM calculator earns its keep
Keep tooth counts and speeds inside the published range so the scaled output rpm cannot overflow into a non-finite value that the solver must reject. Prefer this capability when you already know motor rpm and the two integer tooth counts of a single mesh and you need the output rpm as the primary answer. If you only need the dimensionless ratio without a speed, a dedicated gear-ratio landing may be a better search match; if you are sizing a four-by-four crawl stack, use a crawl-ratio calculator instead. Pair classroom examples deliberately: twenty driving teeth and forty driven teeth at one thousand rpm yields a two-to-one reduction and five hundred rpm out; eighteen driving and fifty-four driven at thirty-six hundred rpm yields a three-to-one reduction and twelve hundred rpm out; equal counts leave rpm unchanged; and a zero or fractional tooth count demonstrates the hard invalid_input path. This landing targets people searching for a gear ratio rpm calculator, output shaft speed from tooth counts, or driving and driven gear rpm conversion online. It is not a full multi-stage compound gearbox solver, not a bicycle chainring and sprocket development tool, not a crawl-ratio product of first gear, transfer case, and axle, and not a module or diametral-pitch geometry helper. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when learners deliberately pass illegal tooth counts. Round-trip checks are easy: recompute input_rpm times driving_teeth divided by driven_teeth by hand and confirm it equals the published output_rpm within the same twelve-decimal rounding.
Integration use cases
Homework checks for output rpm
Students enter motor rpm plus driving and driven tooth counts and compare the textbook n_out = n_in × T1/T2 result against deterministic JSON before submitting.
Firmware unit tests for drivetrain math
Generate known-good reduction, overdrive, and one-to-one output rpm fixtures plus deliberate non-integer or zero-teeth rejections for embedded transmission tests.
Technical questions
How is output rpm calculated from a gear ratio?
output_rpm = input_rpm × driving_teeth / driven_teeth, which is the same as dividing input rpm by gear_ratio = driven_teeth / driving_teeth. Send those three fields as JSON.
Must tooth counts be whole numbers?
Yes. driving_teeth and driven_teeth must be positive integers. Zero, negative, and fractional counts fail with invalid_input because they do not describe a cut gear.