Rads to RPM: The Exact Formula and How to Convert Angular Velocity

Control loops, simulation tools, and physics equations report angular velocity in radians per second. Motor nameplates, tachometers, and mechanical drawings report RPM. Engineers cross between the two dozens of times a day, and every manual switch invites a dropped factor or a slipped decimal.

The exact conversion factor is 30/π — an irrational number you can never write out in full. Rounding it to 9.549 feels harmless, yet that truncation compounds inside PID loops, gear-ratio math, and torque-speed curves until a "small" error turns into a real one. Keep π in the math and let software carry the precision: you can convert any rad/s value to RPM with full precision in one step, or follow the derivation below to do it by hand with confidence.

What rad/s and RPM actually measure

Both units describe rotational speed, but they count different things. RPM counts whole revolutions completed each minute, which is why it reads naturally on a gauge. Radians per second measures the angle swept each second, where one full turn equals 2π radians.

That difference matters the moment you reach for an equation. Angular velocity, centripetal acceleration, and rotational kinetic energy are all defined in terms of radians, so rad/s drops straight into the formula while RPM needs converting first.

Why rad/s is the SI and calculus favorite

The radian is the SI unit of angle, and it is the only angle measure where the derivative of sin(θ) is cos(θ) without an extra constant. Calculus, differential equations, and control theory all assume radians, so rad/s is the native language of any rotational model.

RPM survives because it is human-readable. A technician reading "3,000 RPM" pictures the speed instantly; "314 rad/s" means little on a shop floor. The two units serve different audiences, which is exactly why the conversion never goes away.

The 30/π derivation

Start from the definitions. One revolution is 2π radians, and one minute is 60 seconds. To turn radians per second into revolutions per minute, multiply by 60 seconds per minute and divide by 2π radians per revolution.

That gives RPM = rad/s × 60 ÷ 2π. The 60 and the 2 simplify, leaving the compact form RPM = rad/s × 30/π. Nothing was approximated — this identity is exact.

The exact decimal value

Evaluating 30/π gives 9.5492965855…, with digits that never repeat or terminate. The factor is irrational because π is irrational, so any decimal you write is already a rounding.

This is the number most reference tables abbreviate to 9.549, and it is where avoidable error sneaks in.

Why 9.549 loses precision

Using 9.549 instead of the full factor introduces an error of about two parts per hundred thousand on a single conversion. One conversion, no problem. But drive calculations rarely stop at one step.

Chain that rounded factor through a gear train, a transmission ratio, and a feedback loop, and the errors stack in the same direction. The fix costs nothing: write the factor as 30 / Math.PI and the language keeps every available digit.

Related conversions you will reach for

The same geometry links the neighboring units. Frequency in hertz is revolutions per second, so Hz = rad/s ÷ 2π = RPM ÷ 60. Degrees per second scales rad/s by 180/π. The rotation period — the time for one full turn — is Period = 2π ÷ rad/s = 60 ÷ RPM.

A spinning value of zero is the one edge case worth naming. At 0 rad/s the object is not rotating, so its period is infinite rather than zero.

The reverse formula

To go from RPM back to rad/s, multiply by the reciprocal: rad/s = RPM × π/30, where π/30 ≈ 0.1047197551. A car engine at 3,000 RPM runs at 3,000 × π/30 ≈ 314.16 rad/s.

Real motor speeds in both units

These reference points show how the two scales line up across everyday machines:

Keep π in your code

A correct, reusable implementation stays tiny:

// Keep π in the math — never hard-code 9.549.
const RADS_TO_RPM = 30 / Math.PI; // 9.5492965855…
const RPM_TO_RADS = Math.PI / 30; // 0.1047197551…

const toRpm = (radPerSec) => radPerSec * RADS_TO_RPM;
const toRadPerSec = (rpm) => rpm * RPM_TO_RADS;

toRpm(100); // → 954.9296585513721
toRadPerSec(3000); // → 314.1592653589793

Memorize the structure, not the digits. One revolution is 2π radians and one minute is 60 seconds — every factor on this page follows from those two facts, and π carries the rest.