Reaction distance calculator
At 13.89 m/s with a 1.5 s reaction time, a car covers 20.835 m before the brakes even begin to work. Enter speed and reaction time to get this thinking distance, the first part of any stopping distance. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Speed
- 13.89
- Reaction time
- 1.5
- Reaction distance
- 20.835 m
- Precision
- 10
This reaction distance calculator multiplies driving speed by driver reaction time to find how far a vehicle travels before braking even starts. In road-safety and physics teaching, total stopping distance splits into two parts: reaction (thinking) distance at constant speed while the driver perceives a hazard and moves the foot to the pedal, then braking distance once deceleration begins. With speed in metres per second and time in seconds, the answer is in metres. Negative speed or reaction time is rejected rather than silently flipped, so a bad spreadsheet cell cannot become a nonsense positive distance. The engine is pure deterministic arithmetic: no network calls, no sampling, and no date-dependent shortcuts.
What reaction distance means and what you get
Reaction distance is the path length covered at roughly constant speed during the interval between detecting a hazard and the instant the brakes begin to slow the vehicle. It is not the full stopping distance: braking distance still depends on tyre friction, road surface, slope, and brake performance, and those effects belong in other tools such as friction stopping-distance calculators.
Typical classroom values use a reaction time near one to one and a half seconds and speeds converted from kilometres per hour or miles per hour into metres per second so that d is reported in metres. The tool does not convert units for you, choose a standard reaction time from age tables, or add a braking phase: you enter speed and reaction time in a consistent unit system, and it returns the product. Zero speed or zero reaction time is valid and yields zero distance.
Where reaction distance fits in study, driving education, and software
Students meet reaction distance when a road-safety chapter splits total stopping distance into thinking distance plus braking distance, when a worksheet gives a speed and a reaction time and asks how many metres pass before the brakes bite, or when a contest problem wants the pre-braking segment without a full vehicle-dynamics simulation. Teachers can pre-generate answer keys for modest speeds and reaction times without trusting opaque calculator apps that silently switch between kilometres per hour and metres per second.
Driver-education programs use the same identity to show why higher speed multiplies the gap before any deceleration begins, even when reaction time is held fixed. Developers call the contract from scripts to seed deterministic test vectors for driving simulators, to normalize user-entered hazard-response parameters before a full stopping-distance chain, or to satisfy programming-challenge statements that demand metres rather than a hand-waved sketch.
What you can do with it
Homework and theory tests
Compute reaction (thinking) distance from speed and reaction time before grading worksheets or comparing to textbook tables.
Driver education demos
Show how higher speed multiplies metres travelled before braking starts at a fixed reaction time.
FAQ
What does the reaction distance calculator cost?
It is free in your browser on this page.
Does this include braking distance?
No. Reaction distance ends when braking begins. For friction-based braking distance use a dedicated stopping-distance tool and add the two segments if you need total stopping distance.
Why are results rounded to a precision?
Default precision is 10 decimal places; you can set precision from 0 to 15.
How do I convert km/h to m/s for the reaction distance?
Divide the speed in kilometres per hour by 3.6 to get metres per second. Keep the reaction time in seconds and the result comes out in metres, matching textbook answers.
What reaction time should I use?
Classroom problems usually take a reaction time between one and one and a half seconds. The calculator does not pick a value for you, so enter the time your exercise or study gives.
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/reaction-distance \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"speed":13.89,"reaction_time":1.5}'const res = await fetch("https://api.kit.forhosting.com/mech/reaction-distance", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"speed": 13.89,
"reaction_time": 1.5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/mech/reaction-distance",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"speed": 13.89,
"reaction_time": 1.5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/mech/reaction-distance", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"speed":13.89,"reaction_time":1.5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"speed":13.89,"reaction_time":1.5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/mech/reaction-distance", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"speed": 13.89,
"reaction_time": 1.5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "mech.reaction_distance",
"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.
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
Given a non-negative speed v and a non-negative reaction time t_r, the closed form is simply d equals v times t_r.
What reaction distance means and what the response contains
Here the model is intentionally elementary: the driver (or automated system) continues at speed v for time t_r, so d equals v times t_r. The response includes the normalized inputs speed and reaction_time, the derived reaction_distance, the precision used for rounding, a method tag reaction_distance, a short formula reminder, and a unit hint m for SI inputs. There is no Monte Carlo model of distraction, no random human-factor noise, and no network lookup of traffic rules: the engine either multiplies two finite non-negative numbers inside the supported range or rejects the input with invalid_input. Rejected cases include a missing speed or reaction_time, non-finite values, magnitudes above the documented ceilings, and any negative speed or reaction time.
How speed and reaction time are read and how d stays reproducible
Zero is allowed and returns zero reaction distance. Optional leading plus signs and scientific notation on numeric strings are allowed when they parse as finite decimals; embedded spaces and non-numeric tokens are rejected. When you convert from kilometres per hour, divide by three point six to obtain metres per second before calling the calculator, and keep reaction time in seconds so that the product is in metres and matches textbook answer keys. The preferred field for driving speed is speed, but aliases v, velocity, initial_speed, and u are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. Speed must be finite and non-negative: a negative value fails with invalid_input and a message that names the field, so a bad cell does not become a silent absolute-value surprise. The preferred field for reaction time is reaction_time, with aliases t, time, t_r, reaction, and thinking_time. Reaction time must likewise be finite and non-negative; a negative duration is rejected with invalid_input because elapsed reaction time cannot go backward in this model. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for the numeric outputs, defaulting to ten and capped at fifteen so JSON goldens stay stable across runtimes. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing the product yourself.
Where reaction distance fits in study, driving education, and software
Product and education tools use the endpoint when a learner types a speed and a reaction time and the UI must show how far the vehicle coasts while the driver reacts. 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. Pair it with friction stopping-distance or following-distance helpers when you need the braking phase or a time-gap rule, and with other mechanics endpoints when you are building a small lab of free, deterministic physics calculators for traffic-safety lessons.
Integration use cases
Deterministic test fixtures
Generate reproducible d = v · t_r values for unit tests, driving sims, and CI assertions.
Technical questions
How is reaction distance defined here?
d = v × t_r, where v is non-negative driving speed and t_r is non-negative reaction time. With v in m/s and t_r in s, d is in metres. This is only the pre-braking segment, not full stopping distance.
What happens if speed or reaction time is negative?
The input is rejected with invalid_input. Negative speed or reaction time has no meaning for this model, so the API refuses the request rather than taking an absolute value.