Equivalent weight converter
Switch a chemical equivalent weight between eight units in one step: 49.04 g/eq reads as 49.04 mg/meq, and 1 kg/eq is exactly 1000 g/eq. Handy beside a titration manual or a reagent certificate. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 49.04
- Source unit
- g/eq
- Target unit
- mg/meq
- Result
- 49.04
- From label
- grams per equivalent
- To label
- milligrams per milliequivalent
- G eq
- 49.04
An equivalent weight converter turns a chemical equivalent mass written in grams per equivalent, kilograms per equivalent, milligrams per milliequivalent, or related mass-per-equivalent units into any other unit in that set without hunting conversion tables or rewriting spreadsheet formulas.
Supported units and how the conversion is computed
The converter accepts eight equivalent-weight families under stable canonical codes: g/eq for grams per equivalent, kg/eq for kilograms per equivalent, mg/eq for milligrams per equivalent, mg/meq for milligrams per milliequivalent, g/meq for grams per milliequivalent, kg/keq for kilograms per kiliequivalent, ug/ueq for micrograms per microequivalent, and lb/eq for avoirdupois pounds per equivalent.
Factors follow SI decimal prefixes and the exact avoirdupois pound: one kilogram per equivalent is exactly one thousand grams per equivalent; one milligram per equivalent is exactly one thousandth of a gram per equivalent; milli-, kilo-, and micro- prefixes cancel when both the mass and the equivalent share the same scale, so mg/meq, kg/keq, and ug/ueq are each numerically identical to g/eq.
Because the intermediate is always g/eq, converting A to B and B to A is consistent up to the published rounding of twelve decimal places, and there is no pairwise matrix that can drift out of sync. Molar mass, n-factor, normality, and concentration calculators are intentionally out of scope so this landing stays a pure unit converter for equivalent weight alone.
From the lab bench to the classroom
Use the free in-browser equivalent weight converter when you need a quick g/eq to mg/meq, kg/eq to g/eq, or mg/eq to g/eq check while reading a titration manual, reagent certificate, pharmaceutical worksheet, or analytical chemistry textbook. Open the page, enter the number and units, and copy the result without installing a spreadsheet, a unit library, or a desktop calculator pack. Source inputs follow the same retention rules as other KIT parse items, and results are safe to cache because the algorithm is fully deterministic.
Authors shipping mobile apps or chatbots can map the result and formula fields directly into cards that show both the number and the conversion path chemists expect on paper.
What you can do with it
Titration and analytical lab notes
Convert published equivalent weights between g/eq and mg/meq so bench notebooks and electronic logs share one view without hand-written factors.
Reagent certificates and bulk specs
Normalize kg/eq and g/eq on certificates of analysis when suppliers mix SI mass-per-equivalent scales.
FAQ
Which units does the equivalent weight converter support?
g/eq, kg/eq, mg/eq, mg/meq, g/meq, kg/keq, ug/ueq, and lb/eq.
Is mg/meq the same as g/eq?
Yes, numerically: one milligram per milliequivalent equals one gram per equivalent because both the mass and the equivalent are scaled by one thousand.
What happens if I send an unknown unit?
The message names the field and lists supported units. Validation failures are not charged.
Is the equivalent weight converter free?
The browser tool runs free on your device.
How do I convert kg/eq to g/eq?
Multiply by 1000: one kilogram per equivalent is exactly one thousand grams per equivalent. To go back from g/eq to kg/eq, divide by 1000; the converter uses the same factors in both directions.
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/conv/equivalent-weight \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":49.04,"from":"g/eq","to":"mg/meq"}'const res = await fetch("https://api.kit.forhosting.com/conv/equivalent-weight", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 49.04,
"from": "g/eq",
"to": "mg/meq"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/equivalent-weight",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 49.04,
"from": "g/eq",
"to": "mg/meq"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/equivalent-weight", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":49.04,"from":"g/eq","to":"mg/meq"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":49.04,"from":"g/eq","to":"mg/meq"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/equivalent-weight", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"value": 49.04,
"from": "g/eq",
"to": "mg/meq"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.equivalent_weight",
"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 browser tool runs free on your device; the prepaid API charges $0.002 per successful item when pipelines need the same contract from servers and automation.
Supported units and how the conversion is computed
Friendly aliases such as geq, g-eq, grams per equivalent, milligrams per milliequivalent, kg per eq, and pounds per equivalent are normalized case-insensitively so forms and APIs can pass either short codes or full names. Every request multiplies the input value by the exact g/eq-per-unit factor for the source, then divides by the g/eq-per-unit factor for the target.
Request shape, response fields, and unknown-unit errors
The error message names the bad field and lists the supported set so clients can correct forms without guessing. Negative values are allowed when you need signed deltas in inventory pipelines; zero converts cleanly to zero in every target unit. Send a JSON body with three required fields: value as a finite number, from as the source unit string, and to as the target unit string. Aliases amount, quantity, equivalent_weight, and ew are accepted for value; unit_from and source for from; unit_to and target for to. On success the response echoes the canonical from and to codes, human-readable from_label and to_label strings, the converted result, the intermediate g_eq quantity, the dimensionless factor from source to target, a short formula line suitable for UI display, the method tag equivalent_weight_si, and the fixed list of units_supported. Missing value, non-finite numbers such as NaN or Infinity, missing unit fields, and any token that does not map to a supported unit fail with invalid_input and are not charged after the engine rejects the request. Identical inputs always yield identical JSON because the path is pure arithmetic with no randomness, no remote lookup, and no dependence on the wall clock, which makes the endpoint safe to pin in continuous-integration goldens and SDK contract tests. Bulk kg/eq reagent sheets and trace mg/eq worksheets share the same code path, so extreme magnitude pairs remain well-defined as long as IEEE double precision can represent the intermediate g/eq product.
Browser use, API pricing, and lab or teaching workflows
Switch to the prepaid API when a LIMS adapter, titration log app, e-learning problem generator, SDS normalization pipeline, or materials inventory system must convert mass-per-equivalent units at scale under a stable KIT contract at $0.002 per successful item; validation failures that raise invalid_input do not consume balance after rejection. Pair this endpoint with molarity or normality tools when a product pipeline needs several chemistry measure families, or call it alone when search traffic is specifically for equivalent weight conversion—g/eq, kg/eq, mg/meq, and related codes—rather than a general unit switchboard.
Integration use cases
Teaching tools and automated pipelines
Call a prepaid, deterministic equivalent-weight API from homework generators and LIMS adapters with clear invalid_input on unknown units.
Technical questions
How do I convert 49.04 g/eq to mg/meq?
Send JSON with value: 49.04, from: "g/eq", to: "mg/meq". The response result field is 49.04, plus a g_eq intermediate and a readable formula.