Reaction time calculator
At 20 m/s, a driver who needs 1.5 s to react covers 30 m before touching the brake. Enter speed and reaction time to get the thinking distance, the stretch of road travelled before braking even begins. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Reaction time
- 1.5
- Speed
- 20
- Reaction distance m
- 30 m
This reaction time calculator finds how far a vehicle travels while a driver is still reacting, before the brakes are applied. Highway-code tables, fleet trainers, physics homework, and safety simulators all need that number separately from braking distance, because perception-reaction delay is a human interval, not a tire-road deceleration. The engine is fully deterministic arithmetic: no network calls, no sampling, and no date-dependent shortcuts.
What reaction distance means and which quantities determine the answer
In driver training and highway safety, reaction distance — also called thinking distance or perception-reaction distance — is the length of road a vehicle covers at constant speed while the driver is still perceiving a hazard and deciding to apply the brakes. Until the brake pedal actually moves, the vehicle has not begun the deceleration that produces braking distance, so the two segments add rather than replace each other. Under constant speed the identity is elementary: distance equals speed times elapsed reaction time.
If speed is in metres per second and reaction time is in seconds, the product is metres. Search intent clusters around phrases such as reaction time calculator, driver reaction distance, thinking distance from speed, perception-reaction time, and how far you travel before braking. People want a numeric length they can check against a highway-code table, embed in a fleet briefing, or feed into a simulation, not only a reminder that the formula exists.
Zero or negative reaction time is invalid because a human perception-reaction interval must be a positive duration; missing or non-numeric fields fail the same way so a bad cell never becomes a silent zero distance. Keep units consistent: convert kilometres per hour to metres per second by dividing by 3.6 before calling, otherwise the product is dimensionally wrong.
Where reaction distance fits in training, study, and software
Use the browser tool when you want an immediate thinking distance while checking a highway-code worksheet, comparing a one-second alert driver with a two-and-a-half-second design value, briefing a fleet on wet-night hazards, or sanity-checking a game-physics constant for the delay before brakes apply. Choose units consistently — if speed is still in kilometres per hour, convert before calling so time in seconds and distance in metres share the SI metre-second basis.
There is no language model, no external traffic or weather service, and no randomness, so the capacity is safe to pin in continuous-integration checks and reproducible lesson materials. Remember that real-world total stopping distance often adds a braking-distance term of speed squared over twice the deceleration; this calculator isolates the reaction segment only, which is a different search intent from a braking-distance tool and a different number to report on a training card.
What you can do with it
Highway-code and classroom thinking-distance drills
Students and graders confirm how far a vehicle travels during a given reaction time at a stated speed, with clear rejection when reaction time is zero, negative, missing, or non-numeric.
Fleet and driver-training scenarios
Compare alert versus delayed reaction times at the same speed so briefings show how thinking distance grows linearly before any braking begins.
FAQ
Which formula does the reaction time calculator use?
Constant-speed travel during the perception-reaction interval: d = v × t, where v is vehicle speed and t is reaction time. Braking, variable speed, and tire-road friction are not modeled.
What happens if reaction time is zero or negative?
Reaction time must be a positive number; zero or negative intervals are not billed and no distance is returned.
How is this different from a braking distance calculator?
Braking distance is v²/(2a) while the vehicle is decelerating. Reaction distance is v×t while the driver is still reacting. Total stopping distance is the sum of both segments.
How do I use a speed in km/h?
Divide it by 3.6 first to get metres per second, then enter it. Otherwise speed and time do not share the same basis and the distance comes out wrong.
What reaction time should I assume?
It depends on the case you are checking. A common comparison puts an alert driver at about one second against a cautious design value of two and a half seconds.
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/phys/reaction-time \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"reaction_time":1.5,"speed":20}'const res = await fetch("https://api.kit.forhosting.com/phys/reaction-time", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"reaction_time": 1.5,
"speed": 20
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/phys/reaction-time",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"reaction_time": 1.5,
"speed": 20
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/phys/reaction-time", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"reaction_time":1.5,"speed":20}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"reaction_time":1.5,"speed":20}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/phys/reaction-time", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"reaction_time": 1.5,
"speed": 20
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "phys.reaction_time",
"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 | 1000000000000000 |
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
The closed-form identity is reaction distance equals speed times reaction time: if you know the vehicle speed in metres per second and a strictly positive reaction time in seconds, the product is the thinking distance in metres.
What reaction distance means and which quantities determine the answer
This calculator returns the validated reaction_time and speed, the reaction_distance_m, a formula tag d=v*t, a method tag reaction_time, and the unit m. There is no tire-road lookup and no numerical integration: the engine either multiplies two finite numbers inside the supported range or rejects the input with invalid_input.
How this calculator validates input and applies d = v × t
Numeric strings that parse to finite numbers are allowed so forms and CSV-style pipelines can pass values without an extra cast. Zero would claim the driver reacted in no time at all; a negative interval is not a physical perception delay, so both cases are rejected with a message that names the field and states that reaction time must be a positive number. Speed must be non-negative: zero speed yields zero reaction distance, which is physically consistent with a parked vehicle. Magnitudes above the documented ceiling are refused so overflow cannot masquerade as a huge road length. There is no friction model, no alcohol or fatigue table, and no add-on braking term; this is the ideal one-dimensional constant-speed interval from the two known inputs. Send a JSON body with required reaction_time and speed. The preferred field for the interval is reaction_time, but aliases time, t, reaction, thinking_time, and perception_time are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. Speed accepts aliases v, velocity, and vehicle_speed. Every field must be present and finite: missing keys, empty strings, non-numeric text, NaN, and Infinity all fail immediately with invalid_input before any distance is returned, and failed validation is not charged. After validation, reaction_time must be strictly positive. The distance is computed as speed times reaction_time, then rounded to a stable ten-decimal grid so the same input always yields the same JSON across JavaScript engines.
Where reaction distance fits in training, study, and software
Each successful request is one billable item at $0.002; failed validation does not consume balance. Results are fully deterministic: the same speed and reaction time always yield the same reaction_distance_m field. Wire the endpoint into safety drills, contest answer checkers, highway engineering worksheets, or preprocessing steps where you already prefer explicit domain errors — such as rejecting a non-positive reaction time — over opaque widgets that cannot explain why a bad input was refused.
Integration use cases
Deterministic fixtures for safety tests
Pipelines that seed unit tests or interactive driving demos can call a pure reaction-distance oracle instead of reimplementing d=v×t in every language.
Technical questions
How do I compute reaction distance from reaction time and speed?
Send a JSON body with reaction_time in seconds (must be positive) and speed in metres per second (non-negative). The response returns reaction_distance_m plus the validated inputs, formula, method, and unit.
What does the reaction time calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.