Mass of product from reactant calculator
Go from grams of reactant to grams of product in one step: 10 g of oxygen at 32 g/mol turning one to one into carbon dioxide at 44 g/mol gives 0.3125 mol and 13.75 g of product. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Reactant mass
- 10
- Reactant molar mass
- 32
- Product molar mass
- 44
- Reactant coeff
- 1
- Product coeff
- 1
- Mole ratio
- 1 g
- Moles reactant
- 0.3125
- Moles product
- 0.3125
- Product mass
- 13.75
Stoichiometry homework and lab prep often start from a known mass of one reactant and ask how many grams of product that sample can form when the equation is balanced. The answer is not a single division: you convert the reactant mass into moles with its molar mass, scale by the product-to-reactant coefficient ratio from the balanced equation, then convert product moles back into mass with the product molar mass. This capability performs that chain deterministically from five numbers—reactant mass, both molar masses, and both stoichiometric coefficients—and returns the product mass plus the intermediate mole amounts so students, tutors, and pipelines can audit every step. Zero molar masses and zero coefficients are rejected as invalid input because they make the mole conversion undefined.
Inputs, units, and the mass–mole–mass path
Provide the reactant sample mass in grams together with the reactant molar mass and product molar mass in grams per mole. Also send the balanced-equation coefficients of the reactant and the product as positive numbers—typically small integers such as one, two, or three, though non-integer coefficients from scaled equations are accepted when they remain finite and positive.
The engine first computes moles of reactant as mass divided by reactant molar mass, multiplies by the mole ratio of product coefficient over reactant coefficient, and multiplies again by the product molar mass to obtain product mass in grams. That is algebraically identical to scaling the reactant mass by the product-to-reactant molar-mass ratio and by the same stoichiometric ratio in one expression. Mass must be non-negative; molar masses and coefficients must be strictly greater than zero.
Magnitudes are capped for isolate safety while still covering every ordinary classroom and pilot-plant worksheet.
What you can do with it
Homework mass–mole–mass drills
Students enter reactant grams, both molar masses, and balanced coefficients, then compare the returned product mass and intermediate moles against their paper solution.
Lab prep and scale-up estimates
Technicians estimate how many grams of product a known reagent charge can form under a fixed balanced ratio before running the experiment.
FAQ
What happens if a molar mass or coefficient is zero?
Zero molar mass or zero stoichiometric coefficient would make the mole conversion undefined, so those values are rejected and not charged.
Is this the same as theoretical yield in moles?
No. This calculator returns product mass in grams from reactant mass and molar masses. For limiting-reactant moles times ratio only, use a theoretical yield (moles) tool instead.
Is the mass of product from reactant calculator free?
The browser tool runs free on your device.
Which units should I use?
Coefficients are unitless balanced-equation numbers greater than zero.
Does it find the limiting reactant?
No. It assumes the reactant you enter is the one that sets the amount of product. When two reactants could run out, use the product mass from limiting reactant calculator, which compares both first.
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/mass-of-product-from-reactant \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"reactant_mass":10,"reactant_molar_mass":32,"product_molar_mass":44,"reactant_coeff":1,"product_coeff":1}'const res = await fetch("https://api.kit.forhosting.com/chem/mass-of-product-from-reactant", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"reactant_mass": 10,
"reactant_molar_mass": 32,
"product_molar_mass": 44,
"reactant_coeff": 1,
"product_coeff": 1
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/chem/mass-of-product-from-reactant",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"reactant_mass": 10,
"reactant_molar_mass": 32,
"product_molar_mass": 44,
"reactant_coeff": 1,
"product_coeff": 1
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/chem/mass-of-product-from-reactant", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"reactant_mass":10,"reactant_molar_mass":32,"product_molar_mass":44,"reactant_coeff":1,"product_coeff":1}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"reactant_mass":10,"reactant_molar_mass":32,"product_molar_mass":44,"reactant_coeff":1,"product_coeff":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/chem/mass-of-product-from-reactant", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"reactant_mass": 10,
"reactant_molar_mass": 32,
"product_molar_mass": 44,
"reactant_coeff": 1,
"product_coeff": 1
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "chem.mass_of_product_from_reactant",
"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
Inputs, units, and the mass–mole–mass path
Zero molar mass or zero coefficient fails with invalid_input so callers never see infinity or NaN disguised as a result. Aliases such as mass, M_reactant, nu_product, and related names are accepted when documented in the parameter contract. Identical inputs always produce identical JSON because the path is pure arithmetic with no network, no random seed, and no wall clock.
Reading product_mass, mole intermediates, and error cases
On success the response echoes the five numeric inputs with stable rounding, reports mole_ratio as product coefficient divided by reactant coefficient, and lists moles_reactant and moles_product so you can show the intermediate table students write on paper. The primary answer is product_mass in grams with unit set to g, plus a formula string stating the combined expression and a method label mass_of_product_from_reactant for downstream branching. Use product_mass alone when a UI needs a single headline number; use the mole fields when a worked-solution panel must display each conversion; use mole_ratio when you only need the stoichiometric scale factor derived from the coefficients. Missing any required field, non-finite values, negative mass, zero or negative molar mass, and zero or negative coefficients all fail with invalid_input and are not charged after the engine rejects the request. This calculator does not identify a limiting reactant among several reagents and does not look up molar masses from chemical formulas—pair it with a molar-mass tool if you start from molecular formulas rather than tabulated grams per mole. It also differs from a pure theoretical-yield-in-moles endpoint: here the contract is explicitly mass in and mass out for the mass-of-product search intent.
API usage, pricing, classroom workflows, and practical limits
Call the free in-browser mass of product from reactant calculator for homework checks, lecture demos, and quick lab prep without installing a spreadsheet or a chemistry package. Typical classroom examples include ten grams of oxygen forming carbon dioxide when coefficients are one-to-one, or twice the product coefficient when two moles of product form per mole of reactant. Source inputs follow the same retention rules as other KIT parse items. Send a JSON body with reactant_mass, reactant_molar_mass, product_molar_mass, reactant_coeff, and product_coeff as finite numbers or numeric strings. Use the prepaid API when a tutoring platform, learning-management plug-in, curriculum generator, or process-engineering notebook needs a stable contract under KIT balance at $0.002 per successful item; validation failures never consume balance after rejection. Authors shipping SDKs can map the response fields directly into a results table with columns for reactant moles, product moles, and product mass—the same columns students fill when they apply mass–mole–mass stoichiometry by hand.
Integration use cases
Tutoring and LMS auto-graders
Lesson builders and quiz engines generate worked stoichiometry items with a stable JSON contract without embedding a full chemistry CAS.
Technical questions
How do I calculate product mass from reactant mass?
Send reactant_mass in grams, reactant_molar_mass and product_molar_mass in g/mol, and the balanced reactant_coeff and product_coeff. The response includes product_mass and the intermediate mole amounts.