Decay constant calculator
Switch between the three ways of describing exponential decay: a half-life of 10 time units gives a decay constant of about 0.0693 per unit and a mean lifetime of about 14.43 units. Start from whichever of the three you know. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Half life
- 10
- Decay constant
- 0.0693147181
- Mean lifetime
- 14.4269504089
- From
- half_life
- Precision
- 10
This decay constant calculator converts among the three classic first-order exponential-decay quantities: the half-life t½, the decay constant λ (also called the first-order rate constant), and the mean lifetime τ. Enter a positive half-life and the engine returns λ equals the natural log of two divided by t½, together with the mean lifetime τ equals one over λ, which is the same as t½ over ln two. You can also start from λ or from τ and recover the other two scalars with the same identities. The arithmetic is fully deterministic: pure floating-point division with Math.LN2, no network calls, no sampling, and no date-dependent shortcuts. Classroom checks include a half-life of ten time units yielding λ about zero point zero six nine three and τ about fourteen point four three, and a decay constant of zero point one recovering t½ about six point nine three one.
What half-life, decay constant, and mean lifetime mean
First-order exponential decay describes any population that shrinks at a rate proportional to its current size, from radioactive nuclei to many unimolecular chemical processes. The remaining amount follows N of t equals N zero times e to the minus λ t. The half-life t½ is the time for the population to fall to half of its current value; rearranging the exponential gives t½ equals ln two over λ, so the decay constant is simply λ equals ln two over t½.
The mean lifetime τ is the average time a single member survives before decaying, and for pure exponential kinetics it is exactly one over λ, equivalently t½ over ln two.
Where the conversion fits in study, lab work, and software
Students meet λ equals ln two over t½ when a textbook moves from half-life tables to rate constants, when a radiochemistry lab asks for the mean life of a tracer, or when a kinetics problem gives a first-order half-life and demands the rate constant without a calculator under the desk. Teachers can pre-generate answer keys for modest positive half-lives without trusting opaque apps that silently switch units or drop scientific notation.
Nuclear medicine and environmental monitoring workflows often need a quick, offline conversion from tabulated half-lives to λ before integrating activity or comparing exposure models. Developers call the same contract from scripts to seed deterministic test vectors for decay simulators, to normalize user-entered half-lives before plotting N of t curves, or to satisfy programming-challenge statements that demand λ and τ rather than a hand-waved sketch.
Product and education tools use the identities when a learner types a half-life in seconds, minutes, or years and the UI must show the matching decay constant and mean lifetime with a clean formula reminder. Pair it with stoichiometry or concentration tools when you are building a small lab of free, deterministic chemistry helpers, and keep a consistent time unit across half-life and λ so the numbers stay physically meaningful.
What you can do with it
Homework and kinetics checks
Convert textbook half-lives into decay constants and mean lifetimes, or invert λ back to t½, before graphing N(t) or solving first-order rate problems.
Lab and radiopharmacy software
Normalize user-entered half-lives or rate constants into a full (t½, λ, τ) set for activity calculators, tracer planners, and teaching simulators.
FAQ
What does the decay constant calculator cost?
It is free in your browser on this page.
How are λ and τ defined from half-life?
For first-order exponential decay, λ = ln(2)/t½ and τ = 1/λ = t½/ln(2). The half-life is the time for the population to fall by half.
What happens if half-life is zero or negative?
Non-positive half-life makes λ = ln(2)/t½ undefined or non-physical for this model.
Does this tool compute remaining activity after a given time?
No. It only converts among t½, λ, and τ. Use a dedicated remaining-fraction or activity tool if you need N(t)/N0 for a specific elapsed time.
Can I start from the decay constant instead of the half-life?
Yes. Enter exactly one of the three values, half-life, decay constant or mean lifetime, and the calculator returns the other two. A decay constant of 0.1, for example, gives a half-life of about 6.931.
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/chem/decay-constant-half-life \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"half_life":10}'const res = await fetch("https://api.kit.forhosting.com/chem/decay-constant-half-life", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"half_life": 10
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/chem/decay-constant-half-life",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"half_life": 10
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/chem/decay-constant-half-life", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"half_life":10}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"half_life":10}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/chem/decay-constant-half-life", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"half_life": 10
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "chem.decay_constant_half_life",
"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.
Limits
max_abs_value | 1000000000000000 |
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 half-life, decay constant, and mean lifetime mean
This calculator returns all three scalars rounded to your chosen precision, a from tag that records which field you supplied, the method tag exponential_decay, a short formula reminder, a unit_note that half-life and mean lifetime share one time unit while λ is the reciprocal of that unit, and the precision used. There is no Monte Carlo sampling of decay events and no nuclide database lookup: the engine either builds exact floating-point conversions inside the supported magnitude range or rejects the input with invalid_input. Rejected cases include missing all three fields, supplying more than one of them at once, non-finite values, magnitudes above the documented ceiling, and any non-positive half-life, decay constant, or mean lifetime, because zero or negative t½ makes λ undefined or non-physical for this model.
How inputs are read and how results stay reproducible
Optional leading plus signs and scientific notation on numeric strings are allowed when they parse as finite decimals; embedded spaces, hex prefixes, and non-numeric tokens are rejected with a clear message so a bad cell does not become a wrong λ. Every accepted value must be strictly positive: half-life zero or negative is rejected because λ equals ln two over t½ is undefined or non-physical; the same rule applies to λ and τ. The preferred fields are half_life for t½, decay_constant for λ, and mean_lifetime for τ, but aliases t_half, halfLife, t12, T_half, and thalf for half-life; lambda, the Greek letter λ, k, rate_constant, and decayConstant for the rate; and tau, the Greek letter τ, lifetime, mean_life, and meanLifetime for the mean life are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. You must provide exactly one of the three source fields: if none appear, or if two or three appear together, the request fails with invalid_input so the engine never silently picks a conflicting pair. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for half_life, decay_constant, and mean_lifetime, defaulting to ten and capped at fifteen so JSON goldens stay stable. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing the exponential-decay formulas yourself.
Where the conversion fits in study, lab work, and software
On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split — free interactive exploration and a priced, identical API — matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the mathematical result.
Integration use cases
Deterministic test fixtures
Generate reproducible half_life, decay_constant, and mean_lifetime triples for unit tests, property checks, and CI assertions on exponential-decay helpers.
Technical questions
Can I start from the decay constant or mean lifetime instead?
Yes. Provide exactly one of half_life, decay_constant, or mean_lifetime; the other two are computed and returned with a from tag.