Gear output speed calculator
A shaft turning at 1000 rpm through a gear ratio of 2 drives the output at 500 rpm, a reduction stage. Enter the input speed and the ratio to get the output speed and the velocity ratio of the pair. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Input speed
- 1,000
- Gear ratio
- 2
- Output speed
- 500
- Velocity ratio
- 0.5
- Transmission
- reduction
- Precision
- 12
This gear output speed calculator turns a known input shaft speed and a simple pair gear ratio into the driven shaft speed so you can size motors, check reduction stages, and grade machine-design homework without a spreadsheet.
How output speed follows from the gear ratio
For a simple external gear pair the gear ratio GR is defined as driven tooth count over driver tooth count, which is also the ratio of input angular speed to output angular speed when teeth stay in continuous mesh without slip. When GR is greater than one the mesh is a reduction stage—the driven shaft turns slower and torque multiplies by roughly the same factor (ideal, lossless). When GR is less than one the mesh is an overdrive or speed-increase stage—the driven shaft turns faster.
When GR equals one the shafts share speed and the transmission tag is one-to-one. Compound trains, idlers that only reverse direction without changing magnitude, planetary carriers, and belt or chain slip are outside the contract: you must reduce those systems to an equivalent single GR before calling.
Where gear output speed fits in design, study, and software
Teachers can pre-generate answer keys for modest ratios without trusting opaque calculator apps that silently swap driver and driven definitions of GR. Developers call the same contract from scripts to seed deterministic test vectors for gearbox configurators, to normalize user-entered ratio data before a larger drivetrain model, or to satisfy programming-challenge statements that demand shaft speed rather than a hand-waved sketch. Plant and field engineers use the quotient for quick checks when a motor runs at a measured RPM and the gearbox ratio is printed on the housing.
Keep this tool for a single equivalent gear ratio and a known input speed; if you only have tooth counts, compute GR first. Prefer the manufacturer ratio definition (driven over driver) so GR greater than one always means slower output in the usual reduction sense.
What you can do with it
Homework and lab shaft-speed checks
Compute driven RPM from motor input speed and a textbook gear ratio before writing a kinematics report or exam solution.
Gearbox nameplate verification
Convert measured driver shaft speed and the labeled reduction ratio into expected output RPM for commissioning or troubleshooting.
FAQ
How is the gear ratio defined here?
As driven teeth divided by driver teeth, which equals input speed divided by output speed. A ratio above one is a reduction, so the driven shaft turns slower than the driver.
What does a gear ratio below one mean?
It is an overdrive, or speed-increase stage, so the driven shaft turns faster than the driver. A ratio of exactly one keeps both shafts at the same speed.
Can I enter tooth counts instead of the ratio?
No. Divide the driven gear's tooth count by the driver's tooth count to get the ratio first, then enter that number together with the input speed.
Which speed units can I use for the gear calculation?
Any angular speed unit, such as rpm, revolutions per second or radians per second. The output speed comes back in the same unit as the input, because nothing is converted.
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/eng/gear-output-speed \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"input_speed":1000,"gear_ratio":2}'const res = await fetch("https://api.kit.forhosting.com/eng/gear-output-speed", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"input_speed": 1000,
"gear_ratio": 2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/eng/gear-output-speed",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"input_speed": 1000,
"gear_ratio": 2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/eng/gear-output-speed", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"input_speed":1000,"gear_ratio":2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"input_speed":1000,"gear_ratio":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/eng/gear-output-speed", 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_speed": 1000,
"gear_ratio": 2
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "eng.gear_output_speed",
"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
Zero or negative gear ratio is rejected with a clear invalid_input error instead of inventing speed from an impossible mesh.
How gear-pair output speed is defined from n_in and GR
Rearranging that identity gives the single division this calculator performs: output shaft speed n_out equals input shaft speed n_in divided by GR. Velocity ratio is reported as the reciprocal of GR so you can write n_out equals n_in times velocity_ratio if that form matches your notes. This endpoint does not count teeth; if you only know tooth numbers, compute GR first or use a dedicated gear-ratio tool, then pass the ratio here. The response always echoes the rounded inputs, publishes output_speed, velocity_ratio, transmission class, formula, message, and steps, and never invents a second stage or a unit conversion. Keep n_in and n_out in the same unit—RPM with RPM, rad/s with rad/s—because the engine is unitless arithmetic by design.
Input contract, response shape, and error behaviour
Prefer sending numbers rather than pre-formatted strings when you control the client; when you must send strings, avoid unit labels such as RPM that would fail the finite-number pattern. Send a JSON body with two required fields: input_speed for the driver shaft speed n_in (aliases n_in, rpm_in, omega_in, driver_speed, nin) and gear_ratio for the positive pair ratio GR (aliases ratio, gr, R, i, reduction_ratio). Both must be finite numbers; gear_ratio must be strictly positive within the published absolute range so the division remains a finite IEEE double. Optional precision (aliases decimals, dp) chooses how many decimal places to expose for numeric fields, defaulting to twelve and capped at fifteen so JSON goldens stay stable across runtimes. String forms of numbers are accepted when they match a strict finite decimal pattern with optional scientific notation; embedded spaces, unit suffixes, and non-numeric tokens fail with a clear invalid_input message naming the field. On success the response echoes the rounded inputs, publishes output_speed as n_in divided by GR, velocity_ratio as one over GR, transmission as reduction, overdrive, or 1:1, formula and message as English summary strings, and steps as the substitution log you can assert in tests or show next to a sketch. Failed validation—missing fields, non-finite numbers, zero or negative gear_ratio, or values outside absolute limits—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item. Pair this endpoint with a gear-ratio calculator when you start from tooth counts, or with a torque-ratio check when you need ideal torque multiplication; this page answers only output shaft speed from known n_in and GR.
Where gear output speed fits in design, study, and software
Students meet gear-pair output speed when a machine-design course introduces spur gears, when a lab asks for driven RPM from motor nameplate speed and a stated reduction, or when a kinematics problem needs n_out before power or efficiency estimates. Product and education tools use the rewrite when a learner types n_in and GR and the UI must show n_out with a clean formula string. 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 classroom demo to an automated pipeline without changing the mathematical result.
Integration use cases
Drivetrain software fixtures
Generate deterministic n_out vectors for unit tests of configurators and control software that consume gear_ratio and n_in.
Technical questions
How do I calculate gear output shaft speed?
Send finite input_speed (n_in) and a positive gear_ratio GR. The API returns n_out = n_in / GR, plus velocity_ratio = 1/GR and a transmission class (reduction, overdrive, or 1:1).
What definition of gear ratio does this use?
GR = N_driven / N_driver = n_in / n_out. Values greater than 1 reduce speed; values less than 1 overdrive; GR = 1 is one-to-one.
What happens if gear_ratio is zero or negative?
The task fails with invalid_input. A simple mesh ratio must be strictly positive; zero or negative GR is not accepted and is not billed.
Can I pass tooth counts instead of gear ratio?
No. This calculator expects a known GR. Compute GR from teeth first (for example with a gear-ratio tool), then call this endpoint with input_speed and gear_ratio.
What does the gear output speed calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.