Rate law calculator
With k at 0.5, A at 0.1 (first order) and B at 0.2 (second order), the reaction runs at a rate of 0.002, with an overall order of 3. Enter k and each reactant's concentration and order to get the rate and every term. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Runs in your browser. Free, unlimited — your data never leaves this page.
Chemical kinetics textbooks write the empirical rate law as rate equals k times a product of reactant concentrations each raised to a reaction order. That single expression links laboratory measurements of concentration to how fast product forms at a given moment, and it is the first step students take before integrating differential equations or building reactor models. This capability evaluates the power-law form deterministically: you send a finite rate constant and a list of species with concentration and order, and you receive the numerical rate, overall order, per-species factors, and a readable expression string ready for homework checkers, tutoring apps, and lightweight process pipelines. Negative concentrations are rejected with a clear invalid input error so bad sensor data or sign mistakes never produce a silent nonsense rate.
What the rate law computes and how to prepare inputs
Write the rate as k multiplied by the product over i of open bracket A sub i close bracket to the power n sub i, where each n sub i is the reaction order with respect to that reactant and k is the rate constant in units consistent with concentration and time. For a second-order reaction in a single species the form is k times concentration squared; for a reaction that is first order in A and second order in B it is k times A times B squared.
Concentrations must be finite and non-negative; a negative concentration is invalid input because it has no physical meaning in this calculator and would produce misleading powers. Orders may be zero, positive, fractional, or negative as in many textbook empirical laws; zero concentration with a negative order is rejected because the power is undefined.
What you can do with it
Homework and exam verification
Students plug k and concentrations with orders into the rate law, compare the returned rate and overall order, and get a clear error when a negative concentration is submitted by mistake.
Lab notebook and sensor sanity checks
Teaching labs and small process scripts evaluate an empirical rate law at measured concentrations to spot unit mistakes or impossible negative readings before further analysis.
FAQ
Can orders be fractional or zero?
Yes. Reaction orders may be zero, integer, or fractional as in empirical rate laws. Zero concentration with a negative order is rejected because the power is undefined.
Is the rate law calculator free?
The browser tool runs free on your device.
Does this integrate the rate over time?
No. This capability evaluates the instantaneous power-law rate only. For remaining amount after half-life decay, use a dedicated half-life calculator instead.
Can a reaction order be negative?
Yes. Orders may be zero, positive, fractional or negative, as in many textbook empirical laws. The only combination refused is a zero concentration with a negative order, because that power is undefined.
What units does the rate come out in?
The units implied by your inputs. Keep the units of k consistent with your concentration and time units, and the rate follows as k times the concentration terms, for example in moles per litre per second.
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/rate-law \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"k":0.5,"reactants":[{"concentration":0.1,"order":1,"name":"A"},{"concentration":0.2,"order":2,"name":"B"}]}'const res = await fetch("https://api.kit.forhosting.com/chem/rate-law", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"k": 0.5,
"reactants": [
{
"concentration": 0.1,
"order": 1,
"name": "A"
},
{
"concentration": 0.2,
"order": 2,
"name": "B"
}
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/chem/rate-law",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"k": 0.5,
"reactants": [
{
"concentration": 0.1,
"order": 1,
"name": "A"
},
{
"concentration": 0.2,
"order": 2,
"name": "B"
}
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/chem/rate-law", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"k":0.5,"reactants":[{"concentration":0.1,"order":1,"name":"A"},{"concentration":0.2,"order":2,"name":"B"}]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"k":0.5,"reactants":[{"concentration":0.1,"order":1,"name":"A"},{"concentration":0.2,"order":2,"name":"B"}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/chem/rate-law", 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.5,
"reactants": [
{
"concentration": 0.1,
"order": 1,
"name": "A"
},
{
"concentration": 0.2,
"order": 2,
"name": "B"
}
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "chem.rate_law",
"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
What the rate law computes and how to prepare inputs
Send the required field k as a JSON number or numeric string; aliases rate_constant, rateConstant, and constant are accepted. Send reactants as a non-empty array of objects; each object needs concentration (aliases conc, c, molarity, M) and order (aliases reaction_order, power, exponent, n), and may include an optional name or species label for display. The engine caps the list at thirty-two species for Worker isolate safety while still covering multi-reactant classroom exercises and simple industrial examples. Identical inputs always produce identical JSON because the path is pure arithmetic with no network, no random seed, and no wall clock.
Reading rate, overall order, factors, and the expression string
The reactants array is the structured heart of the contract: each entry includes the optional name, the concentration, the order, and the factor equal to concentration raised to that order. The expression field builds a human-readable line such as rate equals zero point five times open bracket A close bracket times open bracket B close bracket squared for quick display in UIs and worksheets. On success the response echoes k rounded for stable display, reactant_count, and overall_order equal to the sum of the individual reaction orders. The concentration_product field multiplies those factors into the product that multiplies k, and the rate field is k times that product—the instantaneous rate in the units implied by your inputs. The method label is always rate_law so downstream code can branch without sniffing shapes. Use rate alone when a sensor pipeline only needs the scalar; use reactants and factors when grading software must check each power separately; use overall_order when classifying elementary versus non-elementary schemes in teaching materials. Missing k, missing reactants, empty arrays, non-finite numbers, and any negative concentration all fail with invalid_input and are not charged. Keep units consistent yourself: this endpoint multiplies numbers and does not convert molarity to millimolar or minutes to seconds.
API usage, pricing, classroom workflows, and practical limits
Call the free in-browser rate law calculator for homework checks, lecture demos, and quick lab sanity checks without installing a spreadsheet template or a local kinetics package. Floating-point powers can overflow for extreme concentration and order combinations, so keep classroom-scale inputs for grading oracles and prefer moderate magnitudes in continuous integration. Authors shipping SDKs can map the reactants array directly into UI tables that show concentration, order, and factor columns—the same breakdown students write when they expand a multi-reactant rate law by hand. Send a JSON body with the required rate constant k and the reactants array of concentration and order objects. Use the prepaid API when a tutoring platform, coding-assessment sandbox, curriculum generator, or process-control script needs a stable contract under KIT balance at $0.002 per successful item; validation failures never consume balance after the engine rejects the request. Pair this endpoint with half-life tools when the next question is remaining amount after decay, or with equilibrium constant calculators when students move from rates to Kc expressions.
Integration use cases
Tutoring and curriculum generators
Lesson builders produce worked multi-reactant rate-law examples with structured JSON for drills and auto-graded kinetics problems without embedding a full CAS.
Technical questions
How do I compute reaction rate with this rate law calculator?
Send JSON with k set to the rate constant and reactants as an array of objects each with concentration and order (for example k: 0.5 and two species). The response includes rate, overall_order, factors, and an expression string.
What happens if a concentration is negative?
The request fails with invalid_input. Negative concentrations are not allowed in this calculator; the error is returned without charging the request.