First-order reaction time calculator
Find the time a first-order reaction needs to fall from one concentration to another: with k of 0.1 per second, 1 mol/L drops to 0.5 mol/L in about 6.931 seconds, and with k of 0.05, 2 drops to 0.5 in about 27.7. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- First-order rate constant k
- 0.1
- Initial concentration
- 1
- Final
- 0.5
- Time
- 6.9314718056
- Precision
- 10
This first-order reaction time calculator finds how long a reactant takes to fall from an initial concentration to a final concentration when the rate is proportional to remaining amount. The arithmetic is fully deterministic: one natural logarithm and one division on finite floating-point numbers, with no network calls, no sampling, and no date-dependent shortcuts. Classroom checks include k equals zero point one with [A]₀ equals one and [A] equals zero point five yielding t approximately six point nine three one, and k equals zero point zero five with [A]₀ equals two and [A] equals zero point five yielding t approximately twenty-seven point seven.
What the elapsed time tells you
First-order kinetics describe processes whose instantaneous rate is proportional to the current concentration of the reactant: rate equals k times [A]. The integrated rate law is ln of [A] equals ln of [A]₀ minus k t, or equivalently [A] equals [A]₀ times e to the minus k t. Solving for the time that takes the concentration from [A]₀ down to a chosen final [A] gives t equals ln of the ratio [A]₀ over [A], all divided by k.
Unlike zero-order kinetics, where concentration falls linearly and half-life grows with starting amount, first-order decay has a half-life that depends only on k (t½ equals ln two over k), but the time to any other remaining fraction still needs both concentrations. Zero concentrations are especially important: [A] equals zero would make the log ratio diverge (first-order kinetics never reach exact zero in finite time), and [A]₀ equals zero makes the ratio undefined.
Where first-order reaction time fits in study, lab work, and software
Students meet t equals ln([A]₀/[A])/k when a textbook derives the integrated first-order law, when a kinetics lab fits a linear ln[A] versus time plot, or when a pharmacy or environmental problem models exponential drug clearance or pollutant decay. Teachers can pre-generate answer keys for modest positive k and concentration pairs without trusting opaque apps that silently switch between zero-order and first-order formulas.
Process chemists and analytical teams often need a quick, offline check that a proposed rate constant and two measured concentrations imply an elapsed time compatible with sampling windows, residence times, or stability studies. Developers call the same contract from scripts to seed deterministic test vectors for kinetics simulators, to normalize user-entered k and concentrations before plotting exponential curves, or to satisfy programming-challenge statements that demand first-order time rather than a hand-waved sketch.
Product and education tools use the identity when a learner types a rate and two concentrations and the UI must show t with a clean formula reminder and unit note. Pair it with zero-order half-life or reaction-order tools when you are building a small lab of free, deterministic chemistry helpers, and keep consistent concentration and time units so the numbers stay physically meaningful.
What you can do with it
Homework and kinetics checks
Compute textbook first-order times from k, [A]₀, and [A] before graphing ln[A](t) or checking half-life consistency on a worksheet.
Lab and process software
Normalize user-entered rate constants and concentrations into elapsed t for decay models, stability demos, and teaching simulators.
FAQ
What does the first-order reaction time calculator cost?
It is free in your browser on this page.
How is the elapsed time defined for first-order kinetics?
From [A] = [A]₀ e^(−k t), solving for t gives t = ln([A]₀/[A])/k. Time is in the reciprocal unit of k.
What happens if a concentration is zero?
[A] = 0 makes ln([A]₀/[A]) diverge (infinite time); [A]₀ = 0 makes the ratio undefined.
Does this tool compute zero-order half-life?
No. Zero-order half-life is t½ = [A]₀/(2k) and uses a different integrated law. Use the dedicated zero-order half-life tool for that model.
Why are results rounded to a precision?
Default precision is 10 decimal places; you can set precision from 0 to 15.
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-time \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"rate_constant":0.1,"initial_concentration":1,"final_concentration":0.5}'const res = await fetch("https://api.kit.forhosting.com/chem/first-order-time", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"rate_constant": 0.1,
"initial_concentration": 1,
"final_concentration": 0.5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/chem/first-order-time",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"rate_constant": 0.1,
"initial_concentration": 1,
"final_concentration": 0.5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/chem/first-order-time", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"rate_constant":0.1,"initial_concentration":1,"final_concentration":0.5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"rate_constant":0.1,"initial_concentration":1,"final_concentration":0.5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/chem/first-order-time", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"rate_constant": 0.1,
"initial_concentration": 1,
"final_concentration": 0.5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "chem.first_order_time",
"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
Enter a positive first-order rate constant k, a positive initial concentration [A]₀, and a positive final concentration [A], and the engine returns the elapsed time t equals the natural log of the concentration ratio [A]₀ over [A] divided by k, together with the normalized inputs, the method tag first_order_time, a short formula reminder, and a unit note so time and concentration units stay consistent.
What first-order elapsed time means and what the response contains
This calculator returns the normalized rate_constant, initial_concentration, and final_concentration, the computed time rounded to your chosen precision, the method tag first_order_time, the precision used, a formula string that recalls t equals ln([A]₀/[A])/k from the integrated first-order law, and a unit_note that time is in the reciprocal of the rate-constant unit while the two concentrations share one concentration unit. There is no Monte Carlo sampling of reaction events and no lookup table of reaction orders: the engine either builds the exact floating-point elapsed time inside the supported magnitude range or rejects the input with invalid_input. Rejected cases include missing k or either concentration, non-finite values, magnitudes above the documented ceiling, rate constant equal to zero, non-positive k, and zero or negative concentrations.
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. The rate constant must be strictly positive: k equals zero is rejected explicitly because division by k is undefined, and negative k is rejected because this tool models consumption under first-order kinetics with a consistent elapsed-time interpretation. Both concentrations must be strictly positive: zero is rejected by contract because the natural log of the concentration ratio is undefined or infinite, and negative concentrations are non-physical for this model. When [A] is less than [A]₀ the time is positive (reactant consumed); when they are equal the time is zero; when [A] exceeds [A]₀ the signed time is negative, which can flag an inverted pair of readings. The preferred fields are rate_constant for k, initial_concentration for [A]₀, and final_concentration for [A], but aliases k, rateConstant, first_order_k, and k1 for the rate constant; A0, a0, concentration0, C0, c0, and initialConcentration for the starting concentration; and A, a, concentration, C, c, finalConcentration, and remaining for the final concentration are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. All three primary fields are required: if any is missing, empty, or not a finite decimal, the request fails with invalid_input so a bad cell does not become a wrong reaction time. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for the numeric outputs, 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 log formula yourself.
Where first-order reaction time 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 time values for unit tests, property checks, and CI assertions on first-order kinetics helpers.