Dynamic viscosity converter
One pascal-second is 1000 centipoise. Convert dynamic viscosity between pascal-seconds, poise, centipoise and pound-force seconds per square foot for fluid datasheets, paint and lubricant specs and lab homework. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 1
- Source unit of 'value'
- Pa_s
- To
- cP
- Result
- 1,000
- From label
- pascal-seconds
- To label
- centipoise
- Value pas
- 1
This dynamic viscosity converter turns a numeric viscosity from one common engineering unit into another and returns the converted magnitude with canonical unit labels. Conversion always bridges through pascal-seconds using fixed international SI factors, so the same input always yields the same result with no network calls, no sampling, and no date-dependent shortcuts. Typical checks include one pascal-second to centipoise, one poise to pascal-seconds, and one reyn-scale imperial viscosity to SI.
Where dynamic viscosity conversion fits in fluids, process, and software
Lab datasheets often quote water near one centipoise while process models demand pascal-seconds, and older rheology literature still uses poise, so a single deterministic converter prevents hand-calculator drift when a technician, designer, or student compares fluid properties. Lubricant and paint specs may mix centipoise with SI units; aerospace and older US engineering notes may use pound-force seconds per square foot, also called the reyn scale for dynamic viscosity; teachers assign homework that needs a fast, offline check of poise to pascal-seconds without trusting opaque apps that silently change precision.
Developers call the same contract from scripts to seed deterministic test vectors for product UIs, to normalize user-entered viscosities before sizing demos, or to satisfy programming-challenge statements that demand exact factors rather than a hand-waved estimate. Product tools use the rewrite when a learner or agent types one thousand centipoise and the UI must show pascal-seconds and poise side by side.
Pair it with fluid-mechanics calculators when you already have dynamic viscosity and need Reynolds number or Poiseuille flow next, and with the general multi-category unit converter when the same form must also handle length or mass.
What you can do with it
Lab and process fluid tables
Convert between centipoise, poise, and pascal-seconds when comparing datasheets, rheometer outputs, and SI process models for oils, paints, and aqueous solutions.
Imperial to SI viscosity specs
Normalize pound-force seconds per square foot (reyn-scale) values into Pa·s or cP for deterministic equipment sizing and international documentation.
FAQ
What does the dynamic viscosity converter cost?
It is free in your browser on this page.
What happens if I send an unknown unit?
Unknown or misspelled units are never silently mapped.
Does this convert kinematic viscosity as well?
No. This capability converts dynamic viscosity units only. Kinematic viscosity (m²/s, stokes) requires density and is out of scope here.
Is a centipoise the same as a millipascal-second?
Yes. One centipoise is 0.001 pascal-seconds, exactly one millipascal-second, which is why lab sheets list water near 1 cP while process models expect pascal-seconds.
How many pascal-seconds is one poise?
One poise is 0.1 pascal-seconds, and one centipoise is a hundredth of a poise. Older rheology literature still quotes poise, so this is the conversion you meet most when comparing old and new sources.
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/dynamic-viscosity \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":1,"from":"Pa_s","to":"cP"}'const res = await fetch("https://api.kit.forhosting.com/conv/dynamic-viscosity", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 1,
"from": "Pa_s",
"to": "cP"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/dynamic-viscosity",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 1,
"from": "Pa_s",
"to": "cP"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/dynamic-viscosity", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":1,"from":"Pa_s","to":"cP"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":1,"from":"Pa_s","to":"cP"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/dynamic-viscosity", 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": 1,
"from": "Pa_s",
"to": "cP"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.dynamic_viscosity",
"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_value | 1000000000000000000 |
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
Supported units are pascal-seconds, poise, centipoise, and pound-force seconds per square foot, plus everyday aliases such as Pa·s, P, cP, mPa·s, and lbf·s/ft².
What the dynamic viscosity converter returns and which units it understands
A dynamic viscosity conversion answers a narrow question: given a magnitude in one unit, what is the equivalent magnitude in another unit that people actually use for fluids, lubricants, paints, and process streams. This calculator accepts a numeric value, a source unit, and a target unit, then returns the converted result rounded to a stable precision, the canonical from and to identifiers, human-readable labels, the intermediate value in pascal-seconds, and the SI factors used for the bridge. Everyday spellings such as Pa·s, pascal-second, poise, centipoise, cP, mPa·s, lbf·s/ft², and pound-force seconds per square foot normalize to those ids so forms, query strings, and spreadsheets can reuse the same contract without inventing private enums. Canonical ids are Pa_s for pascal-seconds, P for poise, cP for centipoise, and lbf_s_ft2 for pound-force seconds per square foot. There is no temperature-dependent viscosity model and no density path to kinematic viscosity: the engine either multiplies and divides by fixed factors inside the supported magnitude range or rejects the input with invalid_input. Rejected cases include missing value, from, or to; non-finite numbers; magnitudes above the documented ceiling; and any unit string that is not on the supported list.
How factors are defined and how results stay reproducible
Optional scientific notation on the value string is allowed when it parses as a finite decimal; embedded spaces, hex prefixes, and non-numeric tokens are rejected with a clear message so a bad cell does not become a wrong fluid property. Zero is a valid value and simply yields zero in the target unit. Computation multiplies value by the source factor in pascal-seconds, then divides by the target factor: one poise is exactly one tenth of a pascal-second; one centipoise is exactly one thousandth of a pascal-second and equals one millipascal-second; one pound-force second per square foot equals forty-seven point eight eight zero two five eight nine eight zero three three five eight four pascal-seconds using the international foot and pound-force. The preferred fields are value for the viscosity magnitude, from for the source unit, and to for the target unit, with aliases amount, viscosity, mu, n, and quantity for the value, unit, from_unit, source, and input_unit for from, and target, to_unit, output_unit, and into for to so heterogeneous clients can share one contract. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for value, result, and value_pas, defaulting to ten and capped at fifteen so JSON goldens stay stable. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing unit tables yourself.
Where dynamic viscosity conversion fits in fluids, process, and software
On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split — free interactive exploration and a priced, identical API — matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the mathematical result.
Integration use cases
Homework and CI fixtures
Generate reproducible dynamic viscosity conversions for worksheets, tutoring software, and unit tests that assert fixed SI and engineering factors.
Technical questions
Which dynamic viscosity units are supported?
Pascal-seconds (Pa_s), poise (P), centipoise (cP), and pound-force seconds per square foot (lbf_s_ft2), including common aliases such as Pa·s, mPa·s, centipoise, and lbf·s/ft².
How are conversion factors defined?
All conversions bridge through pascal-seconds using fixed definitions: 1 P = 0.1 Pa·s, 1 cP = 0.001 Pa·s (also 1 mPa·s), and 1 lbf·s/ft² = 47.88025898033584 Pa·s (international foot and pound-force).