Engineering notation
47,000 becomes 47×10^3 and 0.000025 becomes 25×10^-6: the exponent always moves in steps of three, so it tells you the prefix, kilo or micro, at a glance. Enter a number and read the coefficient and the exponent separately. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 47,000
- Coefficient
- 47
- Exponent
- 3
- Notation
- 47×10^3
Engineering notation is the way engineers, electricians and physicists actually write numbers: not 4.7×10^4, but 47×10^3, because the exponent always moves in steps of three that line up with the SI prefixes kilo, mega, giga and their small counterparts milli, micro and nano. Send a value, get the two components back, and render or compare magnitudes without reimplementing the logarithm-and-rounding logic yourself.
What engineering notation is and why the exponent jumps by threes
Scientific notation normalizes every number to a mantissa between 1 and 10, which is mathematically tidy but awkward in practice: nobody says 4.7×10^4 ohms when they mean 47 kilo-ohms. Engineering notation relaxes the coefficient to the range [1, 1000) so that the exponent is always a multiple of three, and those steps of three are exactly the steps of the SI prefix ladder: 10^3 is kilo, 10^6 is mega, 10^9 is giga, and downward 10^-3 is milli, 10^-6 is micro, 10^-9 is nano.
That alignment means the exponent alone tells you which prefix a measurement carries, and the coefficient is the number you would read off a dial or a datasheet. A frequency of 2,400,000,000 hertz becomes 2.4×10^9 — giga — and a current of 0.000025 amperes becomes 25×10^-6 — twenty-five microamps.
How the coefficient and exponent are computed
The algorithm is pure arithmetic and fully deterministic. It takes the base-10 logarithm of the absolute value, floors it to the nearest multiple of three, and divides the value by ten raised to that exponent to obtain the coefficient. Because floating-point logarithms can land a hair off at exact powers of ten, the result is re-checked with explicit guard loops: if the coefficient reaches 1000 the exponent is raised by three, and if it falls below 1 the exponent is lowered by three.
The coefficient is then rounded to the requested number of significant digits — six by default, configurable from 1 to 15 with the precision field — and if that rounding pushes 999.96 up to 1000, the pair is rebalanced one final time, so the invariant coefficient in [1, 1000) and exponent divisible by three always holds. Zero is a special case and returns coefficient 0 with exponent 0. Numbers with absolute value above 1e300 and non-finite inputs such as Infinity or NaN are rejected before any arithmetic happens.
What you can do with it
Format component values in an electronics tool
Turn 0.0000000047 farads into 4.7×10^-9 so the UI can show 4.7 nF without hard-coding prefix tables.
Normalize telemetry before display
Group sensor readings by exponent to decide whether a dashboard should show kilohertz or megahertz.
Compare magnitudes in a test harness
Assert on the exponent first — it is always a multiple of three — before comparing coefficients within tolerance.
FAQ
Can I control the rounding of the coefficient?
Yes. The precision field sets the number of significant digits, from 1 to 15, and defaults to 6.
Is the input stored or logged?
No. The number is processed in memory and discarded; only the converted result is returned.
Is there a size limit?
The absolute value must be at most 1e300.
What is the difference between engineering and scientific notation?
Scientific notation keeps the mantissa between 1 and 10, as in 4.7×10^4. Engineering notation lets the coefficient run from 1 to under 1000 with an exponent divisible by three, as in 47×10^3, which reads directly as 47 kilo-ohms.
Which SI prefix matches each exponent?
An exponent of 3 is kilo, 6 is mega and 9 is giga; going down, -3 is milli, -6 is micro and -9 is nano. The exponent alone tells you which prefix the number should carry.
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/math/engineering-notation \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":47000}'const res = await fetch("https://api.kit.forhosting.com/math/engineering-notation", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 47000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/engineering-notation",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 47000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/engineering-notation", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":47000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":47000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/engineering-notation", 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": 47000
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.engineering_notation",
"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 | 1e+300 |
max_precision | 15 |
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
This API takes one finite number and returns its engineering form as a coefficient in the range [1, 1000) together with an integer exponent divisible by three, plus a ready-to-display notation string. The same deterministic code runs free in your browser on this page and through the paid API for automated pipelines.
What engineering notation is and why the exponent jumps by threes
This endpoint performs that conversion for a single value and returns both components separately, so you can format them, sort by exponent to group magnitudes, or map the exponent straight to a prefix. Input that is not a finite number is rejected with an invalid_input error and is never billed.
Where it fits and what it costs
Typical callers are electronics and RF tools that present component values, telemetry pipelines that normalize sensor readings before display, scientific notebooks that want consistent units, and test harnesses that compare computed magnitudes against expected ones by exponent first. Because the output is a plain JSON object with coefficient, exponent and a preformatted notation string, it drops directly into a UI label, a log line or a database column. The capability runs as a pure parse engine on our global edge: nothing is stored, the input number is processed and discarded, and the same module that answers the API runs free in your browser on this page, so you only pay when you automate the call. The price is $0.002 per converted item, with no per-size surcharge because every request converts exactly one number regardless of its magnitude. Validation errors — a missing value, a non-numeric string, Infinity, NaN, or a magnitude above the documented limit — return a structured invalid_input error and are not charged, which makes it safe to wire the endpoint straight into a user-facing form without pre-validation on your side.
Technical questions
What does it cost?
$0.002 per request. It is also free to run in your browser on this page.
What exactly is returned?
A JSON object with the coefficient in [1, 1000), the integer exponent (always a multiple of three) and a notation string such as 47×10^3.
What happens with zero, Infinity or NaN?
Zero returns coefficient 0 and exponent 0. Infinity and NaN are not finite and are rejected with an invalid_input error.