Space travel time dilation
At 60% of light speed the Lorentz factor is 1.25, so clocks aboard run at 0.8 times the Earth rate. Enter the speed as a fraction of c, and the time measured aboard if you have it, to see how much time passes on Earth. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Velocity
- 0.6
- Lorentz factor
- 1.25
- Clock rate
- 0.8
A space travel time dilation calculator converts a spacecraft's speed, given as a fraction of the speed of light, into the Lorentz factor of special relativity. That factor, written gamma, is one divided by the square root of one minus beta squared, where beta is velocity over c. Clocks that travel with the ship accumulate less proper time than clocks that stay behind, and the ratio of those two times is exactly gamma.
What the Lorentz factor means for space travel
The Lorentz factor is the number that special relativity assigns to a constant-velocity boost. If a spacecraft moves at speed v relative to an inertial Earth frame, and c is the speed of light in vacuum, the dimensionless speed is beta equals v divided by c. Time dilation then says that a clock at rest on the ship measures proper time tau while Earth clocks measure coordinate time t, related by t equals gamma times tau, where gamma equals one over the square root of one minus beta squared.
At rest, beta is zero, the remainder under the square root is one, and gamma is one: both clocks agree. At sixty percent of light speed, beta squared is 0.36, the remainder is 0.64, the square root is 0.8, and gamma is 1.25, so Earth records twenty-five percent more elapsed time than the crew. At eighty percent of light speed gamma is five thirds, and at ninety-nine percent of light speed gamma is already about seven.
The same factor also stretches energy and longitudinal momentum, but this capability reports the kinematic clock effect only. Velocity must stay strictly below the speed of light: at light speed the remainder under the square root is zero and gamma diverges; above light speed the remainder is negative and gamma is not a real number. Negative speeds are rejected as well, because beta here is a speed ratio, not a signed velocity component.
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 twin-paradox checks
Students enter β from textbook problems and compare hand-written γ and t = γτ against a deterministic Lorentz factor before submitting relativity homework.
Science-fiction worldbuilding consistency
Authors and game designers pin a cruise speed as a fraction of c and read off how much younger the crew is than Earth after a given proper time.
FAQ
What formula does this space travel calculator use?
The special-relativity Lorentz factor γ = 1 / sqrt(1 − β²), with β = v/c. Clocks aboard the ship run at 1/γ times the Earth-frame rate.
What happens if velocity equals or exceeds light speed?
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 space travel time dilation calculator free?
The browser tool is free and runs locally.
How do I find how much time passes on Earth during the trip?
Add the time measured aboard the ship, in any unit you like. The calculator multiplies it by the Lorentz factor and gives the Earth time in the same unit, so at 60% of light speed Earth records a quarter more time than the crew.
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/space-travel \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"velocity":0.6}'const res = await fetch("https://api.kit.forhosting.com/phys/space-travel", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"velocity": 0.6
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/phys/space-travel",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"velocity": 0.6
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/phys/space-travel", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"velocity":0.6}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"velocity":0.6}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/phys/space-travel", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"velocity": 0.6
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "phys.space_travel",
"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
Enter a finite non-negative speed strictly below light speed and the endpoint returns gamma, the reciprocal clock rate aboard the craft, and—when you also send a proper time—the matching Earth-frame duration. If velocity equals or exceeds light speed the formula is undefined, so the task fails with invalid_input instead of a NaN.
What the Lorentz factor means for space travel
Those cases are not physical for a massive spacecraft, so the solver rejects them with invalid_input rather than returning Infinity or a complex value.
How to call the API and what comes back
Send a JSON body with one required finite number and one optional duration. The required field is velocity, with aliases beta, v_over_c, v_c, and velocity_c: the spacecraft speed as a fraction of light speed, so 0.6 means sixty percent of c and not 0.6 metres per second. It must be a finite number satisfying zero less than or equal to velocity and velocity strictly less than one. The optional field is proper_time, with aliases tau and ship_time: a non-negative duration measured aboard the spacecraft in any consistent time unit you choose. When proper_time is omitted it is not echoed and no Earth-frame duration is computed, matching the rule that optional output keys are omitted rather than set to null. When proper_time is present the response includes earth_time equal to gamma times that proper time in the same unit. Absolute proper_time must stay within the published limit of one trillion so the product remains finite in IEEE double precision on the Worker and in the browser. On success the body echoes rounded velocity, sets lorentz_factor to gamma, clock_rate to one over gamma (the rate at which ship clocks run relative to Earth), formula to the canonical gamma string, message to a short English summary, and steps to an ordered list of substitution lines you can assert in tests. Failed validation—missing velocity, non-finite numbers, negative velocity, a velocity that equals or exceeds light speed, or a proper_time that is negative or non-finite—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item.
Practical tips, limits, and related searches
Keep beta comfortably below one if you need a modest Lorentz 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 space-travel calculator for the relativistic ratio, not a unit converter from metres per second. Prefer this capability when you already have v over c and only need gamma, plus optionally Earth time from proper time. 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. When teaching, pair examples: velocity zero is a rest check with gamma equal to one; velocity 0.6 is the classic textbook case with gamma 1.25; velocity 0.8 with proper_time equal to one year shows one and two-thirds years on Earth; and velocity equal to one demonstrates the hard invalid_input path required by the product. This landing targets people searching for space travel time dilation, a Lorentz factor calculator, or how much younger a crew is after a fast interstellar trip. It is not a rocket-equation delta-v tool, not a light-travel-time delay from distance over c, and not a general-relativistic gravitational redshift calculator for clocks in a gravity well. 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 relativity helpers
Generate known-good rest, 0.6c, and 0.8c cases plus deliberate β = 1 rejections for coding kata expected values in simulation clocks.
Technical questions
Can I omit proper_time?
Yes. The Lorentz factor and clock rate are still returned. earth_time is included only when you send a non-negative proper_time.