Low-redshift luminosity distance calculator
Get the distance to a nearby galaxy or supernova from its redshift alone. A redshift of 0.01 with a Hubble constant of 70 gives 42.827494 megaparsecs. Made for small redshifts and classroom work. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Redshift
- 0.01
- Hubble constant
- 70
- Luminosity distance mpc
- 42.827494
- Luminosity distance ly
- 139,684,603.09
- Recession velocity km s
- 2,997.92458
- C km s
- 299,792.458
Luminosity distance is the distance that converts an object's intrinsic luminosity into the flux you measure on Earth, so it sits at the centre of magnitude work, supernova standard-candle labs, and introductory cosmology homework. At low redshift the expanding universe admits a simple linear expansion approximation: luminosity distance d_L is approximately c times z divided by the Hubble constant H0. When the speed of light is taken in kilometres per second and H0 in kilometres per second per megaparsec, d_L comes out in megaparsecs—the natural unit for nearby extragalactic sources.
How the low-z luminosity distance approximation works
Start from the linear expansion of cosmological distances at small redshift. To leading order in z the luminosity distance collapses to the same simple closed form as the classical Hubble–Lemaître relation written in redshift language: d_L is approximately equal to c times z divided by H0.
Here z is the dimensionless cosmological redshift of the source, c is the speed of light in vacuum (two hundred ninety-nine thousand seven hundred ninety-two point four five eight kilometres per second in this implementation), and H0 is the present-day Hubble constant, usually expressed in kilometres per second per megaparsec. With those units the quotient is a length in megaparsecs.
Hubble constant must be a finite strictly positive number because division by a non-positive H0 is undefined or non-physical; zero and negative H0 fail with invalid input instead of returning Infinity or a negative nonsense distance. Redshift must be finite and non-negative; blueshift is outside the luminosity-distance product rule for this landing. This page intentionally uses only the linear low-redshift approximation.
Full Friedmann–Lemaître–Robertson–Walker integrals that depend on matter and dark-energy densities, higher-order terms involving the deceleration parameter q0, angular-diameter distance, comoving distance, and peculiar-velocity corrections are separate search intents and separate landings. Keep units consistent: if your lab sheet quotes H0 in other conventions, convert to km/s/Mpc so the numeric quotient matches the megaparsec unit your report claims.
Where low-z luminosity distance calculators show up in real work
Secondary-school and introductory university astronomy courses assign low-redshift distance drills, magnitude-to-luminosity checks, and order-of-magnitude estimates that rearrange the same formula; a single trusted oracle speeds grading and demo setup. Science communicators convert tabulated small redshifts into megaparsec and light-year scales for public displays without re-deriving unit conversions each time. Data pipelines that pre-filter nearby-supernova or galaxy catalogues sometimes need a deterministic linear luminosity-distance column before heavier cosmological modules run.
Research notebooks comparing sensitivity to H0 can sweep several constant values against fixed redshifts and compare returned distances side by side. If you later need luminosity distance from redshift under a full ΛCDM cosmology, angular-diameter distance, lookback-time integrals, or Hubble-law distance from recession velocity rather than redshift, treat those as separate search intents and landings rather than overloading this low-redshift luminosity distance calculator page.
What you can do with it
Homework and exam answer keys
Compute d_L ≈ c z / H0 for textbook redshifts and a fixed Hubble constant so students and auto-graders share one closed-form ground truth in Mpc and light-years.
Planetarium and outreach demos
Turn small survey redshifts into human-readable megaparsec and light-year luminosity distances for exhibits and classroom widgets.
H0 sensitivity sweeps
Hold redshifts fixed and vary H0 across modern estimate ranges to show how linear luminosity distances scale before full cosmology codes.
FAQ
What formula does this low-redshift luminosity distance calculator use?
The linear expansion approximation d_L ≈ c z / H0. With c in km/s and H0 in km/s/Mpc, luminosity distance is returned in megaparsecs, plus light-year and recession-velocity convenience fields.
What happens if the Hubble constant is zero or negative?
Non-positive H0 makes d_L ≈ c z / H0 undefined or non-physical and is never turned into Infinity or a nonsense distance.
Is this a full cosmological distance calculator?
No. It is the linear low-redshift luminosity-distance approximation only. Full FLRW luminosity or comoving distances that depend on Ωm and ΩΛ are a different problem and a different landing.
How is this different from a Hubble-law velocity calculator?
This page takes cosmological redshift z and returns luminosity distance d_L ≈ c z / H0. A Hubble-law calculator typically takes recession velocity v and returns d = v / H0. Same linear spirit, different inputs and SEO intent.
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/luminosity-distance-lowz \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"redshift":0.01,"hubble_constant":70}'const res = await fetch("https://api.kit.forhosting.com/astro/luminosity-distance-lowz", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"redshift": 0.01,
"hubble_constant": 70
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/astro/luminosity-distance-lowz",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"redshift": 0.01,
"hubble_constant": 70
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/astro/luminosity-distance-lowz", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"redshift":0.01,"hubble_constant":70}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"redshift":0.01,"hubble_constant":70}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/astro/luminosity-distance-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
{
"redshift": 0.01,
"hubble_constant": 70
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "astro.luminosity_distance_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
How the low-z luminosity distance approximation works
The calculator evaluates that closed form 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
Redshift is the cosmological z of the source, dimensionless and non-negative—for example zero point zero one for a nearby galaxy or supernova host. Hubble constant is H0 in kilometres per second per megaparsec in the usual convention, for example seventy for many textbook drills or sixty-seven point four for a Planck-era reference. Classic textbook checks include z equals zero point zero one at seventy kilometres per second per megaparsec recovering about forty-two point eight three megaparsecs, and z equals zero point zero five at the same H0 recovering about two hundred fourteen point one megaparsecs. Send two required finite numbers under the fields redshift and hubble_constant. Missing fields, non-numeric strings, NaN, Infinity, negative redshift, and a non-positive Hubble constant fail with invalid_input and are not charged. On success the response echoes cleaned redshift and hubble_constant, returns luminosity_distance_mpc as the primary result in megaparsecs under that unit convention, luminosity_distance_ly as the same distance converted to light-years, recession_velocity_km_s as c times z for a classical linear velocity check, exposes c_km_s as the fixed speed of light used in the formula, includes a units hint object, sets method to linear_low_z_luminosity_distance, formula to d_L approximately c z over H0, and approximation to linear_expansion_low_z 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 low-z luminosity distance 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.