The $max accumulator finds the highest value in each $group bucket—ideal for top scores, peak prices, highest quantities, and range reports alongside $min.
Largest value in the bucket.
{ $max: "$field" }
Scans all docs in group.
Max of computed values.
Peak value vs last doc.
Skips null when others exist.
$max is a MongoDB accumulator used in the $group stage. For each group, it evaluates an expression on every document and returns the maximum value found.
Unlike $first or $last, $max does not care about document order—it compares values across the whole group. Scores 85, 92, and 78 yield 92 whether or not you sorted first.
Use $max for leaderboard peaks, inventory high-water marks, price ceilings, and validation checks. Pair with $min for min/max ranges, or use $topN when you need the full document that achieved the peak, not just the number.
$max takes one expression inside $group:
{
$group: {
_id: <expression>,
<outputField>: { $max: <expression> }
}
}$group (also $bucket, windows)."$score" or a formula like { $multiply: ["$price", "$quantity"] }.null if no usable values exist._id: null — one global maximum across all documents.db.students.aggregate([
{
$group: {
_id: null,
maxScore: { $max: "$score" }
}
}
]);| Question | Answer |
|---|---|
| Stage | $group accumulator |
| Syntax | { $max: <expression> } |
| Needs $sort? | No—scans entire group |
| Empty / all null | Returns null |
vs $min | $max = highest; $min = lowest |
vs $last | $max = peak anywhere; $last = value on last doc |
{ _id: null,
max: { $max: "$score" } }One peak for all docs
{ _id: "$class",
max: { $max: "$score" } }Max per class
{ $max: {
$multiply: ["$price", "$qty"]
} }Max of computed total
low: { $min: "$score" }
high: { $max: "$score" }Range in one $group
$max accepts one expression inside $group:
expression RequiredValue compared for each document in the group. Can be a field path or any expression MongoDB can compare using BSON ordering rules.
{ $max: "$salary" }
{ $max: { $add: ["$base", "$bonus"] } }_id Group keyDefines buckets. Use a field path for per-category maximums, compound keys for multi-field grouping, or null for one global bucket.
_id: "$item"return type Value | nullReturns the winning value’s type (number, date, string, etc.). With mixed types, BSON comparison order determines the result type.
92null / missing ImportantIf some documents have values, null and missing fields are skipped. If all are null or missing, result is null.
$match: { score: { $type: "number" } }Student scores and sales data—find global and per-group maximums, use expressions, and compare with related operators.
Insert sample student scores and find the highest score overall.
db.students.insertMany([
{ name: "Alice", class: "10A", score: 85 },
{ name: "Bob", class: "10A", score: 92 },
{ name: "Charlie", class: "10B", score: 78 },
{ name: "Diana", class: "10B", score: 88 },
{ name: "Eve", class: "10A", score: 90 }
]);Five students across two classes—the global max is Bob’s 92; class 10A max is also 92.
db.students.aggregate([
{
$group: {
_id: null,
maxScore: { $max: "$score" }
}
}
]);
/* Result:
{ _id: null, maxScore: 92 }
— Bob has the highest score */
*/_id: null groups every document together. $max compares all score values and returns 92.
Break maximums down by category, compute on expressions, and compare operators.
db.students.aggregate([
{
$group: {
_id: "$class",
minScore: { $min: "$score" },
maxScore: { $max: "$score" }
}
},
{ $sort: { _id: 1 } }
]);
/* Result:
[
{ _id: "10A", minScore: 85, maxScore: 92 },
{ _id: "10B", minScore: 78, maxScore: 88 }
]
*/Grouping by class gives independent min/max ranges per section—common for grade spread reports.
Find the highest price × quantity per item:
db.sales.insertMany([
{ item: "abc", price: 10, quantity: 2 },
{ item: "jkl", price: 20, quantity: 1 },
{ item: "xyz", price: 5, quantity: 5 },
{ item: "abc", price: 10, quantity: 10 },
{ item: "xyz", price: 5, quantity: 10 }
]);
db.sales.aggregate([
{
$group: {
_id: "$item",
maxTotal: {
$max: { $multiply: ["$price", "$quantity"] }
},
maxQty: { $max: "$quantity" }
}
},
{ $sort: { _id: 1 } }
]);
/* abc → maxTotal: 100 (10×10), maxQty: 10
jkl → maxTotal: 20, maxQty: 1
xyz → maxTotal: 50, maxQty: 10 */
*/$max accepts any expression—not just a field path. MongoDB evaluates $multiply per document, then picks the largest result.
Peak value is not always on the most recent document:
db.students.aggregate([
{ $sort: { class: 1, score: 1 } },
{
$group: {
_id: "$class",
maxScore: { $max: "$score" },
lastDocScore: { $last: "$score" }
}
}
]);
/* 10A (sorted asc by score: 85, 90, 92):
maxScore: 92
lastDocScore: 92 — same here
If Eve(95) were last by date but Bob(92) had max:
maxScore → 95 or 92 depending on data;
lastDocScore → score on final sorted doc */
*/Use $max when you need the peak. Use $last when you need the value tied to the most recent (sorted) record—they answer different questions.
$max Works$group assigns each document to a bucket via _id.
For each document, MongoDB computes the $max expression (field or formula).
MongoDB tracks the running maximum using BSON comparison rules across all documents in the bucket.
One peak value per group—or null if no comparable values exist.
$max does not require $sort—it scans the entire group.null when every document has null or missing values for the expression.$group, array fields are compared as whole arrays, not element-by-element.$max is the go-to accumulator for peak values inside $group. It is simple, order-independent, and works on field paths or expressions like $multiply.
Pair with $min for ranges, use $top when you need the full winning document, or explore $maxN for the N largest values per group.
$max + $min in one $group for score/price ranges$match before $group to max only relevant documents$match: { field: { $type: "number" } } when data is messy$top or $bottom when you need identifying fields from the peak record$max with $last (peak vs last document’s value)$max returns the student name—it returns the maximum value only$max to traverse into array elements inside $group$max when you need N largest values—use $maxN instead$maxUse these points when finding peak values inside $group.
Highest in the group.
Basics{ $max: "$field" }
SyntaxScans whole group.
PatternPeak vs trailing doc.
CompareMin/max ranges.
Pair$max and $min use BSON comparison order, so dates, strings, and numbers compare by type rules—not just numeric magnitude. For the N largest numbers specifically, MongoDB 5.2+ offers $maxN. See the official $max docs.
Find peak values with $max, then learn $maxN for the N largest values per group.
5 people found this page helpful