Newton-meters to foot-pounds converter
Read a metric torque spec against a US tool chart: 1 newton-meter is 0.737562149277 foot-pounds, found by dividing by the exact 1.3558179483314004 rather than reusing a truncated 0.7376. 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
- 0.7375621493 ft·lbf
- Converted
- 0.7375621493
- Foot pounds
- 0.7375621493
- From unit
- N·m
A newton-meters-to-foot-pounds converter turns an SI newton-metre torque or energy reading into the US customary foot-pound force value used in North American tool charts, fastener torque tables, older mechanics handbooks, and many workshop datasheets. Approximate mental shortcuts such as zero point seven three seven six foot-pounds per newton-metre are rejected in favour of the full exact constant, so homework checks and lab exports match standard conversion tables.
Why newton-meters and foot-pounds meet at 1.3558179483314004
The newton-metre is the SI coherent unit of torque and of work: one newton of force through one metre of lever arm, and the common reporting unit for fastener torque, moment of force, and energy in modern science. The foot-pound force remains common in US customary mechanics, North American tool and fastener torque charts, older ballistics and impact notes, and many engineering handbooks that still quote ft·lbf rather than N·m.
The bridge between them is exact for the international definitions: one foot is exactly zero point three zero four eight metres, and the pound-force is defined from standard gravity acting on the international pound-mass, which yields one foot-pound force equal to one point three five five eight one seven nine four eight three three one four zero zero four newton-meters. That makes the conversion a single exact division, foot-pounds equals newton-meters divided by that constant.
Teachers can contrast the exact path with a rough zero-point-seven-three-seven-six rule of thumb so students see the small relative error that accumulates on large torque or impact figures when the truncated constant is reused row after row in spreadsheets.
Practical tips, checks, and related searches
Round-trip sanity checks are easy: convert one point three five five eight one seven nine four eight three three one four zero zero four newton-meters and confirm you receive about one foot-pound after rounding, or convert ten newton-meters and confirm about seven point three seven five six two one four nine two seven eight three foot-pounds. If your source table quotes inch-pounds or kilonewton-metres, scale to newton-meters or interpret the customary result carefully before treating it as ft·lbf from N·m alone.
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 pure conversion so students see that one newton-metre is smaller than one foot-pound and that the same exact constant appears in both SI and US customary worksheets.
This landing targets people searching for newton-meters to foot-pounds, convert N·m to ft-lbf, or an exact newton-metre to foot-pound calculator; it is not a multi-unit torque hub, not a foot-pounds-to-newton-meters primary form, not a joules-only energy landing, and not a kinetic-energy or power calculator. Prefer this capability when the input is already in newton-meters and you only need foot-pounds; if you must convert among many torque units in one call, use a broader torque unit converter instead.
What you can do with it
SI specs to US tool settings
Convert metric torque specs in N·m into ft·lbf for North American tool dials, imperial fastener charts, and bilingual assembly instructions with the same exact factor every row.
FAQ
Is this torque or energy?
Newton-metre and foot-pound can name either a moment of force (torque) or energy (work). This tool applies the exact unit factor between N·m and ft·lbf; interpret the physical quantity from your problem context.
Is the newton-meters to foot-pounds converter free?
The browser tool is free and runs locally.
How many foot-pounds is 1 newton-meter?
1 newton-meter is 0.737562149277 foot-pounds. The converter divides your value by 1.3558179483314004, the exact number of newton-meters in one foot-pound, so the result matches standard conversion tables.
What is wrong with using 0.7376 as the factor?
Nothing for a single quick estimate, but the truncated factor leaves a small relative error. Reused row after row in a spreadsheet of large torque or impact figures, that error adds up; the full constant avoids it.
Where are foot-pounds still used?
Mostly in US customary mechanics: North American tool and fastener torque charts, older mechanics handbooks, workshop datasheets and ballistics or impact notes. A newton-meter figure from a modern spec must be converted before you compare it with them.
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/newton-meters-to-foot-pounds \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"newton_meters":1}'const res = await fetch("https://api.kit.forhosting.com/conv/newton-meters-to-foot-pounds", {
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/newton-meters-to-foot-pounds",
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/newton-meters-to-foot-pounds", 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/newton-meters-to-foot-pounds", 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.newton_meters_to_foot_pounds",
"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.
How to call the API and what comes back
Absolute values must stay within the published limit of one trillion. Send a JSON body with one required finite number field named newton_meters. Aliases nm, n_m, newton_metres, value, Nm, and torque 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 foot_pounds, result, and converted to the same rounded foot-pound magnitude, unit to the token ft·lbf, from_unit to N·m and to_unit to ft·lbf, factor to the rounded reciprocal multiplier, foot_pounds_per_newton_meter to that same exact reciprocal, formula to the string foot_pounds equals newton_meters divided by one point three five five eight one seven nine four eight three three one four zero zero four, 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 and zero marginal unit price. Prefer bare 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 in the payload.
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-metre readings to foot-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 foot-pounds can be normalized for US customary exports, control logic, and API payloads without fragile hand-typed factor tables.
Technical questions
How many foot-pounds are in one newton-meter?
Exactly 1/1.3558179483314004 ft·lbf by international definition: foot_pounds = newton_meters / 1.3558179483314004 (about 0.737562149277 ft·lbf).
Why not use 0.7376 ft·lbf per newton-meter?
0.7376 is a rounded rule of thumb. This converter hard-codes the exact international constant derived from 1 ft·lbf = 1.3558179483314004 N·m used in precise tables and unit-conversion references.
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.