Universe age from Hubble constant
With a Hubble constant of 70 km/s/Mpc, the simple matter-only model gives an age of a little over 9 billion years, two-thirds of the Hubble time. Enter your value of H0 and get the age in years and billions of years. 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
- Age (years)
- 9,312,306,873.15
- Age gyr
- 9.3123068732
- Hubble time years
- 13,968,460,309.7
- Hubble time gyr
- 13.9684603097
The Hubble constant H0 sets the present expansion rate of the universe, and a first estimate of cosmic age follows from the reciprocal Hubble time. In a matter-dominated flat cosmology—the classic Einstein–de Sitter model—the scale factor grows as time to the two-thirds power, so the present age is exactly two-thirds of the Hubble time: t equals two-thirds over H0. Students use that closed form for homework, exam drills, and order-of-magnitude checks before they meet full Friedmann integrals with dark energy. Science communicators convert a quoted H0 near sixty-seven to seventy-four kilometres per second per megaparsec into a human-scale age in years and gigayears without re-deriving unit conversions each time. This calculator accepts a positive Hubble constant, returns the matter-dominated flat age in years and gigayears plus the companion Hubble time, and rejects non-positive H0 so a bad constant never becomes Infinity, NaN, or a negative age.
How a matter-dominated flat universe age follows from H0
Start from the Hubble time t_H, defined as the reciprocal of the present Hubble constant: t_H equals one over H0. Alone, t_H is only a characteristic expansion timescale; the true age of the universe depends on how the expansion rate evolved in the past. In the Einstein–de Sitter cosmology the universe is spatially flat, filled only with pressureless matter, and has zero cosmological constant.
Solving the Friedmann equation then yields a scale factor proportional to t to the two-thirds, and the present age collapses to the closed form t equals two-thirds times t_H, or equivalently t equals two-thirds over H0. That expression is the standard textbook first estimate taught in introductory cosmology before students add radiation, curvature, or dark energy.
H0 must be a finite positive number because division by zero is undefined and a non-positive expansion rate is unphysical for this age formula; zero and negative values fail with invalid input instead of returning Infinity. This page intentionally stays on the EdS closed form only; full lookback-time integrals that depend on matter and dark-energy density parameters, radiation epochs, or curvature are separate search intents and separate landings.
Keep the unit convention clear: H0 is accepted in kilometres per second per megaparsec, and the reciprocal is converted to years with fixed megaparsec-to-kilometre and Julian-year constants so the numeric age matches the length and time units your report claims.
Where universe-age-from-H0 calculators show up in real work
Secondary-school and introductory university cosmology courses assign Hubble-time and Einstein–de Sitter age drills that rearrange the same formula; a single trusted oracle speeds grading and demo setup without spreadsheet drift. Science communicators convert a quoted modern H0 into a human-readable age range for exhibits while clearly labelling the matter-only flat assumption, then contrast it with older universe ages from dark-energy models without mixing formulas on one landing. Data pipelines that pre-filter catalogue metadata sometimes need a deterministic EdS age column before heavier cosmological modules run.
Research notebooks comparing sensitivity to H0 can sweep several constant values and compare returned ages side by side to show the inverse scaling before full ΛCDM codes. If you later need lookback time from redshift under a full ΛCDM cosmology, luminosity distance integrals, or galaxy distance from recession velocity via Hubble's law, treat those as separate search intents and landings rather than overloading this universe age from Hubble constant calculator page.
What you can do with it
Homework and exam answer keys
Compute Einstein–de Sitter age t = (2/3)/H0 for textbook Hubble constants so students and auto-graders share one closed-form ground truth in years and gigayears.
Planetarium and outreach demos
Turn a quoted H0 into a human-readable cosmic age under the classic matter-dominated flat model for exhibits and classroom widgets.
H0 sensitivity sweeps
Vary H0 across modern estimate ranges and compare returned EdS ages to show inverse scaling before running full cosmology codes.
FAQ
What formula does this universe age calculator use?
The Einstein–de Sitter (matter-dominated flat) age t = (2/3) / H0, which is two-thirds of the Hubble time. H0 is taken in km/s/Mpc and age is returned in years and gigayears.
What happens if the Hubble constant is zero or negative?
The age formula divides by H0, so non-positive H0 is undefined or unphysical and is never turned into Infinity, NaN, or a negative age.
Is this a full ΛCDM cosmic age calculator?
No. It is the closed-form matter-dominated flat (EdS) estimate only. Ages that depend on Ωm, ΩΛ, radiation, or curvature are a different problem and a different landing.
How is this different from a Hubble-law distance calculator?
Hubble-law distance uses d = v / H0 from recession velocity. This page estimates cosmic age from H0 alone via t = (2/3)/H0. Same constant, different search intent and result.
What does it cost?
The browser tool is free and runs locally.
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/age-from-hubble \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"hubble_constant":70}'const res = await fetch("https://api.kit.forhosting.com/astro/age-from-hubble", {
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/age-from-hubble",
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/age-from-hubble", 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/age-from-hubble", 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.age_from_hubble",
"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
How a matter-dominated flat universe age follows from H0
The calculator evaluates it in deterministic floating-point arithmetic: 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
Classic textbook checks include H0 equals seventy recovering a Hubble time near fourteen billion years and an EdS age near nine point three billion years, and H0 equals one hundred recovering the round reference Hubble time near nine point seven eight billion years with age two-thirds of that. Send one required finite positive number under the field hubble_constant. That value is H0 in kilometres per second per megaparsec—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 estimate. Missing fields, non-numeric strings, NaN, Infinity, zero, and negative Hubble constants fail with invalid_input and are not charged. On success the response echoes the cleaned hubble_constant, returns age_years as the primary cosmic age in years under the Einstein–de Sitter formula, age_gyr as the same age divided by one billion for convenient gigayear readout, hubble_time_years and hubble_time_gyr as the companion t_H values so you can check the two-thirds factor by hand, includes a units hint object documenting the km/s/Mpc and year conventions, sets method to matter_dominated_flat, formula to t equals two-thirds over H0, and cosmology to einstein_de_sitter for honest scope. Pricing for successful API calls is the published base of $0.002 per item; validation failures do not consume prepaid balance.
Where universe-age-from-H0 calculators show up in real work
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.