Free weight converter for pounds, kilograms, ounces, and grams. Instant conversions for cooking, fitness tracking, shipping, and scientific measurements with NIST-accurate formulas.
Need to convert 150 pounds to kilograms for a fitness app? Or translate 250 grams to ounces for a recipe? This weight converter handles instant conversions between pounds (lbs), kilograms (kg), ounces (oz), and grams (g)—the four most common units you'll encounter in cooking, fitness tracking, shipping, and scientific work.
What makes this tool practical: it converts to all units simultaneously. Enter your weight once, and you'll see the equivalent in the other three units instantly. No button clicking, no repeated calculations—just enter your value and select your starting unit.
Three steps get you accurate conversions:
That's it. Change the number or switch units, and results update instantly. You might find this particularly useful when working with international recipes—enter the ingredient weight in grams, and immediately see the ounce equivalent your measuring cups show.
This tool validates your input to prevent calculation errors:
A common mistake: entering commas in large numbers. Use 1000 instead of 1,000 for better compatibility across different locale settings.
Weight conversion between different units relies on precise mathematical relationships. Understanding these conversion factors helps ensure accuracy in various applications.
All weight conversions are based on the following fundamental relationships:
Metric System Conversions:
Imperial System Conversions:
Metric to Imperial Conversions:
For any weight conversion, the formula follows this pattern:
Where the conversion factor represents the precise mathematical relationship between the source and target units.
| From/To | Pounds (lb) | Kilograms (kg) | Ounces (oz) | Grams (g) |
|---|---|---|---|---|
| Pounds (lb) | 1 | 0.45359237 | 16 | 453.59237 |
| Kilograms (kg) | 2.20462262 | 1 | 35.2739619 | 1,000 |
| Ounces (oz) | 0.0625 | 0.028349523 | 1 | 28.349523 |
| Grams (g) | 0.002204623 | 0.001 | 0.035273962 | 1 |
To convert pounds to other units:
Pounds to Kilograms: Multiply pounds by 0.45359237
Pounds to Ounces: Multiply pounds by 16
Pounds to Grams: Multiply pounds by 453.59237
To convert kilograms to other units:
Kilograms to Pounds: Multiply kilograms by 2.20462262
Kilograms to Ounces: Multiply kilograms by 35.2739619
Kilograms to Grams: Multiply kilograms by 1,000
To convert ounces to other units:
Ounces to Pounds: Divide ounces by 16 (or multiply by 0.0625)
Ounces to Kilograms: Multiply ounces by 0.028349523
Ounces to Grams: Multiply ounces by 28.349523
To convert grams to other units:
Grams to Pounds: Multiply grams by 0.002204623
Grams to Kilograms: Divide grams by 1,000 (or multiply by 0.001)
Grams to Ounces: Multiply grams by 0.035273962
Here's a scenario many home cooks encounter: you're following a European baking recipe that calls for 250 grams of flour, but your kitchen scale only shows ounces. That's 8.82 oz—close enough to treat as 9 oz for most recipes.
In my experience with recipe conversions, small rounding errors in flour (within 5-10g) rarely affect the outcome. However, precision matters more with leavening agents. When a recipe specifies 5 grams of baking powder, that's 0.176 oz—you'll want to use measuring spoons rather than eyeballing it.
When weight conversion matters most:
Many fitness apps default to kilograms, while doctors in the US measure in pounds. If your goal is to lose 10 kg, that's 22 pounds—which sounds more significant and might feel more motivating to track.
What I've found useful: tracking in kilograms gives you finer gradations. A 0.5 kg loss (about 1.1 lbs) shows meaningful progress weekly, whereas a 1-pound minimum increment on some scales can mask smaller changes.
Common scenarios:
Shipping carriers have specific weight thresholds that dramatically affect pricing. A 5-pound package (2.27 kg) might fall into one rate category, while a 5.5-pound package (2.49 kg) jumps to the next pricing tier.
Here's what happens frequently: you're shipping internationally and the form asks for weight in kilograms, but your postal scale shows pounds. A small Amazon package at 2 lbs converts to 0.91 kg. Round up to 1 kg for shipping forms—carriers charge by dimensional weight anyway, so slight overestimates prevent unexpected fees.
Real-world applications:
Laboratory work demands precision that goes beyond everyday measurements. When a chemistry protocol specifies 15.5 grams of a reagent, you need exactly that—not the ounce equivalent rounded to two decimal places.
Most lab equipment displays in metric units globally. However, older US labs or field work sometimes involves Imperial measurements. Understanding the conversion lets you verify that a sample weight makes sense: if someone reports 0.547 oz, you can quickly check that's 15.5 g—a reasonable sample size.
Key considerations:
Manufacturing tolerances often specify acceptable weight ranges. A component might need to weigh 500g ±5g for quality approval. That's 17.64 oz ±0.18 oz—tighter than it looks when you see the ounce values.
Quality engineers frequently work with suppliers using different measurement systems. A US manufacturer ordering steel from a European supplier needs to convert specifications: 2,000 lbs of material becomes 907 kg on the purchase order.
The development of weight measurement systems reflects humanity's evolution from local trade to global commerce. Understanding this history provides context for modern conversion needs.
Early civilizations developed weight systems based on natural references:
Medieval trade expansion required more consistent weight standards:
The Imperial system evolved from English customary units:
The metric system emerged from Enlightenment ideals of rational measurement:
20th and 21st-century efforts established global weight standards:
This historical evolution explains why multiple weight systems coexist today and why accurate conversion tools remain essential for global communication and commerce.
Understanding weight conversion through code examples helps developers implement conversion functionality and provides insight into the mathematical relationships between units.
Excel provides an accessible platform for weight conversion calculations:
1' Convert pounds to kilograms
2=A1*0.45359237
3
4' Convert kilograms to pounds
5=A1*2.20462262
6
7' Convert ounces to grams
8=A1*28.349523
9
10' Convert grams to ounces
11=A1*0.035273962
12
13' Universal weight converter function
14Function ConvertWeight(value, fromUnit, toUnit)
15 ' Conversion factors to grams (base unit)
16 Select Case fromUnit
17 Case "lb": baseValue = value * 453.59237
18 Case "kg": baseValue = value * 1000
19 Case "oz": baseValue = value * 28.349523
20 Case "g": baseValue = value
21 End Select
22
23 ' Convert from grams to target unit
24 Select Case toUnit
25 Case "lb": ConvertWeight = baseValue / 453.59237
26 Case "kg": ConvertWeight = baseValue / 1000
27 Case "oz": ConvertWeight = baseValue / 28.349523
28 Case "g": ConvertWeight = baseValue
29 End Select
30End Function
31Python offers flexible weight conversion with error handling:
1class WeightConverter:
2 def __init__(self):
3 # Conversion factors to grams (base unit)
4 self.to_grams = {
5 'lb': 453.59237,
6 'kg': 1000.0,
7 'oz': 28.349523,
8 'g': 1.0
9 }
10
11 # Conversion factors from grams
12 self.from_grams = {
13 'lb': 1 / 453.59237,
14 'kg': 1 / 1000.0,
15 'oz': 1 / 28.349523,
16 'g': 1.0
17 }
18
19 def convert(self, value, from_unit, to_unit):
20 if value < 0:
21 raise ValueError("Weight cannot be negative")
22
23 if from_unit not in self.to_grams:
24 raise ValueError(f"Unknown unit: {from_unit}")
25
26 if to_unit not in self.from_grams:
27 raise ValueError(f"Unknown unit: {to_unit}")
28
29 # Convert to grams first, then to target unit
30 grams = value * self.to_grams[from_unit]
31 result = grams * self.from_grams[to_unit]
32
33 return round(result, 6)
34
35 def convert_all(self, value, from_unit):
36 """Convert to all other units"""
37 results = {}
38 for unit in self.to_grams.keys():
39 if unit != from_unit:
40 results[unit] = self.convert(value, from_unit, unit)
41 return results
42
43# Example usage
44converter = WeightConverter()
45print(f"10 lbs = {converter.convert(10, 'lb', 'kg')} kg")
46print(f"5 kg = {converter.convert(5, 'kg', 'lb')} lbs")
47all_conversions = converter.convert_all(100, 'g')
48print(f"100g converts to: {all_conversions}")
49JavaScript implementation suitable for web-based weight converters:
1class WeightConverter {
2 constructor() {
3 this.conversionFactors = {
4 // Conversion factors to grams
5 toGrams: {
6 'lb': 453.59237,
7 'kg': 1000,
8 'oz': 28.349523,
9 'g': 1
10 },
11 // Conversion factors from grams
12 fromGrams: {
13 'lb': 1 / 453.59237,
14 'kg': 1 / 1000,
15 'oz': 1 / 28.349523,
16 'g': 1
17 }
18 };
19 }
20
21 convert(value, fromUnit, toUnit) {
22 // Input validation
23 if (isNaN(value) || value < 0) {
24 throw new Error('Please enter a valid positive number');
25 }
26
27 if (!this.conversionFactors.toGrams[fromUnit]) {
28 throw new Error(`Unknown source unit: ${fromUnit}`);
29 }
30
31 if (!this.conversionFactors.fromGrams[toUnit]) {
32 throw new Error(`Unknown target unit: ${toUnit}`);
33 }
34
35 // Convert via grams as intermediate unit
36 const grams = value * this.conversionFactors.toGrams[fromUnit];
37 const result = grams * this.conversionFactors.fromGrams[toUnit];
38
39 // Round to appropriate precision
40 return Math.round(result * 1000000) / 1000000;
41 }
42
43 convertToAll(value, fromUnit) {
44 const results = {};
45 const units = ['lb', 'kg', 'oz', 'g'];
46
47 units.forEach(unit => {
48 if (unit !== fromUnit) {
49 results[unit] = this.convert(value, fromUnit, unit);
50 }
51 });
52
53 return results;
54 }
55}
56
57// Example usage
58const converter = new WeightConverter();
59console.log(`25 lbs = ${converter.convert(25, 'lb', 'kg')} kg`);
60console.log(`2 kg converts to:`, converter.convertToAll(2, 'kg'));
61Java implementation with BigDecimal for high-precision calculations:
1import java.math.BigDecimal;
2import java.math.RoundingMode;
3import java.util.HashMap;
4import java.util.Map;
5
6public class WeightConverter {
7 private static final Map<String, BigDecimal> TO_GRAMS = new HashMap<>();
8 private static final Map<String, BigDecimal> FROM_GRAMS = new HashMap<>();
9
10 static {
11 // Initialize conversion factors to grams
12 TO_GRAMS.put("lb", new BigDecimal("453.59237"));
13 TO_GRAMS.put("kg", new BigDecimal("1000"));
14 TO_GRAMS.put("oz", new BigDecimal("28.349523"));
15 TO_GRAMS.put("g", BigDecimal.ONE);
16
17 // Initialize conversion factors from grams
18 FROM_GRAMS.put("lb", BigDecimal.ONE.divide(TO_GRAMS.get("lb"), 10, RoundingMode.HALF_UP));
19 FROM_GRAMS.put("kg", new BigDecimal("0.001"));
20 FROM_GRAMS.put("oz", BigDecimal.ONE.divide(TO_GRAMS.get("oz"), 10, RoundingMode.HALF_UP));
21 FROM_GRAMS.put("g", BigDecimal.ONE);
22 }
23
24 public static BigDecimal convert(BigDecimal value, String fromUnit, String toUnit) {
25 if (value.compareTo(BigDecimal.ZERO) < 0) {
26 throw new IllegalArgumentException("Weight cannot be negative");
27 }
28
29 if (!TO_GRAMS.containsKey(fromUnit)) {
30 throw new IllegalArgumentException("Unknown source unit: " + fromUnit);
31 }
32
33 if (!FROM_GRAMS.containsKey(toUnit)) {
34 throw new IllegalArgumentException("Unknown target unit: " + toUnit);
35 }
36
37 // Convert to grams first
38 BigDecimal grams = value.multiply(TO_GRAMS.get(fromUnit));
39
40 // Convert from grams to target unit
41 BigDecimal result = grams.multiply(FROM_GRAMS.get(toUnit));
42
43 return result.setScale(6, RoundingMode.HALF_UP);
44 }
45
46 public static Map<String, BigDecimal> convertToAll(BigDecimal value, String fromUnit) {
47 Map<String, BigDecimal> results = new HashMap<>();
48 String[] units = {"lb", "kg", "oz", "g"};
49
50 for (String unit : units) {
51 if (!unit.equals(fromUnit)) {
52 results.put(unit, convert(value, fromUnit, unit));
53 }
54 }
55
56 return results;
57 }
58
59 public static void main(String[] args) {
60 BigDecimal weight = new BigDecimal("15.5");
61 System.out.println("15.5 lbs = " + convert(weight, "lb", "kg") + " kg");
62
63 Map<String, BigDecimal> allConversions = convertToAll(new BigDecimal("100"), "g");
64 System.out.println("100g converts to: " + allConversions);
65 }
66}
67C++ implementation optimized for performance-critical applications:
1#include <iostream>
2#include <unordered_map>
3#include <string>
4#include <stdexcept>
5#include <iomanip>
6
7class WeightConverter {
8private:
9 std::unordered_map<std::string, double> toGrams;
10 std::unordered_map<std::string, double> fromGrams;
11
12public:
13 WeightConverter() {
14 // Initialize conversion factors
15 toGrams["lb"] = 453.59237;
16 toGrams["kg"] = 1000.0;
17 toGrams["oz"] = 28.349523;
18 toGrams["g"] = 1.0;
19
20 fromGrams["lb"] = 1.0 / 453.59237;
21 fromGrams["kg"] = 0.001;
22 fromGrams["oz"] = 1.0 / 28.349523;
23 fromGrams["g"] = 1.0;
24 }
25
26 double convert(double value, const std::string& fromUnit, const std::string& toUnit) {
27 if (value < 0) {
28 throw std::invalid_argument("Weight cannot be negative");
29 }
30
31 auto fromIt = toGrams.find(fromUnit);
32 if (fromIt == toGrams.end()) {
33 throw std::invalid_argument("Unknown source unit: " + fromUnit);
34 }
35
36 auto toIt = fromGrams.find(toUnit);
37 if (toIt == fromGrams.end()) {
38 throw std::invalid_argument("Unknown target unit: " + toUnit);
39 }
40
41 // Convert via grams
42 double grams = value * fromIt->second;
43 return grams * toIt->second;
44 }
45
46 std::unordered_map<std::string, double> convertToAll(double value, const std::string& fromUnit) {
47 std::unordered_map<std::string, double> results;
48 std::vector<std::string> units = {"lb", "kg", "oz", "g"};
49
50 for (const auto& unit : units) {
51 if (unit != fromUnit) {
52 results[unit] = convert(value, fromUnit, unit);
53 }
54 }
55
56 return results;
57 }
58};
59
60int main() {
61 WeightConverter converter;
62
63 try {
64 double result = converter.convert(10.0, "lb", "kg");
65 std::cout << std::fixed << std::setprecision(6);
66 std::cout << "10 lbs = " << result << " kg" << std::endl;
67
68 auto allResults = converter.convertToAll(500.0, "g");
69 std::cout << "500g converts to:" << std::endl;
70 for (const auto& pair : allResults) {
71 std::cout << " " << pair.first << ": " << pair.second << std::endl;
72 }
73 } catch (const std::exception& e) {
74 std::cerr << "Error: " << e.what() << std::endl;
75 }
76
77 return 0;
78}
79These programming examples demonstrate various approaches to implementing weight conversion functionality, from simple Excel formulas to enterprise-grade Java implementations with precision handling.
Understanding weight conversion through real-world examples helps illustrate the practical applications and accuracy requirements of different scenarios.
International Recipe Adaptation:
Precision Cooking Applications:
Body Weight Tracking:
Nutrition and Supplement Dosages:
Package Weight Calculations:
International Trade:
It depends on what you're doing. For cooking, rounding to the nearest gram or ounce rarely matters. A recipe won't fail if you use 201g instead of 200g.
For shipping, round to the nearest 0.1 lb or kg—that's what most carriers accept. For lab work or medication dosing, use all available decimal places. The conversion factor of 1 pound = 0.45359237 kg is exact by definition (per NIST Special Publication 811), so any loss of precision comes from rounding, not the calculation.
History and habit. The metric system was designed in 1790s France to be logical and universal—everything in multiples of 10. The Imperial system evolved from Roman and medieval English units, with 16 ounces to a pound and 2.2 pounds to a kilogram.
Most of the world adopted metric for consistency. The US officially recognizes the metric system but continues using Imperial units in everyday life. This is why you need conversion tools—the world hasn't agreed on one system.
Yes, for mental math. That approximation (actual: 2.20462) works fine when you're estimating at the grocery store or gym. Similarly, "1 oz ≈ 30g" (actual: 28.35g) and "1 lb ≈ 450g" (actual: 453.59g) are close enough for quick calculations.
These shortcuts break down when precision matters or you're working with large quantities where small errors compound.
Technically, mass measures the amount of matter (in kg or lbs), while weight measures gravitational force (in Newtons). Your bathroom scale actually measures force but displays mass units.
This distinction only matters in physics or space exploration. On Earth, we use "weight" to mean mass, and this converter handles those everyday measurements.
For medications, never rely on conversions alone—follow the prescriber's exact instructions in the original units. If a prescription says 500mg, that's 0.5g, but don't do the conversion yourself for dosing.
For precious metals, watch out: gold and silver trade in troy ounces (31.1g), not standard ounces (28.35g). This converter uses standard ounces. When buying gold, always verify which ounce system applies—the difference affects value significantly.
No, not for practical purposes. Temperature affects volume (thermal expansion) but not mass. Your 1 kg of steel weighs the same whether it's frozen or heated.
The only exception: extremely precise scientific measurements in controlled environments, where even air buoyancy matters. For cooking, shipping, or fitness tracking, ignore temperature effects.
Round to the nearest 0.1 lb or 0.1 kg for most carriers. FedEx, UPS, and USPS accept this precision. What matters more: dimensional weight often overrides actual weight for bulky packages.
Pro tip: When in doubt, round up slightly. Declaring 2.3 kg when your package weighs 2.28 kg prevents disputes better than rounding down.
Convert everything to one system first, then scale. Say you're doubling a recipe with 200g flour and 8 oz butter:
Option 1 (work in grams): 200g flour × 2 = 400g, and 8 oz = 227g, so 227g × 2 = 454g butter Option 2 (work in ounces): 200g = 7.05 oz, so 7.05 × 2 = 14.1 oz flour, and 8 oz × 2 = 16 oz butter
Either works. The key: don't mix unit systems mid-calculation.
Whichever you'll stick with consistently. Some people prefer kilograms because 0.5 kg sounds like more progress than 1.1 lbs (even though they're the same). Others like pounds because they're smaller units—seeing 2 lbs down feels more tangible than 0.9 kg.
The measurement system doesn't affect your actual progress, only how you perceive it.
Most scientific formulas require SI units (grams, kilograms). If you're calculating kinetic energy and have weight in pounds, convert to kilograms first. The formula E = ½mv² expects mass in kg and velocity in m/s—mixing in pounds will give you wrong answers.
When working with formulas, convert all inputs to the required units before plugging in values, not after.
For professional applications requiring authoritative conversion factors and measurement standards:
NIST Special Publication 811 - National Institute of Standards and Technology. "Guide for the Use of the International System of Units (SI)." The definitive US reference for unit conversions and SI usage.
BIPM SI Brochure - International Bureau of Weights and Measures. "The International System of Units (SI)," 9th edition. The international authority on metric system definitions.
ISO 80000-4:2019 - International Organization for Standardization. "Quantities and units — Part 4: Mechanics." Standards for mechanical quantities including mass measurements.
NIST Weights and Measures Division - Resources on measurement standards, calibration, and conversion factors used in commerce and science.
These sources define the exact conversion factors used in this calculator (1 lb = 0.45359237 kg exactly) and provide the basis for legal commerce and scientific measurements worldwide.
Need a quick conversion? Enter your weight above and select your unit. You'll see conversions to all three other units instantly—no extra clicks needed. Bookmark this page for the next time you're adapting recipes, comparing international shipping rates, or tracking fitness progress across different measurement systems.
Discover more tools that might be useful for your workflow