Damping coefficient converter
100 N·s/m is about 6.852176585679 lbf·s/ft: convert viscous damping coefficients between SI, US customary and cgs units, for shock-absorber datasheets, vibration isolators, suspension setups and modal-analysis reports. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 100
- From
- N.s/m
- To
- lbf.s/ft
- Result
- 6.8521765857
- From label
- newton-second per meter
- To label
- pound-force second per foot
- Nsm
- 100
A damping coefficient converter turns a viscous damping constant written in one force-per-velocity unit into another without re-deriving SI factors or hunting handbook tables.
Supported units and how the conversion is computed
The converter accepts viscous damping-coefficient families under stable canonical codes: N.s/m for the SI newton-second per meter, kg/s for the mass-per-time form that is exactly equal to N·s/m, N.s/mm and kN.s/m for machine-design and structural scales, lbf.s/ft (also accepted as lb.s/ft or pound seconds per foot) and lbf.s/in (lb.s/in or pound seconds per inch) for customary US and aerospace datasheets, kgf.s/m when technical kilogram-force is explicit, and dyn.s/cm for the cgs dyne-second per centimeter.
Factors follow SI and conventional engineering standards: one N·s/mm is one thousand N·s/m, one kN·s/m is one thousand N·s/m, one kilogram per second equals one N·s/m exactly because a newton is one kilogram-meter per second squared, one pound-force is zero point four five three five nine two three seven kilograms times standard gravity nine point eight zero six six five meters per second squared divided by zero point three zero four eight meters for the foot or zero point zero two five four meters for the inch, one kilogram-force second per meter is nine point eight zero six six five N·s/m, and one dyne-second per centimeter is zero point zero zero one N·s/m.
Because the intermediate is always N·s/m, 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. Pure force units, pure velocity units, dynamic viscosity, and spring stiffness are intentionally out of scope so analysts get predictable damping-coefficient-only results under one clear convention.
Where damping coefficients turn up
Use the free in-browser damping coefficient converter when you need a quick N·s/m-to-lbf·s/ft, lbf·s/in-to-N·s/m, or kg/s-to-dyn·s/cm check while reading a shock-absorber datasheet, vibration-isolator catalog, vehicle suspension setup sheet, modal-analysis report, or homework problem. 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 engineers, technicians, and students expect on paper.
What you can do with it
Shock absorbers and vehicle suspension
Convert N·s/m damper rates from European catalogs into lbf·s/in or lbf·s/ft for US setup sheets without hand-written factors or mixed-unit spreadsheets.
Vibration isolation and modal analysis
Normalize N·s/m, kg/s, and kN·s/m viscous damping values when FEA, test reports, and vendor PDFs disagree on force-per-velocity notation.
FAQ
Which damping coefficient units does this converter support?
N.s/m (Ns/m, kg/s), N.s/mm, kN.s/m, lbf.s/ft (lb.s/ft), lbf.s/in (lb.s/in), kgf.s/m, and dyn.s/cm.
How many N·s/m is one lbf·s/ft (pound-force second per foot)?
About 14.593902937206 N·s/m under the ISO definition that multiplies the avoirdupois pound mass by standard gravity 9.80665 m/s² and divides by 0.3048 m.
Is kg/s the same as N·s/m?
Yes. Because one newton equals one kilogram-meter per second squared, the viscous damping unit N·s/m is exactly equal to kg/s. Both codes use the factor 1 in this converter.
What happens if I send an unknown unit?
The message names the field and lists supported units. Validation failures are not charged.
Is the damping coefficient converter free?
The browser tool runs free on your device.
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/damping-coefficient \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":100,"from":"N.s/m","to":"lbf.s/ft"}'const res = await fetch("https://api.kit.forhosting.com/conv/damping-coefficient", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 100,
"from": "N.s/m",
"to": "lbf.s/ft"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/damping-coefficient",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 100,
"from": "N.s/m",
"to": "lbf.s/ft"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/damping-coefficient", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":100,"from":"N.s/m","to":"lbf.s/ft"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":100,"from":"N.s/m","to":"lbf.s/ft"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/damping-coefficient", 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": 100,
"from": "N.s/m",
"to": "lbf.s/ft"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.damping_coefficient",
"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 newton seconds per meter, pound-force second per foot, kilograms per second, and dyne second per centimeter 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 newton-seconds-per-meter factor for the source, then divides by the newton-seconds-per-meter 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 damping components in specialized analysis 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, c, and damping 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 nsm quantity in newton-seconds per meter, the dimensionless factor from source to target, a short formula line suitable for UI display, the method tag damping_coefficient_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. Micro-scale and mega-scale magnitudes share the same code path, so extreme pairs remain well-defined as long as IEEE double precision can represent the intermediate N·s/m product.
Browser use, API pricing, and everyday workflows
Switch to the prepaid API when a CAE plugin, damper-selection tool, robotics compliance pipeline, aerospace loads worksheet, or physics homework checker must convert viscous damping coefficients 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 a spring-stiffness converter when you also need force-per-length rates for a mass-spring-damper model, or call it alone when search traffic is specifically for damping coefficient unit conversion—newton seconds per meter, pound seconds per foot, and pound seconds per inch—rather than a general force or viscosity switchboard.
Integration use cases
Homework and lab automation
Convert lbf·s/ft and N·s/m for class problems and automated lab scripts with a prepaid, deterministic API and clear invalid_input on unknown units.