Nm to in-lbs converter
Set an inch-pound torque wrench from a metric spec: 1 newton-meter is 8.8507 inch-pounds, so a 10 N·m bolt becomes 88.507 in-lb with one multiplication. Handy for bicycle, electronics and small-fastener work. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Newton meters
- 1
- Result
- 8.8507 in·lbf
- Converted
- 8.8507
- Inch pounds
- 8.8507
- In lbs
- 8.8507
A newton-meters-to-inch-pounds converter turns an SI torque reading in newton-metres into the US customary inch-pound force value used on fastener charts, torque-wrench scales, and North American assembly specs. One newton-meter equals eight point eight five zero seven inch-pounds on this path, so a ten newton-meter spec becomes eighty-eight point five zero seven inch-pounds after the same multiply.
Why newton-meters and inch-pounds meet at 8.8507
Inch-pounds remain common on North American torque-wrench scales, small-fastener charts, bicycle and electronics assembly notes, and many US customary tool manuals that still quote in-lb rather than N·m. The published bridge used on this landing is a single multiplication: inch-pounds equals newton-meters times eight point eight five zero seven. Zero newton-meters maps cleanly to zero inch-pounds.
Negative values are accepted as signed moments when a signed delta is meaningful to the caller. Teachers can contrast this published four-decimal factor with a longer laboratory constant so students see why a dedicated nm-to-in-lbs page and a high-precision table can differ slightly on large torque figures. Because the map is linear, doubling the input doubles the output, and converting one newton-meter is the fastest sanity check you can run before trusting a batch of rows.
Practical tips, checks, and related searches
Round-trip sanity checks are easy: convert one newton-meter and confirm you receive eight point eight five zero seven inch-pounds after rounding, or convert ten newton-meters and confirm eighty-eight point five zero seven inch-pounds. If your source table quotes foot-pounds instead of inch-pounds, remember that one foot-pound is twelve inch-pounds, so this landing is not a substitute for a foot-pound converter. Stay inside the absolute range so the product cannot overflow into a non-finite result the solver must reject.
When teaching unit analysis, pair a torque example such as one newton at a one-metre lever arm with the published multiply so students see that one newton-meter is smaller than nine inch-pounds and that the same factor appears in both SI and US customary worksheets. This landing targets people searching for nm to in-lbs, convert newton meters to inch pounds, or a newton-meter to inch-pound torque calculator; it is not a multi-unit torque hub, not an inch-pounds-to-newton-meters primary form, and not a kinetic-energy or power calculator.
Prefer this capability when the input is already in newton-meters and you only need inch-pounds; if you must convert among many torque units in one call, use a broader torque unit converter instead. Keep requests small, pin the rounded inch-pounds in tests, and you get reproducible torque conversions for homework, LMS plugins, and edge workers without standing up a general units library of your own.
What you can do with it
Fastener and wrench torque charts
Convert SI torque specs in N·m into in·lbf for inch-pound wrench settings, small-fastener charts, and North American assembly instructions with the same factor every row.
FAQ
Is this torque or energy?
Newton-metre and inch-pound can name either a moment of force (torque) or energy (work). This tool applies the unit factor between N·m and in·lbf; interpret the physical quantity from your problem context.
Is the nm to in-lbs converter free?
The browser tool is free and runs locally.
How many inch-pounds is 10 N·m?
10 newton-meters are 88.507 inch-pounds. The converter multiplies by 8.8507, and because the relation is linear, doubling the torque doubles the result, which makes 1 N·m an easy first check.
Why can my result differ slightly from a high-precision table?
This tool uses the published four-decimal factor 8.8507. A longer laboratory constant can give a slightly different figure on large torques, so keep one source for a whole batch of values.
Can I use it when my chart is in foot-pounds?
No. One foot-pound is twelve inch-pounds, so the same torque reads twelve times higher in inch-pounds. Use a foot-pound converter when your chart quotes foot-pounds.
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/nm-to-in-lbs \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"newton_meters":1}'const res = await fetch("https://api.kit.forhosting.com/conv/nm-to-in-lbs", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"newton_meters": 1
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/nm-to-in-lbs",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"newton_meters": 1
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/nm-to-in-lbs", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"newton_meters":1}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"newton_meters":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/nm-to-in-lbs", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"newton_meters": 1
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.nm_to_in_lbs",
"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.
Limits
max_abs | 1000000000000 |
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
Invalid or missing input fails with a clear invalid_input error instead of inventing a number.
Why newton-meters and inch-pounds meet at 8.8507
The newton-metre is the SI coherent unit of torque: one newton of force acting through one metre of lever arm, and the reporting unit on most international fastener datasheets, motor nameplates, and mechanics textbooks.
How to call the API and what comes back
Absolute values must stay within the published limit of one trillion. Do not send mixed unit labels inside the number field; this capability always treats the input as newton-meters and always returns inch-pounds. Send a JSON body with one required finite number field named newton_meters. Aliases nm, n_m, value, torque, newton_metre, and newton_metres are accepted so SDK clients and form posts can use the name that fits the product. On success the response echoes rounded newton_meters, sets inch_pounds, in_lbs, in_lbf, result, and converted to the same rounded inch-pound magnitude, unit to the token in·lbf, from_unit to N·m and to_unit to in·lbf, factor to eight point eight five zero seven, inch_pounds_per_newton_meter to that same constant, formula to the string inch_pounds equals newton_meters times eight point eight five zero seven, message to a short English summary, and steps to an ordered array of substitution lines. Failed validation—missing fields, non-finite numbers, bare plus or minus signs, non-numeric strings, values outside absolute limits, or a non-finite converted result—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item. Prefer bare JSON numbers when you control the client; string numbers are accepted only when they match a strict finite numeric pattern without unit suffixes or thousand separators.
Practical tips, checks, and related searches
Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when learners deliberately omit newton_meters or pass text.
Integration use cases
Homework and exam checks
Students convert classroom newton-meter readings to inch-pounds and compare hand work against deterministic steps before submitting worksheets or coding kata fixtures.
Engineering unit alignment
Process notes that mix newton-meters and inch-pounds can be normalized for US customary exports, control logic, and API payloads without fragile hand-typed factor tables.
Technical questions
How many inch-pounds are in one newton-meter?
This converter uses the published factor 8.8507 in·lbf per N·m: inch_pounds = newton_meters × 8.8507.
Which input field should I send?
Send newton_meters as a finite number. Aliases nm, n_m, value, torque, newton_metre, and newton_metres are accepted. The value is always treated as N·m.
What happens on invalid input?
Missing fields, non-finite values, non-numeric strings, or values outside the absolute limits return invalid_input and are never charged.