Molarity to normality calculator
0.5 M sulfuric acid used as a diprotic acid is 1 N. Multiply a molarity by the equivalents each mole supplies in your reaction and get the normality that titration tables and older specs still quote. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Solution molarity in mol/L
- 0.5
- Equivalents per mole
- 2
- Normality
- 1 eq/L
Titration tables, acid–base worksheets, and many industrial specs still quote solution strength in normality, while modern curricula and stock labels emphasize molarity in moles per liter. Bridging those two concentration systems requires one extra number: the equivalents per mole, also called the n-factor or valence factor for the reaction under study. Normality equals molarity times that factor, so a half-molar sulfuric acid used as a diprotic acid is one-normal when n equals two, and a monoprotic strong acid keeps the same numeric value for M and N when n equals one.
How molarity becomes normality and which inputs to send
Start from a concentration reported as molarity in moles per liter and the number of equivalents contributed by each mole of solute in the reaction of interest. In classical volumetric analysis, normality multiplies molarity by that equivalents-per-mole factor so that one liter of one-normal solution supplies one equivalent of reactive capacity.
For monoprotic strong acids and bases the factor is often one, so numerical molarity and normality coincide; for diprotic acids such as sulfuric acid in full neutralization the factor is two; for many redox titrations the factor equals the electrons transferred per formula unit. Molarity must be non-negative because a negative concentration is not physical in this product. Identical inputs always produce identical outputs because there is no network call, no model, no random seed, and no wall clock in the path.
Classroom examples include converting zero point five molar sulfuric acid with n equals two into one normal, or turning a zero point one molar permanganate stock into normality once the half-reaction electron count is known.
What you can do with it
Acid–base titration worksheets
Convert molar HCl, NaOH, or H₂SO₄ stocks into normality using the correct n-factor for full neutralization before students fill burette tables.
FAQ
What n-factor should I use for sulfuric acid?
For complete acid–base neutralization of H₂SO₄, n is often 2 (two protons). For partial neutralization or redox contexts the factor may differ—use the value that matches your reaction.
Is the molarity to normality calculator free?
The browser tool runs free on your device.
Does monoprotic mean M equals N?
When equivalents per mole is 1, normality equals molarity numerically.
How do I convert molarity to normality?
Multiply the molarity by the equivalents per mole, the n-factor for the reaction you are using. Normality then tells you how many equivalents of reactive capacity one litre of solution supplies.
What n-factor should I use in a redox titration?
Use the number of electrons transferred per formula unit in the half-reaction. A 0.1 M permanganate stock, for example, can only be turned into normality once that electron count is known.
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/molarity-to-normality \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"molarity":0.5,"equivalents_per_mole":2}'const res = await fetch("https://api.kit.forhosting.com/chem/molarity-to-normality", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"molarity": 0.5,
"equivalents_per_mole": 2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/chem/molarity-to-normality",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"molarity": 0.5,
"equivalents_per_mole": 2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/chem/molarity-to-normality", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"molarity":0.5,"equivalents_per_mole":2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"molarity":0.5,"equivalents_per_mole":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/chem/molarity-to-normality", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"molarity": 0.5,
"equivalents_per_mole": 2
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "chem.molarity_to_normality",
"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
This capability accepts non-negative molarity and a strictly positive equivalents-per-mole value, returns normality in equivalents per liter with a stable formula label, and fails with invalid_input when the n-factor is zero or negative so pipelines never invent a meaningless product. Homework checkers, LIMS scripts, teaching apps, and quality dashboards can pin the same JSON in tests without embedding a chemistry CAS.
How molarity becomes normality and which inputs to send
Send a JSON object with required fields molarity and equivalents_per_mole as finite numbers or numeric strings; aliases such as M, molar, mol_per_L, n, n_factor, eq_per_mol, equivalents, and valence_factor are accepted when documented by the SDK so client code can speak laboratory English. Equivalents per mole must be strictly positive: a zero value would make normality zero for every molarity in a way that hides a blank or mis-parsed n-factor column, and negative n is rejected outright with invalid_input and an explicit message rather than returning a signed nonsense result.
Reading the response: normality, unit, formula, and method
The unit field is always eq/L so UI code can label the primary result without hard-coding strings across locales. Use normality alone when a titration notebook still expects N on the burette side; use the echoed molarity and n-factor when a report must show the intermediate values for auditors; use formula and unit together when a teaching page needs a one-line caption under the answer. Validation failures such as zero or negative equivalents per mole mention the offending field so technicians can correct a blank n-factor without reading a stack trace. On success the response echoes numeric molarity and equivalents_per_mole, then reports normality after stable rounding as the product of the two inputs. Formula restates N equals M times n, which is the definition used throughout analytical chemistry textbooks for this conversion, and method is always molarity_to_normality so downstream routers can branch without sniffing shapes. Missing fields, non-finite numbers, and negative molarity also raise 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 molarity to normality calculator for homework checks, lecture demos, and quick bench conversions without installing a spreadsheet formula library. The n-factor is reaction-dependent: the same solute can have different equivalents per mole in acid–base versus redox contexts, so the calculator never guesses n from a formula string—you supply the factor that matches the intended reaction. Authors shipping SDKs can map the two fields into labeled inputs Molarity mol/L and Equivalents per mole with the normality cell auto-filled—the same columns students write when they convert M to N by hand on paper. Send a JSON body with molarity and equivalents_per_mole as numbers or numeric strings. Use the prepaid API when a LIMS integration, tutoring platform, quality dashboard, or inventory system 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 a dilution calculator or a molar mass tool in your own pipeline when the next step is preparing a stock or checking grams per liter before the normality conversion.
Integration use cases
Homework and exam verification
Students send M and n, compare normality against structured JSON, and see clear invalid_input errors when the n-factor is zero or negative.
LIMS and teaching app integrations
Scripts and curriculum tools call a stable prepaid endpoint instead of reimplementing N = M × n in every language and spreadsheet.
Technical questions
How do I convert molarity to normality?
Send JSON with molarity (mol/L) and equivalents_per_mole (n-factor). The response returns normality using N = M × n, with unit eq/L.
What happens if equivalents per mole is zero or negative?
The request fails with invalid_input. Zero or negative n-factors are rejected; equivalents_per_mole must be a strictly positive finite number.