ForHosting KIT · Science

Percent yield calculator

Recovering 8.5 g of product when stoichiometry predicts 10 g is an 85 % yield: enter the actual and theoretical amounts in grams, moles or any shared unit and get the percent yield and the plain ratio. 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

Actual: 8.5
Theoretical: 10

You get

Ratio: 0.85
Percent yield: 85

Percent yield measures how efficiently a chemical reaction produces the desired product compared with the stoichiometric maximum. You divide the actual (experimental) mass or moles of product by the theoretical yield predicted from the balanced equation and limiting reactant, then multiply by one hundred. Use it for lab reports, homework checks, batch-record validation, and any pipeline that needs a repeatable percent-yield figure without spreadsheets or one-off scripts.

What percent yield means in practice

Theoretical yield is the maximum amount of product that can form when the limiting reactant is fully converted according to the balanced equation and pure stoichiometry. Actual yield is what you isolate or measure after the reaction, workup, and purification. Real reactions almost never hit one hundred percent: side reactions, incomplete conversion, transfers between glassware, and losses during filtration or recrystallization all reduce the recovered product.

Percent yield converts those two amounts into a single efficiency metric that labs, textbooks, and process records share. The formula is simple: percent yield equals actual yield divided by theoretical yield, times one hundred. Values above one hundred percent usually signal a measurement or calculation error—wet product, mis-weighed limiting reactant, or an incorrect theoretical baseline—rather than a physical miracle.

Values near zero can mean the reaction failed, the wrong product was isolated, or units between actual and theoretical were mixed. This tool never invents chemistry: it only applies the arithmetic once you supply both numbers in consistent units, so the quality of the answer depends on how carefully you computed the theoretical yield from stoichiometry beforehand.

What you can do with it

Lab report and homework checks

Compute percent yield from measured product and stoichiometric theoretical yield before students or lab partners finalize lab notebooks.

Batch and campaign efficiency

Record recovered product against the theoretical maximum so process notes reflect true reaction efficiency across lots.

FAQ

How is percent yield calculated?

Percent yield equals actual yield divided by theoretical yield, multiplied by one hundred. The response also returns the unitless ratio actual over theoretical for audit logs.

What if the theoretical yield is zero?

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

Can percent yield be over 100%?

Yes, the arithmetic allows it when actual exceeds theoretical. That usually signals wet product, weighing error, or a wrong theoretical baseline rather than true super-stoichiometric recovery.

Why is my percent yield below 100 %?

Real reactions rarely convert everything. Side reactions, incomplete conversion, product left behind when moving it between glassware, and losses during filtration or recrystallization all reduce what you recover, so a yield under 100 % is normal.

Can I enter moles instead of grams?

Yes. Grams with grams, moles with moles or any other shared unit works, as long as both amounts use the same one. The calculator does not convert units, so mixing grams and moles would give a meaningless percentage.

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/percent-yield

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/percent-yield \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"actual_yield":8.5,"theoretical_yield":10}'

const res = await fetch("https://api.kit.forhosting.com/chem/percent-yield", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "actual_yield": 8.5,
    "theoretical_yield": 10
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/chem/percent-yield",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "actual_yield": 8.5,
    "theoretical_yield": 10
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/chem/percent-yield", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"actual_yield":8.5,"theoretical_yield":10}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"actual_yield":8.5,"theoretical_yield":10}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/chem/percent-yield", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "actual_yield": 8.5,
  "theoretical_yield": 10
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "chem.percent_yield",
  "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 single transparent calculation deterministically: two finite numbers in, percent yield and ratio out, with a fixed twelve-decimal rounding policy so browser and API results match.

Inputs, outputs, and validation rules

Units are not converted inside the capability: grams with grams, moles with moles, or any shared mass basis works as long as both fields use the same scale. A classic homework check is eight point five grams recovered against ten grams theoretical, which yields eighty-five percent and a ratio of zero point eight five. Convert mass from balances and theoretical amounts from mole maps before calling if you need chemically absolute percentages rather than relative bookkeeping on mismatched units. Send two required numbers: actual_yield for the experimental product amount and theoretical_yield for the stoichiometric maximum. Both must be finite; actual_yield must be non-negative, and theoretical_yield must be strictly greater than zero. A theoretical yield of zero is rejected with invalid_input because division by zero is undefined and a zero maximum is not a meaningful reaction baseline—failed requests are not charged.

Where teams plug percent yield into workflows

Laboratory technicians and quality teams record recovered product against the batch theoretical maximum so a run cannot claim high efficiency without the arithmetic. Process engineers embed the same check in electronic batch records and scale-up notes when comparing campaign lots or process improvements. Documentation writers embed live examples so readers can change yields 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 experimental results or curriculum problem banks without model cost or subscription overhead. Prefer this endpoint when you already know actual and theoretical amounts and only need the transparent percent—not a full limiting-reactant solver, multi-product mass balance, or equilibrium calculator, which need richer inputs and different capabilities.

Integration use cases

Automated grading and study tools

Score student percent-yield answers or power interactive study pages with a deterministic JSON result.

Technical questions

What units should I use?

Any consistent unit works—grams or moles are typical—as long as actual_yield and theoretical_yield share the same basis. The tool does not convert units.

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