MongoDB $round Operator

What You’ll Learn

The $round operator rounds numeric values to a chosen number of decimal places inside MongoDB aggregation pipelines. Use it to clean up sensor readings, format prices, or simplify report output without changing stored data.

Definition and Usage

In MongoDB’s aggregation framework, the $round operator rounds a numeric expression to a specified number of decimal places. For example, rounding 21.578 to two places gives 21.58, and rounding 1234 to the nearest hundred (place: -2) gives 1200.

This is especially useful when presenting data, computing financial totals, or normalizing sensor readings where full floating-point precision is unnecessary or confusing for end users.

📝 Syntax

The $round operator accepts an array of two expressions:

{ $round: [ <number>, <place> ] }

Alternatively, you can use the object form:

{
  $round: {
    input: <number expression>,
    place: <place expression>
  }
}

Syntax Rules

• First operand — the number to round (field path, literal, or expression).
• Second operand (place) — how many decimal places to keep.
• place: 2 — round to two decimal places (e.g. 18.942 → 18.94).
• place: 0 — round to the nearest whole number.
• Negative place — round to tens, hundreds, etc. (-1 → nearest 10; -2 → nearest 100).
• Use inside $project, $addFields, or $set.
• If the number is null, the result is null.

Examples Gallery

Round temperature readings, format prices, round averages, and snap sales figures to the nearest hundred with $round.

[
  {
    "_id": 1,
    "location": "New York",
    "temperature": 21.578
  },
  {
    "_id": 2,
    "location": "Los Angeles",
    "temperature": 18.942
  },
  {
    "_id": 3,
    "location": "Chicago",
    "temperature": 16.723
  }
]

db.temperatures.aggregate([
  {
    $project: {
      location: 1,
      temperature: 1,
      roundedTemperature: {
        $round: ["$temperature", 2]
      }
    }
  }
])

// New York:      21.578 → 21.58
// Los Angeles:   18.942 → 18.94
// Chicago:       16.723 → 16.72

db.products.aggregate([
  {
    $project: {
      name: 1,
      price: 1,
      priceRounded: {
        $round: ["$price", 0]
      }
    }
  }
])

// price: 49.99  → priceRounded: 50
// price: 29.4   → priceRounded: 29

db.orders.aggregate([
  {
    $group: {
      _id: "$customerId",
      total: { $sum: "$amount" },
      count: { $sum: 1 }
    }
  },
  {
    $project: {
      avgOrder: {
        $round: [
          { $divide: ["$total", "$count"] },
          2
        ]
      }
    }
  }
])

// total: 100, count: 3 → avgOrder: 33.33

db.stores.aggregate([
  {
    $project: {
      store: 1,
      monthlySales: 1,
      salesRounded: {
        $round: ["$monthlySales", -2]
      }
    }
  }
])

// monthlySales: 1234.56 → salesRounded: 1200
// monthlySales: 9876.50 → salesRounded: 9900

db.invoices.aggregate([
  {
    $project: {
      item: 1,
      subtotal: 1,
      tax: {
        $round: [
          { $multiply: ["$subtotal", 0.0825] },
          2
        ]
      }
    }
  }
])

// subtotal: 19.99 → tax: 1.65 (8.25% rate)

🚀 Use Cases

• Data presentation — show readable numbers in dashboards and API responses.
• Financial calculations — round currency, tax, and totals to required precision.
• Statistical summaries — format averages, rates, and percentages cleanly.
• Reporting buckets — snap large values to tens or hundreds for summary charts.

💡 Best Practices