Rounding calculator
3.14159 rounded to 2 decimal places is 3.14, and 2.5 rounded to a whole number is 3. Choose how many decimals to keep, from 0 to 15, and get the school half-up result, negatives included. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 3.14159
- Places
- 2
- Rounded
- 3.14
Half-up rounding is the rule most people learned in school: look at the first discarded digit, and if it is five or greater, increase the last kept digit by one; otherwise leave it. This rounding calculator applies that rule to a finite number and a chosen count of decimal places, then returns the rounded value together with the cleaned inputs and a method label so clients can document the contract. Ties such as two point five to zero places become three, and negative two point five becomes negative three, because half-up moves away from zero when the discarded part is exactly one half.
How half-up rounding to decimal places works
Start with a finite real number and a non-negative integer that says how many digits should remain after the decimal point. Places zero means the nearest integer under the half-up rule; places two is the classic currency-style round; higher places keep more fractional detail for scientific display, up to a published maximum of fifteen. Internally the solver writes the input as a plain decimal digit string, including a faithful expansion of scientific notation, then inspects the first discarded digit.
If that digit is four or less, the kept prefix is left unchanged. If that digit is five or greater, one unit is added to the last kept place, with carry propagating through nines so that nine point nine nine five to two places becomes ten. Half-up treats an exact half as a signal to increase magnitude: two point five to zero places becomes three, and negative two point five becomes negative three.
That is the school rule, the Java RoundingMode.HALF_UP rule, and the Python decimal ROUND_HALF_UP rule. It is not banker's rounding, which would send two point five to two and keep even digits on a tie. It is also not JavaScript Math.round on a scaled float, which for negatives at a half steps toward positive infinity and which can lose a half to binary residue such as one point zero zero five times one hundred.
Working on decimal digits avoids those two surprises.
Where half-up decimal rounding shows up in real work
Finance and commerce pipelines round unit prices, tax lines, and invoice totals to two decimal places before display and before settlement so user-interface labels and ledger rows share one number. Classroom and exam settings need a single trusted oracle for half-cases and negative values so answer keys and student calculators do not diverge on two point five versus banker's round. Data engineers normalize sensor readings and CSV imports to a fixed places count before hashing or comparing rows, cutting flaky equality checks caused by long binary tails.
Scientists and report writers snap constants such as pi or measured means to a published number of decimal places so tables stay readable without claiming false precision. Keep the number and the places count inside the published limits, pin the rounded field in tests, and you get a reproducible half-up result for homework, spreadsheets, and edge workers without standing up a decimal-arithmetic library of your own.
What you can do with it
Currency and invoice line totals
Round prices and tax lines to two decimal places with a documented half-up rule before display or settlement so the interface and the ledger share one number.
Homework and exam keys
Check half-cases and negative values against a deterministic oracle so two point five and negative two point five never disagree with the school half-up rule.
Bulk sensor and CSV cleanup
Normalize imported columns to a fixed places count before hashing or comparing rows, so long binary tails do not break equality checks.
FAQ
What rounding rule does this calculator use?
Half-up, also called half away from zero. When the first discarded digit is 5 or greater, the last kept digit increases in magnitude. So 2.5 with places 0 becomes 3, and −2.5 becomes −3.
What happens if decimal places is not a non-negative integer?
Missing places, a negative count, a fraction such as 1.5, or a value above 15 is rejected and is not billed.
Is this the same as JavaScript Math.round?
No. Math.round on a scaled float uses a different half-case for negatives and can lose a half to binary residue. This solver works on decimal digits and always uses half-up.
What does the rounding calculator cost?
The browser tool is free and runs locally.
How many decimal places can I keep?
Any whole number from 0 to 15. Zero gives the nearest integer, so 2.5 becomes 3; two places suit money-style figures, and higher counts keep more detail for scientific values.
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/rounding \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":3.14159,"places":2}'const res = await fetch("https://api.kit.forhosting.com/math/rounding", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 3.14159,
"places": 2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/rounding",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 3.14159,
"places": 2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/rounding", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":3.14159,"places":2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":3.14159,"places":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/rounding", 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": 3.14159,
"places": 2
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.rounding",
"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 | 1000000000000000 |
max_places | 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
Decimal places must be a non-negative integer; a missing, negative, or fractional places value is rejected with invalid_input and is not billed. A successful API call costs $0.002.
How half-up rounding to decimal places works
There is no random seed, no wall-clock timestamp, and no network call; identical inputs always produce identical JSON. Missing value, non-numeric text, NaN, Infinity, and a places field that is not a non-negative integer fail with invalid_input and are not charged.
What you send and what you get back
Typical checks include three point one four one five nine with places two yielding three point one four, two point five with places zero yielding three, negative two point five with places zero yielding negative three, and one point two two five with places two yielding one point two three. Wire the free browser form for homework and quick previews, then call the identical contract from scripts when you need bulk normalization before storage or display. Send a JSON body with two required fields. value is the finite number to round; aliases n, number, input, x, num, and amount are accepted when wiring forms or scripts. places is the count of decimal digits to keep; it must be an integer from zero through fifteen, and aliases decimals, precision, dp, and decimal_places map to the same field. Each field may arrive as a JSON number or as a numeric string in ordinary decimal or scientific notation. A missing field, an empty string, a fractional places value such as one point five, a negative places value, or a places count above fifteen fails with invalid_input and names the offending field. Absolute magnitudes above one quadrillion are rejected so the decimal expansion stays inside safe double-precision range on the Worker and in the browser. On success the body echoes the cleaned value and the integer places, reports rounded as the half-up result as a JSON number, and sets method to half_up so clients can document the rule without reading source. Pricing for successful API calls is the published base of $0.002 per item; validation failures do not consume prepaid balance. Rejected requests always use the invalid_input code so clients can branch without parsing free-form five-hundred errors.
Where half-up decimal rounding shows up in real work
Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance. This landing targets people searching for rounding, round to decimal places, or half-up rounding of a single number. It does not convert a decimal into a percent, does not reduce a value to significant figures, and does not snap a figure to the nearest ten, hundred, or thousand: those are different search intents and different tools.
Technical questions
What must I send?
A finite number in value (aliases n, number, input, x, num, amount) and a non-negative integer in places from 0 to 15 (aliases decimals, precision, dp, decimal_places).