ROUND

How ROUND works

ROUND takes a number and a num_digits argument. Positive num_digits means decimal places: ROUND(1234.5678, 2) gives 1234.57. Zero means round to a whole number: ROUND(1234.5678, 0) gives 1235. Negative num_digits rounds to the LEFT of the decimal point: ROUND(12345, -2) gives 12300 (nearest hundred).

Excel uses 'round half away from zero' for the halfway case. 1.5 becomes 2, -1.5 becomes -2. This is the standard arithmetic rounding most people learned in school. Excel does NOT use banker's rounding (round half to even) for ROUND, despite what some forum posts claim - that is a separate concern handled by display-only number formats in certain locales.

ROUND changes the STORED value, not just the display. That distinction matters for financial work: a column rounded to cents with ROUND will sum exactly, but a column merely formatted to 2 decimal places still holds the original precision underneath and can produce penny-off totals. When the math needs to match the paper, ROUND. When it's just for show, use number format.

= ROUND(number, num_digits)

Arguments

ROUND basic: round financial figures to 2 decimal places

The single most common use of ROUND in business: trim noisy decimal output from a calculation down to a clean dollar-and-cents figure. Prices from a tax calculation, exchange-rate conversions, and percentage allocations all produce long decimals that need to land on cents.

Per-row pattern: write =ROUND(A2, 2) in C2 and drag down. Each row rounds its own value independently. The num_digits is a constant (2), so no $-anchoring needed - the drag adjusts only the A2 reference.

=ROUND(A2, 2)

• •A2 -> the source value (different per row after drag-down)
• •2 -> two decimal places - the cents precision for currency
• •1234.5678 to 1234.57 -> the .56 stays, the trailing 78 rounds the 6 up to a 7
• •1500.005 to 1500.01 -> halfway case rounds AWAY from zero (up here, since positive)
• •Length unchanged on clean values -> ROUND is idempotent - already-rounded values pass through

ROUND to whole numbers: dropping decimals entirely

Set num_digits to 0 and ROUND returns the nearest whole number. The halfway case is where ROUND's behavior stands out: 1.5 becomes 2 and -1.5 becomes -2, because Excel rounds AWAY from zero, not toward the nearest even integer.

Common uses: headcount rollups where fractional people make no sense, unit-count forecasts, and any KPI that needs to read as a whole figure on a dashboard.

=ROUND(A2, 0)

• •A2 -> the source value
• •0 -> zero decimal places = round to the nearest integer
• •1.5 to 2 and -1.5 to -2 -> halfway cases push AWAY from zero in both directions
• •2.4 to 2, 7.8 to 8 -> regular rounding for non-halfway cases
• •99.49 to 99, 100.51 to 101 -> strictly under .5 rounds toward zero, strictly over .5 rounds away

ROUND with negative digits: nearest 10, 100, 1000

Pass a negative num_digits and ROUND moves to the LEFT of the decimal point. -1 rounds to the nearest 10, -2 to the nearest 100, -3 to the nearest 1000, and so on. Useful for executive-summary numbers that should read as round figures, or for cohort bucketing.

Same 'half away from zero' rule applies: 12350 with num_digits = -2 rounds to 12400 (the halfway case rounds away from zero). And the cascade still works: 9950 to the nearest 100 becomes 10000.

=ROUND(A2, -2)

• •-1 -> nearest 10 (drops the ones digit)
• •-2 -> nearest 100 (drops tens and ones)
• •-3 -> nearest 1000 (drops the last three digits)
• •12345 to 12300 at -2 -> the 45 in the tens-and-ones is under 50, rounds toward zero
• •67890 to 67900 at -2 -> the 90 in tens-and-ones is over 50, rounds away from zero

ROUND, ROUNDUP, ROUNDDOWN: same shape, different direction

ROUND follows the half-away-from-zero rule. ROUNDUP and ROUNDDOWN ignore the halfway threshold entirely and force direction: ROUNDUP always pushes AWAY from zero (regardless of how close), ROUNDDOWN always pulls TOWARD zero.

All three take the same (number, num_digits) arguments. The choice is purely about the rounding direction. Use ROUNDUP for things like 'how many boxes do I need' (always order extra), and ROUNDDOWN for 'how many full units can I afford' (truncate the partial).

=ROUND(A2, 2)  /  =ROUNDUP(A2, 2)  /  =ROUNDDOWN(A2, 2)

• •ROUND -> half away from zero, otherwise toward the nearer value
• •ROUNDUP -> ALWAYS away from zero, even by 0.001
• •ROUNDDOWN -> ALWAYS toward zero (truncation at the chosen precision)
• •2.341 -> ROUND=2.34 (under half), UP=2.35 (forced up), DOWN=2.34
• •-3.456 -> ROUND=-3.46 (over half, away), UP=-3.46, DOWN=-3.45 (toward zero is less negative)

Real use: invoice totals that don't drift a penny

The classic accounting headache: a column of line items with computed amounts (price * quantity * tax rate), totaled at the bottom, and the total prints as $1,247.99 but the customer's invoice says $1,248.00. The difference comes from rounding only happening at the display layer - the actual numbers in cells still carry long decimals.

The fix is to ROUND each line at the cents level so the stored values match what prints. Then SUM the rounded values for a total that matches the line items exactly. The order matters: SUM(ROUND-ed values) is what you want, not ROUND(SUM-ed unrounded values), because the former locks each line and the latter still hides drift inside the sum.

=ROUND(B2*C2, 2)

• •B2*C2 -> raw line subtotal (price times quantity, before rounding)
• •ROUND(..., 2) -> lock the line at exactly two decimal places
• •SUM(D2:D9) -> totals the rounded lines, so the total always matches what's printed
• •Unrounded SUM column -> column E shows what happens without ROUND - the underlying decimals leak into the total
• •Drift -> $0.02 difference at the bottom from just 8 lines - on 200 lines this becomes embarrassing

Where people go wrong

1. 01
   Confusing ROUND with FLOOR or CEILING

   FLOOR and CEILING (and their .MATH variants) round to a MULTIPLE, not to a number of decimal places. FLOOR(7.3, 0.25) rounds 7.3 down to the nearest 0.25 (= 7.25). ROUND has no concept of a multiple - it only knows decimal places (via num_digits) or positional rounding (via negative num_digits).

   Fix: If you need 'nearest 0.05' or 'nearest 25' or any non-power-of-10 step, use MROUND (nearest), FLOOR.MATH (down), or CEILING.MATH (up). Reserve ROUND for plain decimal-place rounding.
2. 02
   Forgetting num_digits is decimal places, not significant figures

   ROUND(1234.56, 1) = 1234.6, not 1234.56 and not 1200. num_digits counts decimal places, with positive numbers moving right of the decimal point and zero meaning 'whole number'. There's no built-in 'round to N significant figures' in Excel.

   Fix: For sig-figs, use a combined formula: =ROUND(A1, sig_figs - 1 - INT(LOG10(ABS(A1)))). For everyday work, just remember: positive = decimals on the right, negative = positional on the left, zero = integer.
3. 03
   Assuming Excel uses banker's rounding (round half to even)

   Some statistical software (and certain bank systems) round 0.5 to the NEAREST EVEN integer to reduce statistical bias: 0.5 to 0, 1.5 to 2, 2.5 to 2, 3.5 to 4. Excel's ROUND does NOT do this. Halfway cases always go AWAY from zero: 0.5 to 1, 1.5 to 2, 2.5 to 3, 3.5 to 4. People porting code between R and Excel get bitten by this often.

   Fix: If you genuinely need banker's rounding (rare in business; common in scientific work), build it with MROUND and ISEVEN, or use Power Query's Number.Round with the RoundingMode.ToEven argument. Don't expect ROUND alone to do it.
4. 04
   SUM(ROUND(...)) vs ROUND(SUM(...)): the order changes the total

   SUM(ROUND(values, 2)) rounds each line first, then sums - the total matches the printed line items exactly. ROUND(SUM(values), 2) keeps full precision inside the SUM, then rounds the final total once - so the bottom line is correct in isolation, but the printed line items can sum to something a penny or two off from it.

   Fix: For invoices, customer-facing statements, and any breakdown where lines must tie to the total, use SUM(ROUND(...)) - lock each line. For internal aggregate reporting where only the final figure ships, ROUND(SUM(...)) is fine and preserves more precision.

Notes

• Available in every Excel version since 2007 (effectively all modern releases). Identical behavior across Windows, Mac, and Excel for the web.
• num_digits is decimal places: positive = right of decimal point, 0 = whole number, negative = nearest 10, 100, 1000 (one zero per unit).
• ROUND uses 'round half away from zero'. 1.5 to 2, 2.5 to 3, -1.5 to -2, -2.5 to -3. This is NOT banker's rounding (round half to even).
• ROUNDUP always rounds AWAY from zero. ROUNDDOWN always rounds TOWARD zero. Both ignore the halfway threshold and force direction.
• For rounding to a custom multiple (nearest 0.05, nearest 25, nearest quarter-hour), use MROUND - ROUND only handles powers of 10.
• For display-only formatting where the underlying value should stay precise, use Format Cells > Number instead of ROUND. The cell shows fewer decimals but the stored value is untouched.
• Errors propagate. If number is text, a #VALUE! error, or any other error, ROUND returns #VALUE!. Wrap with IFERROR if the input might be dirty.

What to learn next

Now prove it