Angular velocity calculator
Sweeping 2π radians in 2 seconds is an angular velocity of π rad/s, or 30 rpm: enter an angle and a time, or just the RPM, and the calculator returns ω in radians per second with each step. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Angle swept in radians
- 6.2831853072
- Elapsed time in seconds
- 2
- Omega
- 3.1415926536 rad/s
- Angular velocity
- 3.1415926536
- Equation
- ω = 6.28318530718 / 2 = 3.14159265359 rad/s
- Theta
- 6.2831853072
An angular velocity calculator turns rotation rate into a single SI-friendly number: omega (ω) in radians per second. You can enter the angle swept in radians together with a non-negative elapsed time, or enter revolutions per minute (RPM) alone. The tool returns rounded omega, an English unit label, the formula used, a fully substituted equation line, a short physics message, ordered step strings, and—when you use the angle-time path—an equivalent RPM so lab notes and machine specs stay aligned. Signed angle and signed RPM encode rotation sense without a separate direction flag.
What angular velocity means: ω from angle and time, or from RPM
Angular velocity measures how fast an angle changes with time. If a rigid body or a point on a circle sweeps an angle theta (θ) measured in radians during an elapsed time t measured in seconds, the average angular velocity over that interval is exactly omega equals theta divided by t, with unit radians per second. One full turn is two pi radians, so a machine that completes n revolutions in one minute has RPM equal to n and angular velocity omega equals n times two pi divided by sixty.
Those two closed forms cover the searches people type most often: “angular velocity from angle and time” and “RPM to rad/s”. Theta may be positive or negative depending on the chosen positive rotation sense (right-hand rule in 3D textbooks, or a simple signed axis in planar problems); the same sign convention applies to RPM.
Time t is the duration of the interval and must be strictly positive for the angle-time path—negative t would reverse the causal reading of “over time t”, and t equal to zero would make the ratio undefined. When you already know shaft speed in revolutions per minute from a nameplate or tachometer, skip angle and time and send rpm alone; the calculator multiplies by two pi over sixty and returns omega in rad/s.
The tool does not convert degrees to radians for you: if your source angle is in degrees, multiply by pi over one hundred eighty first so that theta over t stays coherent. Likewise, if you measure time in milliseconds or minutes, convert to seconds before calling so the product of unit checks matches lab SI practice.
Practical tips, limits, and related searches
Use radians and seconds for the angle-time path, or bare RPM for the shaft-speed path; this landing does not perform unit conversion between degrees, revolutions, hours, or milliseconds. When teaching, keep the sign of omega aligned with the positive rotation axis you chose rather than treating “clockwise” as always negative without defining axes.
This page targets people searching for an angular velocity calculator, omega in rad/s, RPM to radians per second, or theta over t online; it is not a full rigid-body dynamics suite that solves Euler equations, not a variable angular-acceleration integrator, and not a degrees-to-radians converter by itself. Prefer this capability when you already know either swept angle and duration or shaft RPM and only need scalar omega; if your source problem gives linear tangential speed and radius, use omega equals v over r offline first.
Round-trip checks are easy: recompute theta divided by t or rpm times two pi over sixty by hand and confirm it equals the published omega within the same twelve-decimal rounding used in the response.
What you can do with it
Lab pre-check before multi-body dynamics
Pipelines validate scalar angular rate from θ and t or from RPM first, then branch to full attitude solvers only when the single-axis check matches lab notes.
FAQ
What formulas does the angular velocity calculator use?
From angle and time it uses ω = θ / t with θ in radians and t in seconds. From RPM it uses ω = rpm · 2π / 60. Both return rad/s.
Why is negative time rejected?
Elapsed time cannot be negative in this model.
Can angle or RPM be negative?
Yes. Negative θ or negative rpm means rotation opposite your positive sense. Only t is required to be non-negative (and strictly positive on the angle-time path).
Does this convert degrees to radians for me?
No. Convert degrees to radians yourself (multiply by π/180) before sending theta. The calculator evaluates ω = θ/t or the RPM formula only.
Is the angular velocity calculator free?
The browser tool is free and runs locally.
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/mech/angular-velocity \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"theta":6.283185307179586,"angle":-1000000000000}'const res = await fetch("https://api.kit.forhosting.com/mech/angular-velocity", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"theta": 6.283185307179586,
"angle": -1000000000000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/mech/angular-velocity",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"theta": 6.283185307179586,
"angle": -1000000000000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/mech/angular-velocity", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"theta":6.283185307179586,"angle":-1000000000000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"theta":6.283185307179586,"angle":-1000000000000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/mech/angular-velocity", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"theta": 6.283185307179586,
"angle": -1000000000000
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "mech.angular_velocity",
"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
Negative time is rejected with a clear invalid_input error because elapsed duration cannot run backward; zero duration is also rejected so the tool never silently divides by zero. Pricing is a flat $0.002 per successful API request; failed validation is never charged.
How to call the API and what comes back
Absolute values of theta and rpm must stay within the published limit of one trillion; t must be between zero and one trillion exclusive of the zero lower bound for the angle-time path. Send a JSON body with either rpm (aliases rev_per_min, revolutions_per_minute, and n) or both theta (aliases angle and phi) and t (aliases time and duration). When rpm is present it takes precedence so mixed payloads still resolve deterministically. The angle-time path also includes theta, t, and rpm_equiv (omega converted back to revolutions per minute). Failed validation—missing path fields, non-finite numbers, values outside absolute limits, non-finite omega, omega outside the absolute cap, negative t, or zero duration—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item and zero marginal unit price. Prefer sending JSON numbers when you control the client; string numbers are accepted only when they match a strict finite numeric pattern, which keeps homework-form paste paths working without accepting arbitrary text.
Practical tips, limits, and related searches
Keep theta, t, and rpm inside the published absolute range so the quotient theta over t and the product rpm times two pi over sixty remain finite in IEEE double precision on the Worker and in the browser. Pair classroom examples deliberately: one full turn in two seconds (theta equals two pi, t equals two) yields pi rad/s; sixty RPM yields two pi rad/s; negative angle over positive time demonstrates opposite rotation sense; and t equals negative one demonstrates the hard invalid_input path for negative time. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when learners deliberately pass negative t.
Integration use cases
Homework checks for ω = θ/t and RPM conversion
Students enter angle and time or a nameplate RPM and compare hand-written rad/s results and substitution steps against a deterministic JSON response before submitting.
CNC and motor drive unit tests
Generate known-good positive, negative, and sixty-RPM golden cases plus deliberate negative-time rejections for firmware and simulator expected values.