ForHosting KIT · Science

Gear ratio calculator

A 20-tooth driver turning a 40-tooth gear gives a ratio of 2, a speed reduction: 1000 rpm in becomes 500 rpm out. Ratios above 1 slow the output, ratios below 1 speed it up. Free in your browser.

  • Free
  • Runs in your browser
  • No sign-up
  • Your data stays on your device
Use it from WebAPIEmailTelegramApp soon
If you enter
Driver teeth
20
Driven teeth
40
Optional driver shaft speed
1,000
You get
N1
20
N2
40
Gear ratio
2
Ratio
2

A gear ratio calculator turns two tooth counts into the dimensionless transmission ratio that links shaft speeds in a simple meshed pair. Enter the number of teeth on the driver (input) gear N1 and on the driven (output) gear N2; the tool returns gear ratio GR equals N2 over N1, the reciprocal velocity ratio used as a speed multiplier, a human-readable ratio string, a transmission class of reduction, overdrive, or one-to-one, the closed formula, a short English message, and ordered substitution steps.

What gear ratio means for a simple two-gear mesh

In a simple external mesh the driver gear is the input wheel that you turn or that a motor turns, and the driven gear is the output wheel that follows. If the driver has N1 teeth and the driven has N2 teeth, each full revolution of the driver advances exactly N1 teeth along the pitch circle, so the driven must turn by N1 over N2 of a revolution.

The standard gear ratio GR is therefore defined as N2 divided by N1: when GR is greater than one the pair is a speed reduction (driven larger, output slower, ideal torque multiplies by GR neglecting losses); when GR is less than one the pair is an overdrive (driven smaller, output faster); when GR equals one the pair is a one-to-one mesh with equal tooth counts.

The velocity ratio, sometimes called the speed ratio multiplier, is the reciprocal N1 over N2 and is exactly the factor that scales input speed into output speed. Classroom problems and many online search intents phrase the same idea as “teeth ratio” or “gear reduction calculator”; this tool sticks to the closed forms above so results match textbook algebra rather than approximate diameter ratios.

External spur and helical pairs reverse rotation sense, while internal meshes keep the same sense; this calculator reports magnitudes and ratio class only—it does not encode rotation direction or efficiency. Zero teeth is not a physical gear: both tooth counts must be strictly positive finite numbers, and any zero or non-positive value is a hard validation failure.

Robotics and hobby gearbox sizing

Makers plug pinion and spur tooth counts plus motor RPM to estimate shaft output speed and pick a reduction stage without opening CAD.

What is gear ratio for two meshed gears?

For a driver with N1 teeth and a driven gear with N2 teeth, gear ratio GR = N2/N1.

Is a ratio greater than 1 a reduction or an overdrive?

GR > 1 means reduction (driven has more teeth, output turns slower). GR < 1 means overdrive.

Is the gear ratio calculator free?

The browser tool is free and runs locally.

How do I work out the output speed of a gear pair?

Enter the input shaft speed along with both tooth counts. The output speed is the input speed times driver teeth over driven teeth, so 1000 rpm with 20 and 40 teeth gives 500 rpm, in the same unit you entered.

Does the calculator show the direction of rotation?

No. It reports the size of the ratio and whether the pair is a reduction, an overdrive or one-to-one. Keep in mind that an external pair reverses the turning direction while an internal mesh keeps it; losses are not included either.

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.

POSThttps://api.kit.forhosting.com/sci/gear-ratio

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.

curl -X POST https://api.kit.forhosting.com/sci/gear-ratio \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"driver_teeth":20,"driven_teeth":40}'
{
  "driver_teeth": 20,
  "driven_teeth": 40
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "sci.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.

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

max_abs1000000000000
HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

Optionally add input shaft speed in any consistent unit (commonly RPM) to receive matching output speed from n_out equals n_in times N1 over N2. Zero or non-positive tooth counts are rejected with a clear invalid_input error so the API never silently divides by zero or invents a mesh.

How to call the API and what comes back

Both tooth counts must be strictly positive; values at or below zero—including exact zero teeth—are rejected. Send a JSON body with two required finite numbers: driver_teeth (aliases N1, teeth_driver, driver, and pinion_teeth) and driven_teeth (aliases N2, teeth_driven, driven, and gear_teeth). Absolute values must stay within the published limit of one trillion so quotients remain finite in IEEE double precision on the Worker and in the browser. Optionally include input_speed (aliases driver_speed, rpm_in, omega_in, and n1) as a finite signed number in the same unit you expect for output_speed, typically revolutions per minute. On success the response echoes rounded driver_teeth and driven_teeth, mirrors them as N1 and N2, sets gear_ratio and ratio to the same rounded GR equals N2 over N1, velocity_ratio to N1 over N2, ratio_string to an N2:N1 style label, transmission to one of reduction, overdrive, or 1:1, formula to the string GR equals N2 over N1, message to a short English summary, and steps to an ordered array of substitution lines. When input_speed is provided the response also includes input_speed, output_speed, and speed_formula for n_out equals n_in times N1 over N2. Failed validation—missing fields, non-finite numbers, values outside absolute limits, non-finite ratio or speed, or zero teeth—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 related searches

Keep tooth counts and speeds inside the published absolute range so N2 over N1 and the scaled output speed cannot overflow into non-finite values that the solver must reject. Prefer this capability when you already have N1 and N2 for a single mesh; if your source is a multi-stage box, multiply stage ratios offline or chain calls. Prefer sending JSON numbers when you control the client; string numbers are accepted only when they match a strict finite numeric pattern, which keeps paste-from-spreadsheet paths working without accepting arbitrary text. Pair classroom examples deliberately: twenty driver teeth and forty driven teeth yields GR equals two and a reduction; forty driver and twenty driven yields GR equals one half and overdrive; equal counts yield one-to-one; and driver_teeth equals zero demonstrates the hard invalid_input path for zero teeth. When you only need the dimensionless ratio, omit input_speed; when you already know motor RPM from a nameplate, send it so homework and firmware tests can assert both GR and n_out in one call. This landing targets people searching for a gear ratio calculator, driver and driven teeth ratio, gearbox reduction calculator, or output speed from tooth counts online; it is not a full multi-stage compound train solver, not a module or diametral-pitch geometry tool, and not a power-loss or efficiency estimator. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when learners deliberately pass zero teeth. Round-trip checks are easy: recompute N2 divided by N1 by hand and confirm it equals the published gear_ratio within the same twelve-decimal rounding, and confirm that n_out equals n_in times N1 over N2 when speed is supplied.

Homework checks for GR = N2/N1

Students enter driver and driven tooth counts from textbook problems and compare hand-written gear ratio, velocity ratio, and reduction class against deterministic JSON before submitting.

Firmware unit tests for drivetrain math

Generate known-good reduction, overdrive, and 1:1 cases plus deliberate zero-teeth rejections for embedded transmission expected values.

What happens if a gear has zero teeth?

Zero (or non-positive) tooth counts are invalid. This tool returns invalid_input instead of dividing by zero.

Do I have to provide input speed?

No. Tooth counts alone return gear_ratio and velocity_ratio. Add input_speed only when you need output_speed in the same unit.

Read the full KIT documentation →