Simple lookback time calculator
Estimate how long ago the light from a nearby galaxy set off: a redshift of 0.05 with a Hubble time of 14 billion years gives about 700 million years. Meant for small redshifts and quick checks. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Z
- 0.05
- Hubble time years
- 14,000,000,000
- Lookback time years
- 700,000,000
- Redshift
- 0.05
- Approximation
- linear_low_redshift
This simple lookback time calculator estimates how long light has been travelling from an object at low cosmological redshift. Enter the dimensionless redshift z and a Hubble time expressed in years. The calculator applies the linear relation t = z × Hubble time and returns the estimate in years. It is useful for quick checks, classroom exercises, and rough comparisons when z is small. It is not a full cosmological model and should not replace an expansion-history integral for distant objects or precision research.
What the low-redshift estimate means
Lookback time is the elapsed time between the emission of the light observed today and the present. In an expanding universe, redshift provides a clue to that elapsed time, but the exact relationship depends on the expansion history and cosmological parameters. At sufficiently low redshift, the first-order relationship is especially simple: multiply z by the Hubble time.
If z is 0.05 and the adopted Hubble time is 14 billion years, the estimate is 700 million years. This calculator performs precisely that multiplication and reports the result in years. The method is best understood as a local, linear approximation rather than a complete description of cosmology.
It deliberately does not assume values for matter density, dark-energy density, radiation, or curvature. That makes the result easy to reproduce and useful for an order-of-magnitude check. It also means the user remains responsible for deciding whether a given redshift is low enough for the approximation required by the task.
Choose and enter the two inputs
Provide z as a dimensionless, non-negative number and provide the Hubble time in years. Redshift zero produces a lookback time of zero, as expected for the linear formula. A negative z is rejected because this capability is designed specifically for cosmological lookback estimates based on positive low redshift, not for interpreting blueshifted nearby objects.
The Hubble time must be greater than zero. You may enter a value derived from the Hubble constant used in your course, paper, or calculation, or use a rounded reference such as 14 billion years when only a rough estimate is needed. Keep the units consistent: because the result is returned in years, the supplied Hubble time must also be in years.
The calculator does not silently convert gigayears, seconds, or kilometres per second per megaparsec. Stating the adopted Hubble time alongside a reported result makes the estimate transparent and reproducible for other readers.
Know when to use a fuller cosmological calculation
As redshift grows, the universe changes appreciably during the light's journey, so a simple constant Hubble-time scaling becomes less accurate. Precision work normally computes lookback time by integrating a cosmological expansion model with specified values of the Hubble constant and density parameters. Use such a model when analysing distant galaxies, comparing observational catalogues, fitting cosmological parameters, or quoting uncertainties that matter scientifically.
This calculator is better suited to a sanity check, an introductory explanation, or a fast estimate before a detailed analysis. Its output includes the inputs, formula label, and approximation label so downstream code can preserve that context instead of presenting the number as an exact age. When communicating the result, call it an approximate low-redshift lookback time and retain sensible significant figures rather than implying more precision than the inputs support.
What you can do with it
Check an astronomy exercise
Verify a hand calculation of the first-order lookback time from a supplied redshift and Hubble time.
Estimate a nearby galaxy's light-travel history
Get a quick order-of-magnitude time estimate for a low-redshift object before using a full cosmology calculator.
Add a transparent approximation to a pipeline
Automate the deterministic linear estimate while retaining the exact redshift, Hubble time, and method in the output.
FAQ
What formula does the calculator use?
It uses lookback time in years = z × Hubble time in years. This is the first-order low-redshift approximation.
Why must redshift be non-negative?
This capability targets cosmological lookback time for positive low redshift. Negative z describes blueshift and is outside this calculator's intended approximation.
Which unit should I use for the Hubble time?
Enter the Hubble time in years because the returned lookback time is in years. Convert gigayears or other units before submitting the input.
Is this accurate at high redshift?
No. At higher redshift, use a cosmological lookback-time integral with explicit expansion and density parameters.
What is lookback time?
It is the time between the moment the light we see today left its source and now. For small redshifts it is close to the redshift multiplied by the Hubble time.
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/astro/lookback-time-lowz \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"z":0.05,"hubble_time_years":14000000000}'const res = await fetch("https://api.kit.forhosting.com/astro/lookback-time-lowz", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"z": 0.05,
"hubble_time_years": 14000000000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/astro/lookback-time-lowz",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"z": 0.05,
"hubble_time_years": 14000000000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/astro/lookback-time-lowz", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"z":0.05,"hubble_time_years":14000000000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"z":0.05,"hubble_time_years":14000000000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/astro/lookback-time-lowz", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"z": 0.05,
"hubble_time_years": 14000000000
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "astro.lookback_time_lowz",
"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
Know when to use a fuller cosmological calculation
The linear expression is most useful close to z = 0, where higher-order terms in the redshift–time relationship are comparatively small.
Technical questions
What does the API request cost?
Each API request costs $0.002. The same deterministic calculation can also run free in the browser.