The $min accumulator finds the lowest value in each $group bucket—ideal for cheapest prices, minimum scores, floor quantities, and range reports alongside $max.
Smallest value in the bucket.
{ $min: "$field" }
Scans all docs in group.
Min of computed values.
Floor value vs first doc.
Skips null when others exist.
$min is a MongoDB accumulator used in the $group stage. For each group, it evaluates an expression on every document and returns the minimum value found.
Unlike $first or $last, $min does not care about document order—it compares values across the whole group. Prices 25, 15, 20, and 10 yield 10 whether or not you sorted first.
Use $min for price floors, minimum test scores, lowest inventory levels, and quality thresholds. Pair with $max for min/max ranges, or use $bottomN when you need the full documents at the bottom of a ranked list.
$min takes one expression inside $group:
{
$group: {
_id: <expression>,
<outputField>: { $min: <expression> }
}
}$group (also $bucket, windows)."$price" or a formula like { $multiply: ["$price", "$quantity"] }.null if no usable values exist._id: null — one global minimum across all documents.db.products.aggregate([
{
$group: {
_id: null,
minPrice: { $min: "$price" }
}
}
]);| Question | Answer |
|---|---|
| Stage | $group accumulator |
| Syntax | { $min: <expression> } |
| Needs $sort? | No—scans entire group |
| Empty / all null | Returns null |
vs $max | $min = lowest; $max = highest |
vs $first | $min = floor anywhere; $first = value on first doc |
{ _id: null,
min: { $min: "$price" } }One floor for all docs
{ _id: "$category",
min: { $min: "$price" } }Min per category
{ $min: {
$multiply: ["$price", "$qty"]
} }Min of computed total
low: { $min: "$price" }
high: { $max: "$price" }Range in one $group
$min 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.
{ $min: "$price" }
{ $min: { $add: ["$base", "$discount"] } }_id Group keyDefines buckets. Use a field path for per-category minimums, compound keys for multi-field grouping, or null for one global bucket.
_id: "$category"return type Value | nullReturns the winning value’s type (number, date, string, etc.). With mixed types, BSON comparison order determines the result type.
10null / missing ImportantIf some documents have values, null and missing fields are skipped. If all are null or missing, result is null.
$match: { price: { $type: "number" } }Product prices and student scores—find global and per-group minimums, use expressions, and compare with related operators.
Insert sample products and find the lowest price overall.
db.products.insertMany([
{ name: "Product A", category: "Electronics", price: 25 },
{ name: "Product B", category: "Electronics", price: 15 },
{ name: "Product C", category: "Books", price: 20 },
{ name: "Product D", category: "Books", price: 10 }
]);Four products across two categories—the global minimum price is Product D at 10; Electronics min is 15.
db.products.aggregate([
{
$group: {
_id: null,
minPrice: { $min: "$price" }
}
}
]);
/* Result:
{ _id: null, minPrice: 10 }
— Product D has the lowest price */
*/_id: null groups every document together. $min compares all price values and returns 10.
Break minimums down by category, compute on expressions, and compare operators.
db.products.aggregate([
{
$group: {
_id: "$category",
minPrice: { $min: "$price" },
maxPrice: { $max: "$price" }
}
},
{ $sort: { _id: 1 } }
]);
/* Result:
[
{ _id: "Books", minPrice: 10, maxPrice: 20 },
{ _id: "Electronics", minPrice: 15, maxPrice: 25 }
]
*/Grouping by category gives independent min/max price ranges—common for catalog and pricing analysis.
Find the smallest 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",
minTotal: {
$min: { $multiply: ["$price", "$quantity"] }
},
minQty: { $min: "$quantity" }
}
},
{ $sort: { _id: 1 } }
]);
/* abc → minTotal: 20 (10×2), minQty: 2
jkl → minTotal: 20, minQty: 1
xyz → minTotal: 25 (5×5), minQty: 5 */
*/$min accepts any expression—not just a field path. MongoDB evaluates $multiply per document, then picks the smallest result.
The lowest value is not always on the first document:
db.students.insertMany([
{ name: "Alice", class: "10A", score: 85 },
{ name: "Bob", class: "10A", score: 92 },
{ name: "Charlie", class: "10A", score: 78 }
]);
db.students.aggregate([
{ $sort: { class: 1, score: 1 } },
{
$group: {
_id: "$class",
minScore: { $min: "$score" },
firstDocScore: { $first: "$score" }
}
}
]);
/* 10A (sorted asc by score: 78, 85, 92):
minScore: 78 — Charlie's score
firstDocScore: 78 — same here (lowest is first)
If sorted by name instead, firstDocScore might be 85 (Alice)
while minScore stays 78 */
*/Use $min when you need the floor. Use $first when you need the value tied to the earliest (sorted) record—they answer different questions.
$min Works$group assigns each document to a bucket via _id.
For each document, MongoDB computes the $min expression (field or formula).
MongoDB tracks the running minimum using BSON comparison rules across all documents in the bucket.
One floor value per group—or null if no comparable values exist.
$min 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.$min is the go-to accumulator for floor values inside $group. It is simple, order-independent, and works on field paths or expressions like $multiply.
Pair with $max for ranges, use $bottom when you need the full lowest-ranked document, or explore $minN for the N smallest values per group.
$min + $max in one $group for price/score ranges$match before $group to min only relevant documents$match: { field: { $type: "number" } } when data is messy$bottom or $bottomN when you need identifying fields from the lowest record$min with $first (floor vs first document’s value)$min returns the product name—it returns the minimum value only$min to traverse into array elements inside $group$min when you need N smallest values—use $minN instead$minUse these points when finding floor values inside $group.
Lowest in the group.
Basics{ $min: "$field" }
SyntaxScans whole group.
PatternFloor vs leading doc.
CompareMin/max ranges.
Pair$min and $max use BSON comparison order, so dates, strings, and numbers compare by type rules—not just numeric magnitude. For the N smallest numbers specifically, MongoDB 5.2+ offers $minN. See the official $min docs.
Find floor values with $min, then learn $minN for the N smallest values per group.
5 people found this page helpful