First-order concentration calculator
See how much reactant is left after a first-order reaction has run: 1 mol/L with k of 0.1 per second falls to 0.367879441171 mol/L after 10 seconds, or 1/e of the start, because k times t equals 1. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Initial concentration
- 1
- K
- 0.1
- Time
- 10
- Concentration
- 0.3678794412
- Remaining fraction
- 0.3678794412
- Product k t
- 1
- Ln ratio
- -1
First-order chemical kinetics with rate equal to k times the concentration of reactant A appears throughout organic mechanisms, radioactive decay analogs, and many elementary unimolecular steps taught in general and physical chemistry. The integrated form links initial concentration, the observed first-order rate constant, and elapsed time to the amount of reactant that remains, so students and process chemists can answer how much is left without re-deriving the exponential decay equation every time.
What first-order remaining concentration means and how to choose inputs
For a reaction that follows rate equals k times concentration of A, the differential equation integrates to the natural log of concentration of A at time t equals the natural log of the initial concentration minus k times t. Exponentiating both sides gives concentration of A at time t equals initial concentration times e to the power of minus k t.
That identity is the heart of this calculator: send a strictly positive initial concentration in the same units you use for the rate law, a non-negative first-order rate constant in inverse time, and a non-negative elapsed time in the matching time unit. If k is in inverse seconds and initial concentration is in moles per liter, time must be in seconds and the returned concentration is again in moles per liter. The engine does not convert units for you, which keeps the contract honest and free of silent scale mistakes.
Negative time is invalid input because elapsed reaction time cannot run backward under this model; zero time correctly returns the initial concentration unchanged. Zero rate constant freezes the concentration at the initial value, which is mathematically consistent even if it is rarely the physical case of interest. Unlike second-order kinetics, the remaining fraction for a first-order process depends only on k and t, not on how concentrated the batch started.
What you can do with it
Lab notebooks and batch planning
Process chemists paste fitted first-order k and planned reaction time to estimate how much reactant remains without re-deriving the exponential integrated rate law in each spreadsheet.
FAQ
What happens if time is negative?
Elapsed reaction time must be non-negative; negative time is rejected and not charged.
What units should I use for k and concentration?
Use any consistent set: if time is in seconds, k must be in s⁻¹. Concentration units carry through unchanged. The calculator does not convert units automatically.
Is the first-order concentration calculator free?
The browser tool runs free on your device.
Does the remaining fraction depend on the starting concentration?
No. In a first-order reaction the fraction left depends only on k and the time, so a dilute batch and a concentrated one lose the same share. That is the key difference from second-order kinetics, which fall faster at higher starting amounts.
How much reactant is left after one half-life?
Exactly half. The half-life of a first-order reaction is ln 2 divided by k, so entering that time returns half the starting concentration, which is a quick way to check your k.
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-concentration \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"initial_concentration":1,"k":0.1,"time":10}'const res = await fetch("https://api.kit.forhosting.com/chem/first-order-concentration", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"initial_concentration": 1,
"k": 0.1,
"time": 10
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/chem/first-order-concentration",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"initial_concentration": 1,
"k": 0.1,
"time": 10
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/chem/first-order-concentration", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"initial_concentration":1,"k":0.1,"time":10}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"initial_concentration":1,"k":0.1,"time":10}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/chem/first-order-concentration", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"initial_concentration": 1,
"k": 0.1,
"time": 10
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "chem.first_order_concentration",
"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 the textbook relation concentration of A at time t equals initial concentration times e to the power of minus k t, rejects negative time with a clear invalid input error, and returns structured JSON that homework checkers, lab notebooks, and lightweight process tools can pin in automated tests.
What first-order remaining concentration means and how to choose inputs
Missing fields, non-finite numbers, empty strings, non-positive initial concentration, and negative k all 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 verifying that half the reactant remains when t equals the half-life ln two over k, computing remaining reactant after a given batch time, and contrasting this concentration-independent fractional decay with second-order laws that fall faster at higher starting amounts. The formula field always restates concentration of A at t equals initial times e to the minus k t, and method is always first_order_integrated_rate_law for downstream branching. Pair this endpoint with first-order half-life tools when the next question is t half, with first-order time tools when you know final concentration and need elapsed time, or with rate-law calculators when you still need an instantaneous rate from k and current concentration. Validation failures never consume balance after the engine rejects the request, so exploratory calls with negative time or missing k stay free to fix.
API usage, pricing, lab pipelines, and practical limits
Call the free in-browser first-order concentration calculator for lecture demos, homework checks, and quick mental verification without installing a kinetics package. Keep magnitudes within ordinary floating-point ranges; extremely large products of k and time drive remaining concentration toward zero in a controlled way, while tiny products leave concentration near the start. Send a JSON body with the required fields initial_concentration, k, and time; aliases a0, A0, c0, rate_constant, t, elapsed, and related names are accepted so pipelines can reuse field names from kinetic fits and spreadsheets. Authors shipping SDKs can map concentration and remaining_fraction into UI tables next to concentration–time plots so students see the same exponential identity written in textbooks. This product does not estimate k from multi-point data, does not solve for time given a target final concentration, does not report half-life alone, and does not apply Arrhenius temperature corrections—those are different search intents served by sibling capabilities. When you already hold A zero, k, and t and only need remaining first-order concentration, this endpoint is the direct, charge-transparent path from inputs to remaining amount.
Integration use cases
Homework and kinetics drills
Students compute remaining [A] after a stated batch time for rate = k[A], verify that remaining fraction depends only on k and t, and get a clear invalid_input error when they submit negative time.
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 remaining concentration.
Technical questions
How do I calculate remaining concentration for a first-order reaction?
Send JSON with initial_concentration (or a0), k (first-order rate constant in time⁻¹), and time (or t). The response concentration is [A]_t = [A]_0 · e^(−k t).
How is this different from second-order remaining concentration?
First-order uses [A]_t = [A]_0 · e^(−k t) and the remaining fraction depends only on k and t. Second-order uses [A]_t = [A]_0 / (1 + k·[A]_0·t) and depends on the starting concentration as well.