ForHosting KIT · Engineering & construction

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
Use it from WebAPIEmailTelegramApp soon
If you enter
Input speed
1,000
Gear ratio
2
You get
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.

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.

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.

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/eng/gear-output-speed

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/eng/gear-output-speed \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input_speed":1000,"gear_ratio":2}'
{
  "input_speed": 1000,
  "gear_ratio": 2
}
{
  "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.

Per request$0.002

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

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.

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.

Drivetrain software fixtures

Generate deterministic n_out vectors for unit tests of configurators and control software that consume gear_ratio and n_in.

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.

Read the full KIT documentation →