Parts per thousand calculator
5 g of solute in a 1000 g solution is 5 ‰: enter the solute mass and the total mass and you also get the mass fraction and the solvent mass, ready for salinity notes or lab reports. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Mass of the solute
- 5
- Total mass
- 1,000
- Solvent mass
- 995
- Mass fraction
- 0.005
- Parts per thousand
- 5
Parts per thousand, written as the per-mille sign or ppt by mass, answers a common analytical question: how many parts of solute are present in each one thousand parts of solution by mass? Oceanographers quote salinity near thirty-five parts per thousand, clinical and environmental labs report dilute analytes on the same scale, and classroom stoichiometry converts mass fraction into a readable whole-number concentration. This capability computes that value deterministically from solute mass and total solution mass using the definition parts per thousand equals mass of solute divided by total mass times one thousand, also returns mass fraction and solvent mass for pipeline math, and rejects zero or negative total mass with a clear invalid input error so notebooks, LIMS hooks, and homework checkers never see Infinity.
Definition of parts per thousand and how to prepare the two inputs
Parts per thousand by mass is defined as ‰ equals m of solute divided by m of total solution, then multiplied by one thousand. If you dissolve five grams of solute in a solution whose total mass is one thousand grams, parts per thousand is five and mass fraction is zero point zero zero five. Both values must be finite; solute mass must be non-negative and total mass must be strictly positive.
Zero total mass is invalid input because division by zero is undefined for this product—the engine never invents an infinite concentration. Negative total mass is also rejected so the contract stays honest for laboratory and field work. Use any coherent mass unit pair such as grams with grams or kilograms with kilograms; the ratio is dimensionless and the per-mille scale factor is unit-free.
What you can do with it
Homework and lab report checks
Students enter solute and total solution mass, verify ‰ against worked answers, and get a clear error when total mass is zero or negative by mistake.
Salinity and dilute solutions
Oceanography and environmental notebooks convert batch solute mass and total mass into parts per thousand for salinity-style labels and SPC charts.
FAQ
What happens if total mass is zero or negative?
Parts per thousand divides solute mass by total mass, so a zero or negative denominator is rejected and not charged.
Is parts per thousand the same as mass percent or ppm?
No. Parts per thousand uses a scale factor of 1000; mass percent uses 100; ppm uses 1_000_000.
Is the parts per thousand calculator free?
The browser tool runs free on your device.
Which units should I use?
Any coherent mass unit pair (g with g, kg with kg, …). The ratio is dimensionless; only the scale factor of 1000 turns mass fraction into parts per thousand.
Do I enter the solvent mass or the total solution mass?
Enter the total mass of the solution, meaning solute plus solvent. Using the solvent alone gives a slightly high result. The calculator works out the solvent mass for you and shows it next to the answer.
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/parts-per-thousand \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"solute_mass":5,"total_mass":1000}'const res = await fetch("https://api.kit.forhosting.com/chem/parts-per-thousand", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"solute_mass": 5,
"total_mass": 1000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/chem/parts-per-thousand",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"solute_mass": 5,
"total_mass": 1000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/chem/parts-per-thousand", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"solute_mass":5,"total_mass":1000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"solute_mass":5,"total_mass":1000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/chem/parts-per-thousand", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"solute_mass": 5,
"total_mass": 1000
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "chem.parts_per_thousand",
"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
The free browser parts per thousand calculator runs on your device with no account; the prepaid API charges $0.002 per successful item when servers and SDKs need the same stable contract.
Definition of parts per thousand and how to prepare the two inputs
Send the required fields solute_mass and total_mass as JSON numbers or numeric strings; aliases solute, m_solute, and mass_solute map to the numerator, while total, m_total, solution_mass, and mass_solution map to the denominator. Identical inputs always produce identical JSON because the path is pure arithmetic with no network, no random seed, and no wall clock. Classroom exercises, salinity worksheets, and quality-control sheets all use the same definition, so pinning expected parts_per_thousand in tests is safe across runs and languages.
Reading parts_per_thousand, mass_fraction, solvent_mass, and error cases
Values whose absolute magnitude exceeds the published bound are rejected for isolate safety. Very large per-mille values are mathematically allowed when solute mass is high relative to total mass—useful for catching unit mistakes—so callers that require a practical concentration band should validate that range in their own UI after reading the response. On success the response echoes solute_mass and total_mass, reports parts_per_thousand as one thousand times the mass fraction, returns mass_fraction as the raw ratio m_solute over m_total, and computes solvent_mass as total mass minus solute mass. The formula field is always the string per-mille equals m_solute over m_total times one thousand, and method is always parts_per_thousand so downstream code can branch without sniffing shapes. Use parts_per_thousand when labels, oceanography notes, or student answers expect the per-mille scale; use mass_fraction when the next step is conversion to mass percent by multiplying by one hundred or to ppm by multiplying by one million. Missing either required field, non-finite numbers, negative solute mass, zero total mass, and negative total mass all fail with invalid_input and are not charged after the engine rejects the request.
API usage, pricing, lab workflows, and practical limits
Call the free in-browser parts per thousand calculator for homework checks, lecture demos, and quick batch math without installing a spreadsheet or chemistry CAS. Parts per thousand is not mass percent: the scale factor is one thousand, not one hundred, and not parts per million, whose scale factor is one million—this product intentionally focuses on the per-mille search intent from two masses. Send a JSON body with solute_mass and total_mass in the same mass unit, optionally using the documented aliases if your form already says solution_mass or m_solute. Use the prepaid API when a LIMS, tutoring platform, oceanographic notebook, or process-control pipeline 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 mass fraction tools when you need weight fraction or mass percent as the primary label, with weight/volume percent when the denominator is volume instead of total mass, or with ppm and ppb converters when you already hold a parts-per-million value and only need scale factors. Authors shipping SDKs can map parts_per_thousand directly into UI labels and mass_fraction into internal composition models—the same two numbers students write on paper when they compute parts per thousand by hand.
Integration use cases
LIMS and tutoring APIs
Platforms call a stable prepaid endpoint for ‰ concentration instead of reimplementing mass-ratio math in every client language.
Technical questions
How do I calculate parts per thousand with this tool?
Send JSON with solute_mass and total_mass in the same unit (for example 5 and 1000). The response includes parts_per_thousand, mass_fraction, and solvent_mass.