Excel ROUNDUP Function

ROUNDUP rounds a number up, away from zero, to a specified number of decimal places. It returns a new number, not just a display change. The one thing that catches people off guard: ROUNDUP doesn't care what the next digit is. Even a number like 10.001 gets rounded up to 10.01, because ROUNDUP ignores the normal "5 or higher rounds up" rule entirely.

Syntax

=ROUNDUP(number, num_digits)

Parameter	Required	Description
number	Yes	The value you want to round up. Can be a number or a cell reference.
num_digits	Yes	How many decimal places to keep. Use 0 to round to the nearest whole number, a positive number to keep decimal places, or a negative number to round to the left of the decimal (nearest 10, 100, 1000).

Basic Example

You're shipping 133 units and each box holds 12 items. You need to know how many boxes to order, and a fraction of a box isn't useful.

=ROUNDUP(133/12, 0)

// 133/12 = 11.083...
// 0      = round to the nearest whole number, always up

133 divided by 12 is 11.083. A normal ROUND would return 11, since 0.083 rounds down. ROUNDUP ignores that and returns 12, because you can't actually pack 11.083 boxes. You need 12 boxes, full stop.

How ROUNDUP Works

num_digits determines where the rounding happens

A positive num_digits keeps that many places to the right of the decimal. =ROUNDUP(4.132, 2) returns 4.14. =ROUNDUP(4.132, 1) returns 4.2. The higher the number, the more precision you keep before ROUNDUP forces the last kept digit upward.

ROUNDUP always moves away from zero

This is the core behavior, and it's not optional. =ROUNDUP(3.1, 0) returns 4. =ROUNDUP(-3.1, 0) returns -4, not -3. Both moved further from zero, which is what "away from zero" means in practice.

num_digits of 0 rounds to the nearest whole number

=ROUNDUP(19.01, 0) returns 20. This is the setting you'll use most often for anything involving whole units: people, boxes, tickets, seats.

Negative num_digits rounds to the left of the decimal point

=ROUNDUP(1284, -2) returns 1300. =ROUNDUP(1284, -3) returns 2000. Each step left multiplies the rounding increment by 10. This is useful for rough budget estimates where you want to overshoot rather than undershoot.

Common Use Cases

Calculating how many boxes, pallets, or containers you need

Ordering shipping materials for 347 units when each pallet holds 48:

=ROUNDUP(347/48, 0)   // returns 8 pallets

Rounding up prices to the next whole cent or dollar

Adding a processing fee that must land on a clean cent value, never lower than the true cost:

=ROUNDUP(19.463, 2)   // returns 19.47

Rounding up estimated hours in a project timeline

A task is estimated at 6.15 hours, but your scheduling system only books in half-hour blocks. You'd rather overestimate than underbook a client:

=ROUNDUP(6.15*2, 0)/2   // returns 6.5

Multiplying by 2 shifts the decimal so ROUNDUP works in half-hour units, then dividing by 2 converts it back.

Using ROUNDUP inside SUMPRODUCT to round every value in an array

You have quantities in a range and need each one rounded up to the next whole unit before summing, without adding a helper column:

=SUMPRODUCT(ROUNDUP(quantities/case_size, 0))

// quantities  = range of raw unit counts
// case_size   = number of units per case

ROUNDUP runs on every value in the array before SUMPRODUCT adds the results. No helper column needed.

Handling Errors

ROUNDUP can return #VALUE! when either argument isn't something it can treat as a number.

Common causes of #VALUE!:

• number or num_digits points to a cell containing text, like "pending" instead of a numeric value
• One of the referenced cells already contains an error, like #N/A or #REF!
• The cell looks numeric but was entered as text (common with pasted data from other systems)

=IFERROR(ROUNDUP(A2, 2), "Check input")

This formula catches genuine #VALUE! errors, but it won't catch a blank cell. Excel treats a blank A2 as 0, and ROUNDUP happily returns 0, a normal number, not an error, so IFERROR passes it straight through without ever triggering the "Check input" fallback.

Notes & Gotchas

How do I round up in Excel?

Use the ROUNDUP function: =ROUNDUP(number, num_digits). It forces the result upward regardless of what the digit being dropped actually is. This differs from Excel's default number formatting, which only changes how a value displays, not the value itself.

What is the difference between ROUND and ROUNDUP in Excel?

ROUND follows the standard rule: it rounds up when the dropped digit is 5 or greater, and down when it's less than 5. ROUNDUP skips that rule entirely and always rounds up, no matter what the dropped digit is. =ROUND(4.21, 1) returns 4.2, but =ROUNDUP(4.21, 1) returns 4.3.

How do you round up to a specific number of decimal places in Excel?

Set num_digits to the number of decimal places you want to keep. =ROUNDUP(3.14159, 2) returns 3.15. =ROUNDUP(3.14159, 0) returns 4. The formula structure doesn't change, only the second argument.

What is the syntax of the ROUNDUP function in Excel?

The syntax is =ROUNDUP(number, num_digits). Both arguments are required. There's no optional third argument, unlike some other Excel math functions.

How does ROUNDUP handle negative numbers in Excel?

ROUNDUP moves negative numbers further from zero, which means they get more negative, not less. =ROUNDUP(-2.3, 0) returns -3. =ROUNDUP(-2.31, 1) returns -2.4, since there's a digit past the first decimal place pushing the result away from zero. If the number already stops exactly at the requested precision, like =ROUNDUP(-2.3, 1), there's nothing left to round and it returns -2.3 unchanged. If you expected -2, this is the one to watch for.

Does ROUNDUP fix floating-point rounding errors like 0.1 + 0.2?

Not usually, and 0.1 + 0.2 is actually a poor example of the problem in Excel specifically. =0.1+0.2=0.3 returns TRUE in Excel, because Excel stores and displays values to 15 significant digits, and that precision ceiling rounds away the tiny binary representation error in this particular case. The underlying imprecision is real, it's just invisible in a single simple calculation like this one. It tends to surface after many repeated operations, like adding 0.1 across thousands of rows, where the small errors accumulate into something visible, such as 0.999999999999996 instead of 1. Wrapping a running total in ROUND or ROUNDUP at a sensible number of digits is still a reasonable habit for cumulative calculations, since it forces Excel to store a clean value and avoids downstream comparison mismatches. Reach for it because of accumulated drift across many operations, not because a single 0.1+0.2 will visibly break.

Does ROUNDUP use banker's rounding?

No. Banker's rounding, also called round-half-to-even, decides ties (like 2.5) by rounding to whichever neighbor is even. ROUNDUP doesn't make that decision at all. It rounds every value up regardless of whether the dropped portion is a tie, a fraction just above zero, or anything else. If you need round-half-to-even behavior, ROUNDUP is the wrong function; standard ROUND is closer, though Excel's ROUND still isn't true banker's rounding.

What happens if the number already has fewer decimal places than num_digits?

Nothing changes. =ROUNDUP(4.5, 3) returns 4.5, since there's nothing beyond the third decimal place to round up. ROUNDUP only acts when there's a digit past the specified precision to push upward.

Related Functions

Function	Use this when...
ROUND	You want standard rounding rules, where 5 or higher rounds up and anything less rounds down.