ForHosting KIT · Science

Moles of product calculator

2.5 moles of reactant with coefficients 2 and 1 give 1.25 moles of product, through a mole ratio of 0.5. Enter the limiting reactant amount and both coefficients to get the theoretical baseline for your notebook or batch sheet. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Moles of reactant available: 2.5
Reactant coefficient: 2
Product coefficient: 1

You get

Mole ratio: 0.5
Moles of product: 1.25

Stoichiometry links how much reactant you start with to how much product can form when a reaction runs to completion under the balanced equation. You multiply the moles of limiting reactant by the mole ratio of product coefficient over reactant coefficient from the balanced chemical equation. Use it for lab prep, homework checks, batch stoichiometry tables, and any pipeline that needs a repeatable product-mole figure without spreadsheets or one-off scripts.

What moles of product means in practice

In a balanced chemical equation the coefficients are relative mole counts. If two moles of reactant A produce one mole of product B, the mole ratio of product to reactant is one half. When you know how many moles of A you actually have—and A is the limiting reactant—you scale that ratio to get the theoretical moles of B that can form.

This is the first half of every yield calculation: convert masses to moles if needed, identify the limiting reactant, then apply the coefficient ratio. Real labs still need percent yield for recovery losses, but the stoichiometric product amount is the clean baseline every notebook, grader, and electronic batch record expects. Values of zero product moles arise only when reactant moles or the product coefficient is zero; a zero reactant coefficient is rejected because division by zero is undefined and a missing reactant term is not a valid balanced ratio.

This tool never invents chemistry or balances equations for you: it only applies the arithmetic once you supply reactant moles and both coefficients in consistent mole units, so the quality of the answer depends on how carefully you balanced the equation and measured the reactant beforehand.

What you can do with it

Homework and lab stoichiometry checks

Compute theoretical moles of product from reactant moles and balanced coefficients before students or lab partners finalize notebooks.

Batch charge and scale-up tables

Convert planned reactant feed into theoretical product moles so process notes reflect correct stoichiometry across lots.

FAQ

How are moles of product calculated?

Moles of product equals reactant moles times product coefficient divided by reactant coefficient. The response also returns the unitless mole ratio for audit logs.

What units should I use?

Coefficients are pure stoichiometric numbers from the balanced equation. Convert mass or volume to moles before calling if needed.

What if the reactant coefficient is zero?

Division by zero is undefined, so a zero reactant coefficient is rejected before any result is returned; failed tasks are not charged.

Does this handle limiting reactant among several reagents?

No. Supply the moles of the limiting reactant only.

Is this the amount of product I will actually collect?

No. It is the theoretical amount if the reaction runs to completion with that reactant limiting. Real experiments lose some product during recovery, so you still apply a percent yield to compare with what you collect.

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

POSThttps://api.kit.forhosting.com/chem/moles-of-product

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/moles-of-product \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"reactant_moles":2.5,"reactant_coefficient":2,"product_coefficient":1}'

const res = await fetch("https://api.kit.forhosting.com/chem/moles-of-product", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "reactant_moles": 2.5,
    "reactant_coefficient": 2,
    "product_coefficient": 1
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/chem/moles-of-product",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "reactant_moles": 2.5,
    "reactant_coefficient": 2,
    "product_coefficient": 1
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/chem/moles-of-product", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"reactant_moles":2.5,"reactant_coefficient":2,"product_coefficient":1}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"reactant_moles":2.5,"reactant_coefficient":2,"product_coefficient":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/chem/moles-of-product", 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_moles": 2.5,
  "reactant_coefficient": 2,
  "product_coefficient": 1
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "chem.moles_of_product",
  "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

Per request$0.002

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 performs that transparent calculation deterministically: three finite numbers in, moles of product and the unitless mole ratio out, with a fixed twelve-decimal rounding policy so browser and API results match byte for byte.

Inputs, outputs, and validation rules

Units are moles throughout; convert grams or liters to moles with molar mass or ideal-gas math before calling if your lab data are not already in moles. A classic homework check is two point five moles of reactant with coefficients two for reactant and one for product, which yields one point two five moles of product and a mole ratio of zero point five. Send three required numbers: reactant_moles for the amount of limiting reactant available, reactant_coefficient for that species in the balanced equation, and product_coefficient for the product species. All must be finite; reactant_moles and product_coefficient must be non-negative, and reactant_coefficient must be strictly greater than zero. A reactant coefficient of zero is rejected with invalid_input because the mole ratio would divide by zero and a zero coefficient means that species is not a reactant in the stoichiometry you claimed—failed requests are not charged. Identify the true limiting reactant before calling if more than one reactant is present; this endpoint scales a single reactant amount by one product ratio only.

Where teams plug product moles into workflows

Laboratory technicians convert planned feed amounts into theoretical product moles for batch sheets and scale-up notes. Process engineers embed the same check in electronic batch records when comparing campaign lots or validating charge calculations. Documentation writers embed live examples so readers can change moles and coefficients without leaving the page. Educational product teams expose the free browser form on study pages and call the API from graders that score homework at scale. Because each successful call is a single analytic item priced at $0.002, batch scripts can sweep grids of reactant amounts or curriculum problem banks without model cost or subscription overhead. Prefer this endpoint when you already know reactant moles and balanced coefficients and only need the transparent product amount—not a full multi-reactant limiting-reagent solver, mass-to-mass converter, or percent-yield calculator, which need richer inputs or different capabilities such as chem.percent_yield once actual recovery is known.

Integration use cases

Automated grading and study tools

Score student product-mole answers or power interactive study pages with a deterministic JSON result.

Technical questions

How much does each API call cost?

$0.002 per successful request. The browser tool above runs free locally; the API draws from your prepaid KIT balance only when the task succeeds.

Read the full KIT documentation →

Run — free