Hubble time calculator
With a Hubble constant of 70 km/s/Mpc, the Hubble time is 13.9684603097 billion years, the reciprocal of today's expansion rate. Enter the Hubble constant to get this characteristic expansion timescale in years, gigayears and seconds. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Hubble constant
- 70
- Hubble time years
- 13,968,460,309.7
- Hubble time gyr
- 13.9684603097
- Hubble time seconds
- 440,811,083,070,000,000
Hubble time is the characteristic expansion timescale of the universe obtained by taking the reciprocal of the present-day Hubble constant and converting that inverse rate into years. In the simple linear picture, if expansion had always proceeded at today's rate, a naive cosmic age would sit near this Hubble time; modern cosmology adjusts that estimate with matter and dark-energy densities, but textbooks, homework, and outreach still quote t_H equals one over H0 as the first-order expansion clock.
What Hubble time means and how it becomes years
The Hubble constant H0 measures how fast the scale factor of the universe expands today; its SI units are inverse time, even when observers quote it as kilometres per second per megaparsec. The Hubble time is simply the reciprocal of that rate: t_H equals one divided by H0. When H0 is given in kilometres per second per megaparsec, convert distance to kilometres with a fixed megaparsec-to-kilometre factor, divide by H0 to obtain seconds, then divide by the length of a Julian year to obtain years.
Modern determinations of H0 typically fall near sixty-seven to seventy-four kilometres per second per megaparsec depending on the probe; homework sets often fix seventy for clean arithmetic. At H0 equals seventy, the Hubble time sits near fourteen billion years, which is why introductory courses treat t_H as a first-order age estimate before introducing full Friedmann integrals. This page intentionally stops at the characteristic expansion timescale; a full age-of-universe integral that depends on matter density, dark-energy density, radiation, and curvature is a separate search intent and a separate landing.
Non-positive Hubble constants are rejected because a zero or negative expansion rate does not define a positive physical timescale under this definition.
Where a Hubble time calculator shows up in real work
Secondary-school and introductory university cosmology units ask students to convert a quoted Hubble constant into an expansion timescale and to discuss why that number is only a rough cosmic age. Science communicators place Hubble time next to headlines about H0 tension, showing how a few kilometres per second per megaparsec shift the reciprocal by hundreds of millions of years. Data pipelines that annotate survey metadata sometimes store a simple expansion timescale alongside the adopted H0 for audit trails.
If you later need luminosity distance from redshift, linear Hubble-law galaxy distance from recession velocity, or a full age-of-universe integral under a Lambda-CDM cosmology, treat those as separate search intents and landings rather than overloading this Hubble time calculator page.
What you can do with it
Homework and exam answer keys
Convert a textbook Hubble constant into t_H in years and gigayears so students and auto-graders share one closed-form expansion timescale.
Outreach and H0 tension demos
Show how shifting H0 across local versus CMB-style values changes the characteristic expansion timescale by hundreds of millions of years.
Notebook H0 sensitivity sweeps
Hold a pipeline on pure 1/H0 while sweeping modern H0 estimates before invoking full cosmological age integrators.
FAQ
What happens if the Hubble constant is zero or negative?
Hubble time is the reciprocal of H0 converted to years; non-positive H0 is undefined and is never turned into Infinity or NaN.
Is Hubble time the same as the age of the universe?
No. Hubble time is only the characteristic expansion timescale 1/H0. A full cosmic age depends on matter, dark energy, and other density parameters under an FLRW model.
Which year definition do you use?
Julian years of 365.25 days (31,557,600 seconds). Results are also returned in gigayears and raw seconds for SI-scale checks.
What does it cost?
The browser tool is free and runs locally.
How does a different Hubble constant change the result?
A lower Hubble constant gives a longer Hubble time, because the result is its reciprocal. At 70 km/s/Mpc it is 13.9684603097 billion years; a slightly smaller constant gives a slightly longer timescale.
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/hubble-time \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"hubble_constant":70}'const res = await fetch("https://api.kit.forhosting.com/astro/hubble-time", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"hubble_constant": 70
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/astro/hubble-time",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"hubble_constant": 70
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/astro/hubble-time", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"hubble_constant":70}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"hubble_constant":70}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/astro/hubble-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
{
"hubble_constant": 70
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "astro.hubble_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.
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
What Hubble time means and how t_H = 1/H0 is converted to years
That closed form is what this capability evaluates: no random seeds, no wall-clock timestamps, no network calls, and no model drift, so identical inputs always produce identical JSON.
What you send and what you get back
Use H0 in kilometres per second per megaparsec in the usual convention—for example seventy for many textbook drills, sixty-seven point four for a Planck-era reference, or seventy-three for a local-distance-ladder style value. Classic checks include seventy kilometres per second per megaparsec recovering roughly thirteen point nine seven gigayears, and sixty-seven point four recovering a slightly longer timescale because lower H0 means a longer reciprocal. Wire the free browser form for homework and outreach demos, then call the identical contract from scripts when you need bulk answer keys, sensitivity tables, or grading oracles. Send one required finite number under the field hubble_constant. Missing fields, non-numeric strings, NaN, Infinity, zero, and negative values fail with invalid_input and are not charged. On success the response echoes the cleaned hubble_constant, returns hubble_time_years as the primary result in Julian years, hubble_time_gyr as the same interval in gigayears for easy comparison with cosmic-age tables, hubble_time_seconds as the SI-scale reciprocal before year conversion, includes a units hint object, sets method to hubble_time, formula to t_H equals one over H0, and a short note stating that the result is the characteristic expansion timescale only, not a full Lambda-CDM age integral. Pricing for successful API calls is the published base of $0.002 per item; validation failures do not consume prepaid balance.
Where a Hubble time calculator shows up in real work
Research notebooks that sweep H0 across modern estimate ranges can call this endpoint for a deterministic Gyr column before heavier cosmology codes run full lookback-time integrals. Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance.
Technical questions
What formula does this Hubble time calculator use?
t_H = 1/H0. With H0 in km/s/Mpc, the reciprocal is converted to seconds via a fixed megaparsec-to-kilometre factor, then to Julian years and gigayears.