Time dilation calculator
At 60% of light speed the Lorentz factor is 1.25, so one second on the moving clock lasts 1.25 seconds for the observer. Enter the proper time and the speed as a fraction of light speed to get the dilated time. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Proper time
- 1
- Velocity
- 0.6
- Lorentz factor
- 1.25
- Dilated time
- 1.25
A time dilation calculator converts a proper time interval and a relative velocity into the longer coordinate time that special relativity assigns to a clock moving with respect to an inertial observer. The relation is dilated time equals proper time divided by the square root of one minus beta squared, where beta is velocity over the speed of light, which is the same as multiplying proper time by the Lorentz factor gamma.
What time dilation means and how Δt = γ·Δτ is computed
The Lorentz transformation of special relativity implies that elapsed time depends on the inertial frame. If a clock is at rest in a frame that moves at constant speed v relative to an observer, the time that clock records between two events at the same place in its rest frame is the proper time, written tau. The observer, who sees the clock in motion, assigns a longer coordinate time to that same pair of events.
The exact factor is the Lorentz factor gamma, one divided by the square root of one minus beta squared, where beta is v divided by the speed of light c. Therefore dilated time equals gamma times proper time, or equivalently proper time divided by the square root of one minus v squared over c squared. At rest, beta is zero, gamma is one, and both clocks agree.
At sixty percent of light speed, beta squared is 0.36, the remainder under the square root is 0.64, the square root is 0.8, and gamma is 1.25, so one second of proper time becomes 1.25 seconds of dilated time in the observer frame. At eighty percent of light speed gamma is five thirds, and a ten-second proper interval dilates to sixteen and two-thirds seconds.
Velocity must stay strictly below the speed of light: at light speed the remainder is zero and gamma diverges; above light speed the remainder is negative and gamma is not a real number. Numerically the implementation uses the factored remainder (one minus beta) times (one plus beta) so that values close to one do not lose every significant digit in a single subtraction of two nearly equal squares, which is the usual floating-point trap in a naive one-minus-beta-squared evaluation.
What you can do with it
Classroom special-relativity homework
Students enter Δτ and β from textbook problems and compare hand-written dilated time Δt = γΔτ against a deterministic oracle before submitting relativity homework.
Muon-lifetime and beam-line thought experiments
Lab instructors pin a fraction of c and a proper lifetime and read off how much longer the lab-frame clock runs, without standing up a computer-algebra system.
FAQ
What formula does this time dilation calculator use?
Special-relativity time dilation Δt = Δτ / sqrt(1 − β²) = γ · Δτ, with γ = 1 / sqrt(1 − β²) and β = v/c. Dilated time is returned in the same unit as proper time.
What happens if velocity is not below the speed of light?
The Lorentz factor is undefined for β ≥ 1.
Is velocity in metres per second or as a fraction of c?
As a fraction of light speed. Send 0.6 for 60% of c, not 1.8e8 m/s. Divide your SI speed by c yourself if you start from metres per second.
Is the time dilation calculator free?
The browser tool is free and runs locally.
How long does a 10-second interval last at 80% of light speed?
For the observer it lasts sixteen and two-thirds seconds. At 80% of light speed the Lorentz factor is five thirds, and the calculator multiplies the proper time by it, giving the result in the same unit you entered.
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/time-dilation \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"proper_time":1,"velocity":0.6}'const res = await fetch("https://api.kit.forhosting.com/phys/time-dilation", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"proper_time": 1,
"velocity": 0.6
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/phys/time-dilation",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"proper_time": 1,
"velocity": 0.6
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/phys/time-dilation", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"proper_time":1,"velocity":0.6}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"proper_time":1,"velocity":0.6}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/phys/time-dilation", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"proper_time": 1,
"velocity": 0.6
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "phys.time_dilation",
"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_time | 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
Enter a non-negative finite proper time in any consistent unit and a relative speed as a fraction of light speed that is strictly below one; the endpoint returns the dilated time in that same unit, together with gamma. If velocity is not below the speed of light the Lorentz factor is undefined for a massive clock, so the task fails with invalid_input instead of Infinity or a complex number.
What time dilation means and how Δt = γ·Δτ is computed
Those cases are not physical for a massive clock, so this solver rejects them with invalid_input rather than returning Infinity.
Input contract, response shape, and error behaviour
Optional output keys are omitted rather than set to null. Send a JSON body with two required finite numbers. The first is proper_time, with aliases tau, proper, delta_tau, and time: the interval measured by the moving clock, in any consistent time unit you choose, whether seconds, years, or ticks. It must be a non-negative finite number whose absolute value stays within the published limit of one trillion so the product with gamma remains finite in IEEE double precision on the Worker and in the browser. The second is velocity, with aliases v, speed, beta, v_over_c, and v_c: the relative speed as a fraction of light speed, so 0.6 means sixty percent of c and not 0.6 metres per second. It must satisfy zero less than or equal to velocity and velocity strictly less than one. On success the body echoes rounded proper_time and velocity, sets lorentz_factor to gamma, dilated_time to gamma times proper time in the same unit as the input, formula to the canonical special-relativity string, and steps to an ordered list of substitution lines you can assert in tests. Failed validation—missing fields, non-finite numbers, negative proper_time, negative velocity, or a velocity that is not below the speed of light—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item. Prefer JSON numbers over pre-formatted strings when you control the client; string numbers are accepted only when they match a strict finite numeric pattern with an optional exponent.
Practical tips, units, and related searches
Keep beta comfortably below one if you need a modest dilation factor; as velocity approaches the speed of light, gamma grows without bound and tiny input changes produce large output changes that still have to stay finite. Do not paste a kilometres-per-second figure into velocity unless you have already divided by c: this form is a textbook time-dilation calculator for the dimensionless ratio, not a unit converter from metres per second. Prefer this capability when you already have both a proper interval and v over c and you need the dilated interval itself. The dilated time is returned in the same unit as proper_time, so if you send years you get years, and if you send nanoseconds you get nanoseconds. When teaching, pair examples: velocity zero is a rest check with dilated time equal to proper time; velocity 0.6 with proper time one is the classic textbook case with dilated time 1.25; velocity 0.8 with proper time ten yields sixteen and two-thirds; and velocity equal to one demonstrates the hard invalid_input path required by the product. This landing targets people searching for a time dilation calculator, the formula that dilated time equals gamma times proper time, or how much longer a rest-frame clock runs compared with a moving clock. It is not a gravitational redshift tool for clocks in a gravity well, not a light-travel-time delay from distance over c, and not a spacecraft Lorentz-factor page that can omit proper time. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when learners deliberately set velocity to one.
Integration use cases
Unit tests for simulation clocks
Generate known-good rest, 0.6c, and 0.8c dilated-time cases plus deliberate β = 1 rejections for coding kata expected values in relativistic clock helpers.
Technical questions
What units does proper_time use, and what unit is dilated_time?
Any consistent time unit. Send seconds, years, or ticks; dilated_time uses that same unit. Velocity is a fraction of c, not metres per second.