Significant figures rounder
1234.567 to three significant figures is 1230, also shown as 1.23e+3. Keep only the digits your measurement supports, with exact halves rounded away from zero, for lab reports and chemistry or physics 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,234.567
- Figures
- 3
- Rounded
- 1,230
- Scientific
- 1.23e+3
This significant figures rounder takes a finite number and a figure count, then returns the value rounded to that many significant figures using a fixed half-away-from-zero rule. Significant figures matter whenever a measurement or intermediate result should not pretend to more precision than the data support: lab reports, chemistry stoichiometry, physics estimates, and spreadsheet pipelines all need a stable way to keep three or four meaningful digits without inventing trailing noise. Small checks you can verify by hand include one thousand two hundred thirty-four point five six seven to three significant figures becoming one thousand two hundred thirty, zero point zero zero one two three four to two figures becoming zero point zero zero one two, and one point two five to two figures becoming one point three. The engine is fully deterministic: it uses only finite base-ten logarithms and scaling, no network calls, no random sampling, and no date-dependent shortcuts.
What significant figures mean and what you get back
Significant figures count the digits that carry meaning in a measured or computed quantity, starting from the first non-zero digit and including zeros that sit between non-zero digits or that were retained by an explicit rounding choice. Leading zeros after a decimal point do not count as significant, which is why zero point zero zero one two three four has four significant figures in the digits one two three four, not six.
Rounding to N significant figures therefore keeps the leading N meaningful digits and replaces the rest according to a fixed half-away-from-zero rule, rather than simply chopping a fixed number of decimal places. Decimal-place rounding and significant-figure rounding answer different questions: two decimal places on one thousand two hundred thirty-four point five six seven still leaves a long integer part, while three significant figures compresses the whole magnitude to one thousand two hundred thirty.
Where significant-figure rounding fits in study, labs, and software
Students meet significant figures when a chemistry lab demands three-digit answers that match the least precise measurement, when a physics problem set forbids calculator dumps of twelve decimal places, or when a statistics worksheet asks for a rounded estimate that still reflects order of magnitude. Teachers can pre-generate answer keys for modest magnitudes without trusting opaque calculator modes that silently switch between decimal places and sig figs.
Data and education products use the rewrite when a learner types a raw float and the UI must show a scientifically honest rounded form next to the full-precision value. Pair it with engineering-notation and other numeric formatters when you are building a small lab of free, deterministic number helpers.
What you can do with it
Lab reports and homework
Round measured or calculated values to a required sig-fig count for chemistry, physics, and engineering write-ups.
Dashboards and sensor display
Normalize wide-range floats to a fixed significant-digit budget before labels, logs, and charts.
FAQ
What does the significant figures rounder cost?
It is free in your browser on this page.
What happens if the figure count is below one?
Significant-figure counts must be integers from 1 to 15; zero and negative counts are not allowed.
How does half-away-from-zero rounding work here?
After scaling so N digits sit around the units place, ties at .5 round away from zero (1.25 to 2 figures becomes 1.3; −1.25 becomes −1.3).
Are leading zeros after the decimal significant?
No. In 0.001234 the significant digits start at 1, so two significant figures yield 0.0012.
Is this the same as rounding to fixed decimal places?
No. Decimal-place rounding keeps a fixed width after the point; significant figures keep N meaningful digits across the whole magnitude.
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/fmt/sig-figs \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":1234.567,"figures":3}'const res = await fetch("https://api.kit.forhosting.com/fmt/sig-figs", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 1234.567,
"figures": 3
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fmt/sig-figs",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 1234.567,
"figures": 3
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fmt/sig-figs", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":1234.567,"figures":3}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":1234.567,"figures":3}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fmt/sig-figs", 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": 1234.567,
"figures": 3
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fmt.sig_figs",
"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_figures | 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
What significant figures mean and what the response contains
This calculator returns the original value as parsed, the requested figure count, the rounded number as a JSON-safe float, a scientific-style display string produced with the same figure count, a method tag significant_figures, and a short formula reminder of the log-scale-round path. There is no approximate CAS path and no sampling: the engine either builds a finite result inside the supported magnitude range or rejects the input with invalid_input. Rejected cases include missing value or figures, non-numeric text, Infinity, NaN, magnitudes above the documented ceiling, and any figure count below one.
How value and figures are read and how rounding stays reproducible
Optional leading plus signs and scientific notation on numeric strings are allowed when they parse as finite decimals; embedded spaces, currency symbols, hex prefixes, and non-numeric tokens are rejected with a clear message so a bad cell does not become a wrong rounded result. Zero is valid and simply yields a rounded zero with a plain zero scientific string. Computation locates the order of magnitude with floor of log base ten of the absolute value, builds a scale factor ten to the power of N minus one minus that order, multiplies, rounds half away from zero, divides back, and re-normalizes once if rounding carries across a power of ten, such as nine hundred ninety-nine to two figures becoming one thousand. The preferred fields are value for the number to round and figures for the integer count of significant digits to keep, but aliases n, number, x, amount, input, and text are accepted for the value, and sig_figs, sigfigs, n_figures, digits, and sf for the figure count, so spreadsheets, query strings, and typed forms can reuse the same contract. The figures field is required and must be an integer from one through fifteen inclusive: a count of zero or any negative integer fails with invalid_input because a figure count below one is not a meaningful significant-figure request, and counts above fifteen are rejected to stay inside reliable floating-point presentation. Negative zero is collapsed to plain zero for clean JSON comparisons. 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 significant-figure rules yourself.
Where significant-figure rounding fits in study, labs, 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 rounded result.
Integration use cases
Deterministic test fixtures
Generate reproducible rounded numbers and scientific strings for unit tests, docs, and CI assertions.