Weight converter
Switch a weight between kilograms, grams, pounds and ounces using exact definitions: one pound is precisely 0.45359237 kg, so 2.5 kg come out as 5.51155655462194 lb. Made for shipping labels, recipes, product sheets and fitness records. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 2.5
- From
- Kg
- To
- Lb
- Converted weight
- 5.5115565546
This weight converter changes a value between kilograms, grams, pounds, and ounces in one deterministic calculation. Enter the numeric weight, choose its current unit, and choose the unit you need. The result uses internationally recognized avoirdupois relationships, including the exact definition of a pound as 0.45359237 kilograms. It is useful for shipping, recipes, product specifications, fitness records, and any workflow where metric and customary weight measurements need to agree without manual arithmetic or an external lookup.
Choose the value and both units
Start by entering a finite, nonnegative number in the value field. Then select the source unit in the from field and the destination unit in the to field. The supported choices are kg for kilograms, g for grams, lb for pounds, and oz for ounces.
Keeping the unit codes explicit prevents an important class of mistakes: a bare number such as 12 has no reliable meaning until its unit is known. The converter accepts decimal values, so measurements such as 0.75 kilograms or 2.5 pounds work without first turning them into fractions. You may also convert a unit to itself when you need to normalize an input while preserving its magnitude.
Unsupported spellings and unit systems produce an error instead of a guessed result. That strict behavior is valuable in automation because a typo cannot silently become a plausible but incorrect shipment, ingredient, or inventory weight. For best results, copy the returned unit code together with the converted number whenever the value leaves your immediate calculation.
Understand how the conversion is calculated
Every conversion passes through grams as a common reference. One kilogram equals 1,000 grams. One international avoirdupois pound equals exactly 453.59237 grams, and one avoirdupois ounce equals exactly 28.349523125 grams.
The converter multiplies the entered value by the source unit's grams-per-unit factor, then divides that gram quantity by the target unit's factor. Using one fixed table for all directions keeps reciprocal conversions consistent and avoids maintaining separate formulas for every possible pair. The returned number is rounded only enough to remove floating-point noise while retaining fifteen significant digits, which is more precision than ordinary scales and shipping systems provide.
This does not make the original measurement more accurate: if a kitchen scale reports whole grams, a long decimal result in ounces still reflects a whole-gram observation. Treat the result's meaningful precision according to the measuring device, published specification, or business rule that produced the source value. The algorithm has no network calls, random values, or time-dependent data, so identical valid inputs always return identical outputs.
Use converted weights safely in real work
Weight conversions appear simple, but context still matters. Pounds and ounces here mean the international avoirdupois units used for ordinary goods and body weight, not troy units used for precious metals. The calculation converts mass quantities as they are commonly labeled; it does not account for local gravity, scale calibration, packaging tolerances, moisture changes, or legal rounding requirements.
In a shipping workflow, convert the packed parcel rather than adding independently rounded item conversions, because repeated rounding can accumulate. In recipes, preserve enough precision during scaling and round only when the ingredient can actually be measured. In product data, store the original value and unit beside the converted result so an audit can distinguish supplied data from derived data.
Both paths use the same deterministic conversion logic and return the converted weight with its source and target unit codes.
What you can do with it
Prepare shipping data
Convert a parcel weight from kilograms to pounds or ounces for a carrier form while retaining the original measurement.
Scale recipes and labels
Change ingredient or package weights between grams and customary units without maintaining separate conversion formulas.
Normalize product records
Convert supplier weights to one standard unit before comparing, sorting, or storing catalogue items.
FAQ
Which units are supported?
The supported unit codes are kg for kilograms, g for grams, lb for international avoirdupois pounds, and oz for avoirdupois ounces.
Can I convert decimal weights?
Yes. The value may be zero or any finite, nonnegative decimal number within the numeric range.
Are pounds and ounces troy units?
No. They are international avoirdupois pounds and ounces, the units normally used for body weight, food, parcels, and general goods.
How many grams are in an ounce?
One avoirdupois ounce is exactly 28.349523125 grams. Every conversion passes through grams, so ounces, pounds and kilograms always agree with each other in both directions.
Why does the result show so many decimals?
The converter keeps fifteen significant digits so nothing is lost along the way. That does not make your scale more precise: round the answer to what your device or specification actually reports.
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/weight-converter \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":2.5,"from":"kg","to":"lb"}'const res = await fetch("https://api.kit.forhosting.com/conv/weight-converter", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 2.5,
"from": "kg",
"to": "lb"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/weight-converter",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 2.5,
"from": "kg",
"to": "lb"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/weight-converter", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":2.5,"from":"kg","to":"lb"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":2.5,"from":"kg","to":"lb"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/weight-converter", 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": 2.5,
"from": "kg",
"to": "lb"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.weight_converter",
"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
Use converted weights safely in real work
Automated callers should handle an invalid_input response as a data-quality problem and correct the unsupported unit rather than substituting a default. The browser tool is convenient for individual checks, while the API costs $0.002 per request and is suited to repeatable integrations.
Technical questions
What happens if I provide an unsupported unit?
The request returns an invalid_input error that identifies the unsupported source or target unit instead of guessing.
How much does an API conversion cost?
Each API request costs $0.002. The same deterministic calculation can also run free in the browser.