First-order half-life calculator
Turn a first-order rate constant into a half-life: with k of 0.1 per second, half the reactant is gone after just under 7 seconds, whatever the starting concentration. The result comes in the time unit of k. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- K
- 0.1
- Half life
- 6.9314718056
- Ln2
- 0.6931471806
In first-order chemical kinetics the observed rate constant k fixes how quickly concentration falls with time, and the half-life is the unique time at which half of the reactant remains. For any elementary or effective first-order process the half-life is independent of the starting concentration and equals the natural logarithm of two divided by k.
Why the half-life is ln 2 divided by k
A first-order reaction loses the same fraction of its reactant in every equal stretch of time. Its integrated rate law says the concentration at time t is the starting concentration times e to the minus k t. Set that ratio to one half, solve for t, and you get the half-life: ln 2 divided by k. The starting amount cancels out, so the half-life is a pure time once k is known. With k of 0.1 per second the result is 6.931471805599 seconds. The unit always follows k: per second gives seconds, per hour gives hours, and nothing is converted for you.
Where first-order half-lives appear, and common slips
Radioactive decay, many drug-elimination phases and simple one-molecule reaction steps are all described by their half-life, and lab notebooks often store it beside the fitted k of a batch. The usual slips are small but costly. A k in per minute produces a half-life in minutes, not seconds. Zero-order and second-order reactions have half-lives that change with concentration, so this shortcut does not apply to them. And a rate constant of zero or below is refused, since dividing by zero is undefined and a negative lifetime has no physical meaning.
What first-order half-life means and how to choose k
A first-order reaction follows the integrated rate law concentration of A at time t equals concentration of A at time zero times e to the minus k t. Setting the concentration ratio to one half and solving for t yields the half-life t one-half equals ln of two over k. That expression does not depend on the initial amount, which is why first-order half-lives for radioactive decay, many drug-elimination phases, and elementary unimolecular steps are quoted as pure times once k is known.
Zero is rejected because division by zero is undefined, and negative k is rejected because a negative first-order lifetime is not physical for ordinary decay or consumption kinetics.
What you can do with it
Lab notebooks and LIMS exports
Process chemists paste an observed first-order rate constant from a fit and store the derived half-life beside batch metadata without reimplementing ln(2)/k in each spreadsheet.
FAQ
Does half-life depend on the initial concentration?
No. For true first-order kinetics t½ = ln(2)/k is independent of starting concentration. Zero-order and second-order half-lives behave differently and are outside this calculator.
Is the first-order half-life calculator free?
The browser tool runs free on your device.
What units should I use for k?
Any reciprocal time unit is fine as long as you stay consistent. The engine does not convert units.
What happens to the half-life if k doubles?
It is cut in half. Because the half-life is ln 2 divided by k, doubling the rate constant halves the time, and halving k doubles it. This is a quick check on any fitted value.
Why are a zero or negative rate constant rejected?
A k of zero would mean dividing by zero, which has no answer. A negative k would describe a lifetime that runs backwards, which makes no physical sense for ordinary decay or consumption, so both are refused.
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/first-order-half-life \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"k":0.1}'const res = await fetch("https://api.kit.forhosting.com/chem/first-order-half-life", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"k": 0.1
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/chem/first-order-half-life",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"k": 0.1
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/chem/first-order-half-life", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"k":0.1}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"k":0.1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/chem/first-order-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
{
"k": 0.1
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "chem.first_order_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.
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
This capability applies that textbook relation deterministically from a single positive number, rejects zero or negative rate constants with a clear invalid input error, and returns structured JSON that lab notebooks, homework checkers, and process-safety spreadsheets can pin in automated tests.
What first-order half-life means and how to choose k
Send the required field k as a JSON number or numeric string in reciprocal time units such as per second, per minute, or per hour; aliases rate_constant, rateConstant, constant, and k_obs are accepted so pipelines can reuse field names from kinetic fits. The engine does not convert units for you: if k is in inverse seconds the returned half_life is in seconds; if k is in inverse hours the half-life is in hours. Missing k, non-finite values, and empty strings also fail with invalid_input. Identical inputs always produce identical JSON because the path is pure arithmetic with no network, no random seed, and no wall clock.
Reading the response fields and common classroom workflows
Typical classroom drills include converting a tabulated k into a half-life, verifying that doubling k halves t one-half, and contrasting first-order behavior with zero-order or second-order half-lives that do depend on concentration. On success the response echoes k, returns half_life as ln of two divided by k with stable twelve-decimal rounding, includes ln2 so clients can audit the constant without recomputing Math.LN2, and labels formula as t½ equals ln of two over k with method first_order_half_life for branching. The units_note field reminds integrators that half-life units are the reciprocal of the units of k, which prevents silent mistakes when a fit reports k in inverse minutes but a report table expects hours. Use half_life alone when you only need the scalar for a data sheet; use the full object when grading software must check that the student formula and numeric k were applied correctly. Pair this endpoint with remaining-amount half-life tools when the next step is how much material is left after a given time, or with rate-law calculators when you still need to obtain an effective k from concentrations and reaction orders. Validation failures never consume balance after the engine rejects the request, so exploratory calls with bad units or zero k stay free to fix.
API usage, pricing, lab pipelines, and practical limits
Call the free in-browser first-order half-life calculator for lecture demos, homework checks, and quick mental verification without installing a kinetics package. Keep k within ordinary floating-point ranges; extremely small positive k yields a large half-life that remains finite, while extremely large k yields a tiny half-life that still rounds consistently. Send a JSON body with the required positive finite rate constant k. Authors shipping SDKs can map half_life and k into UI tables next to concentration–time plots so students see the same identity written in textbooks. This product does not estimate k from multi-point kinetic data, does not apply Arrhenius temperature corrections, and does not compute remaining inventory after decay—those are different search intents served by other capabilities. When you already hold an observed first-order rate constant and only need the half-life, this endpoint is the direct, charge-transparent path from k to t one-half.
Integration use cases
Homework and kinetics drills
Students convert a published first-order k into t½, check that larger k shortens half-life, and get a clear invalid_input error when they submit zero or negative rate constants.
Teaching platforms and CI fixtures
Tutoring apps and automated graders call a stable prepaid endpoint so worked examples and unit tests share one deterministic contract for first-order half-life.
Technical questions
How do I calculate first-order half-life from k?
Send JSON with k set to a positive first-order rate constant (for example k: 0.1). The response half_life equals ln(2)/k in the reciprocal unit of k.
What happens if the rate constant is zero or negative?
The request fails with invalid_input. Half-life is undefined for k = 0 (division by zero) and non-physical for negative first-order k; failures are not charged.