White dwarf radius from mass calculator
This white dwarf radius calculator estimates the radius of a cold, non-rotating white dwarf from its mass in solar masses.
Run — free
It applies the Nauenberg approximation to the inverse mass-radius relation produced by electron degeneracy pressure and returns the radius in metres. The calculation uses a Chandrasekhar limit of 1.44 solar masses and reports an input error above that boundary. It is useful for quick astrophysics checks, teaching, model comparisons, and order-of-magnitude estimates, but it is not a replacement for a detailed stellar-structure model.
Why a more massive white dwarf is smaller
Ordinary objects often become larger when material is added, but a white dwarf follows the opposite trend over most of its stable mass range. Its support comes mainly from electron degeneracy pressure, a quantum-mechanical effect that does not depend on ordinary thermal gas pressure in the same way as a main-sequence star. Adding mass strengthens gravity and forces the degenerate electrons into a more compressed state, so the equilibrium radius falls. This calculator represents that behavior with the Nauenberg mass-radius approximation. Enter the stellar mass as a multiple of the Sun's mass, such as 0.6 for a typical white dwarf, and the result gives the corresponding radius in metres. The returned value is the modeled stellar radius, not a Schwarzschild radius, orbital distance, or observational angular radius. Because the relation is idealized, it is best interpreted as a physically motivated estimate that captures the main inverse trend rather than as an exact prediction for every observed remnant.
How the estimate is calculated
The calculation uses R = 0.0112 R_sun times the square root of [(M_ch/M)^(2/3) minus (M/M_ch)^(2/3)]. Here M is the supplied white dwarf mass, M_ch is fixed at 1.44 solar masses, and the solar radius is fixed at 695,700,000 metres. Keeping the input in solar masses makes the mass ratio dimensionless, while multiplying by the adopted solar radius converts the final answer directly to metres. The formula smoothly decreases as mass increases and reaches zero at the adopted Chandrasekhar boundary. A mass greater than 1.44 is rejected instead of being inserted into the square root, because the expression would cease to describe a stable white dwarf and would produce a non-real mathematical result. The implementation is deterministic: identical input always uses the same constants and arithmetic, with no network lookup, random choice, or time-dependent data. The result therefore works well in reproducible calculations and automated tests.
Assumptions, limits, and interpretation
The Nauenberg relation is a compact approximation for a zero-temperature, non-rotating white dwarf supported by a completely degenerate electron gas. Real stars can differ because of finite temperature, envelope structure, rotation, magnetic fields, chemical composition, crystallization, and general-relativistic effects near the high-mass end. The model also assumes the customary electron molecular-weight choice implicit in the quoted coefficient, making it most appropriate for common carbon-oxygen white dwarfs and useful as a broad estimate for related compositions. Very low-mass remnants may have helium cores and thick envelopes that make their observed radii depart noticeably from this cold relation. Near 1.44 solar masses, small mass changes lead to very large relative radius changes, so the output should not be treated as a precision prediction. Use the estimate to compare theoretical scales, check a calculation, or establish an initial condition. For research-grade inference, compare against evolutionary tracks matched to temperature, composition, atmosphere, and observational uncertainties. Each API request costs $0.002; the browser calculation uses the same deterministic relation.
What you can do with it
Check a stellar-remnant calculation
Convert an assumed white dwarf mass into a radius scale before performing luminosity, surface-gravity, or accretion estimates.
Teach the inverse mass-radius relation
Compare several masses to show why increasing degeneracy-supported stellar mass produces a smaller equilibrium radius.
Screen model inputs
Reject masses above the adopted Chandrasekhar limit and create reproducible starting radii for a larger deterministic workflow.
FAQ
What mass unit should I enter?
Enter the mass in solar masses. For example, 0.6 means sixty percent of the Sun's mass.
What unit does the calculator return?
The primary result, radius_m, is the estimated white dwarf radius in metres.
Why does the radius decrease as mass increases?
Stronger gravity compresses the electron-degenerate matter more intensely, producing the inverse mass-radius behavior represented by the approximation.
What happens above the Chandrasekhar limit?
The request returns an invalid input error above 1.44 solar masses because this relation does not describe a stable white dwarf there.
Is this radius exact for an observed white dwarf?
No. It is a zero-temperature approximation; temperature, composition, envelopes, rotation, magnetism, and other stellar physics can change the observed radius.
What does an API request cost?
Each request costs $0.002. The calculation is deterministic and does not contact an external service.
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/white-dwarf-radius \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"mass_solar_masses":0.6}'const res = await fetch("https://api.kit.forhosting.com/astro/white-dwarf-radius", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"mass_solar_masses": 0.6
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/astro/white-dwarf-radius",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"mass_solar_masses": 0.6
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/astro/white-dwarf-radius", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"mass_solar_masses":0.6}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"mass_solar_masses":0.6}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/astro/white-dwarf-radius", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"mass_solar_masses": 0.6
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "astro.white_dwarf_radius",
"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. |