The $divide operator divides one number by another in MongoDB aggregation pipelines. It is a core arithmetic operator for computing averages, ratios, rates, and normalized values directly inside your data.
Divide dividend by divisor.
Two operands in an array.
Compute new ratio fields.
Divide document fields.
Metrics, ratios, scaling.
Guard against divide-by-zero.
In MongoDB’s aggregation framework, the $divide operator performs division on two numeric expressions. For example, { $divide: [ 100, 4 ] } returns 25, and { $divide: [ "$revenue", "$quantity" ] } computes revenue per unit for each document. This is one of the most commonly used arithmetic operators for business metrics and data normalization.
Think of $divide as MongoDB’s pipeline version of the / operator. The first value in the array is the dividend (top number), and the second is the divisor (bottom number). Use it inside expression stages like $project or $addFields.
The $divide operator takes an array of two numeric expressions:
{ $divide: [ <dividend>, <divisor> ] }$divide — returns the quotient of the dividend divided by the divisor.<dividend> — the number being divided (first array element).<divisor> — the number you divide by (second array element).$project, $addFields, or $set.null, the result is null.0, MongoDB throws an error — guard with $cond when needed.If the divisor evaluates to zero, $divide throws an error and stops the pipeline. Check for zero before dividing:
| Question | Answer |
|---|---|
| Operator type | Aggregation expression operator (arithmetic) |
| Syntax | { $divide: [ <dividend>, <divisor> ] } |
| Operands | Two numeric expressions in an array |
| Output | Quotient (number, or null) |
| Common stages | $project, $addFields, $set |
{
$divide: [ 100, 4 ]
}Returns 25
{
$divide: [
"$revenue",
"$quantity"
]
}Revenue per unit
{
$divide: [
"$part",
"$total"
]
}Ratio of part to total
{
$divide: [ null, 5 ]
}Returns null
Walk through sample sales data, an aggregation pipeline, and the computed per-unit revenue step by step.
Start with a simple sales collection and compute average revenue per unit sold with $project.
Suppose you have a sales collection with revenue and quantity fields:
[
{ "_id": ObjectId("609c26812e9274a86871bc6a"), "revenue": 5000, "quantity": 10 },
{ "_id": ObjectId("609c26812e9274a86871bc6b"), "revenue": 7500, "quantity": 15 },
{ "_id": ObjectId("609c26812e9274a86871bc6c"), "revenue": 10000, "quantity": 20 }
]Use $project to add a new field called avgRevenuePerUnit:
db.sales.aggregate([
{
$project: {
avgRevenuePerUnit: {
$divide: [ "$revenue", "$quantity" ]
}
}
}
])5000 / 10 = 5007500 / 15 = 50010000 / 20 = 500Combine $divide with other operators for ratios, rates, and safe division in real pipelines.
Divide completed tasks by total tasks to get a progress ratio between 0 and 1:
db.projects.aggregate([
{
$project: {
name: 1,
completed: 1,
total: 1,
completionRatio: {
$divide: [ "$completed", "$total" ]
}
}
}
])Multiply the ratio by 100 with $multiply if you need a percentage display value (e.g., 0.7 → 70).
Calculate an hourly rate by dividing total earnings by hours worked:
db.timesheets.aggregate([
{
$addFields: {
hourlyRate: {
$divide: [ "$earnings", "$hoursWorked" ]
}
}
}
])$addFields keeps all original fields and adds hourlyRate. This pattern works for any “total divided by count” metric.
Guard against divide-by-zero when the divisor might be 0:
db.sales.aggregate([
{
$project: {
avgRevenuePerUnit: {
$cond: [
{ $eq: [ "$quantity", 0 ] },
null,
{ $divide: [ "$revenue", "$quantity" ] }
]
}
}
}
])If quantity is zero, return null instead of dividing. This prevents pipeline errors on documents with missing or zero quantities.
$divide WorksThe pipeline resolves the dividend and divisor — field paths like "$revenue" or literal numbers.
MongoDB divides the dividend by the divisor. If the divisor is zero, an error is thrown.
The quotient is written to the field you define in $project or $addFields.
You get computed metrics like per-unit revenue, completion ratios, or hourly rates for reports and dashboards.
The $divide operator is a fundamental arithmetic tool in MongoDB aggregation pipelines. It lets you compute ratios, averages, and rates directly on your data — from revenue per unit to project completion percentages and hourly earnings.
For beginners, the key idea is simple: pass two values in an array — { $divide: [ dividend, divisor ] } — inside a stage like $project, and MongoDB returns the quotient. Always watch for zero divisors in your data.
$divide for per-unit, ratio, and rate calculations$cond and $eq$multiply to convert ratios to percentages$round on results when displaying decimals$divide as a query filter outside expressionsnull in either operand returns null$divideUse these points when computing ratios in MongoDB pipelines.
Dividend ÷ divisor.
Purpose{ $divide: [a, b] }
$project, $addFields, $set.
UsageRatios, rates, averages.
Use caseDivisor 0 throws error.
Edge caseMove on to $eq for equality comparisons, or review $degreesToRadians for angle conversion.
5 people found this page helpful