The $size operator counts elements in an array. Use it in find queries to match an exact array length, or in aggregation pipelines to add a count field and filter by array length dynamically.
Array length.
Two contexts.
In find queries.
Range counts.
Tags, skills, items.
[] returns zero.
MongoDB’s $size operator returns how many elements an array contains. In an aggregation pipeline, { $size: "$tags" } produces a number like 3. In a find query, { tags: { $size: 3 } } matches only documents whose tags array has exactly three elements.
This is one of the most practical array operators — use it to validate list lengths, score content by tag count, or find documents with empty arrays.
Query $size only supports exact counts. Need “at least 3 tags”? Use aggregation $size inside $match with $expr and $gte.
$size has two forms depending on where you use it:
{ $size: <array expression> }{ <arrayField>: { $size: <non-negative integer> } }$gt or $lt with query $size.$size of [] is 0.$project, $addFields, or $match + $expr.$ifNull or $cond + $isArray when needed.{ tags: { $size: 2 } } → exactly 2 elements only{ tagCount: { $size: "$tags" } } → adds count field$match: { $expr: { $gte: [ { $size: "$tags" }, 3 ] } }| Question | Answer |
|---|---|
| Operator type | Query operator and aggregation expression |
| Aggregation syntax | { $size: <array> } |
| Query syntax | { field: { $size: N } } |
| Output | Non-negative integer (count) |
| Empty array | 0 |
{
$size: "$tags"
}In $project
{
tags: { $size: 3 }
}Exactly 3 tags
$expr: {
$gte: [
{ $size: "$tags" }, 3
]
}3+ tags
{
$size: [1, 2, 3]
}Returns 3
Count tags in a projection, find documents with an exact array length, filter by minimum count, and measure set overlap with $size.
Add a tagCount field to each document using $project.
Suppose you have an articles collection:
[
{
"_id": 1,
"title": "Intro to MongoDB",
"tags": ["mongodb", "database", "tutorial"]
},
{
"_id": 2,
"title": "Quick Tips",
"tags": ["mongodb", "tips"]
},
{
"_id": 3,
"title": "Draft",
"tags": []
}
]Add a numeric field showing how many tags each article has:
db.articles.aggregate([
{
$project: {
title: 1,
tags: 1,
tagCount: { $size: "$tags" }
}
}
])$size evaluates the tags array and returns its element count. An empty array returns 0.
Exact-length find queries and flexible range filters in aggregation.
Use query $size for an exact array length match:
db.articles.find({
tags: { $size: 2 }
})
// Returns "Quick Tips" onlyQuery $size matches only when the array length equals the given integer. It cannot express “2 or more” on its own.
Use aggregation $size inside $expr for range comparisons:
db.articles.aggregate([
{
$match: {
$expr: {
$gte: [
{ $size: "$tags" },
3
]
}
}
},
{
$project: { title: 1, tags: 1 }
}
])
// Returns "Intro to MongoDB" only$expr lets you use aggregation expressions in $match. Combine $size with $gte, $lte, or $eq for flexible filters.
Measure overlap size between two tag arrays:
db.recommendations.aggregate([
{
$project: {
user: 1,
overlapCount: {
$size: {
$setIntersection: [
"$userTags",
"$articleTags"
]
}
}
}
}
])$setIntersection returns the shared elements; $size turns that array into a numeric relevance score. Sort by overlapCount descending for best matches.
{ field: { $size: 0 } }.$setIntersection.$size WorksIn aggregation, the input expression resolves to an array field or literal. In queries, MongoDB checks the named field.
MongoDB counts top-level array elements. Nested arrays count as one element each.
Aggregation stores the integer in a new field or compares it in $expr. Queries match or exclude documents.
Use for display, sorting, filtering, or chaining with other operators.
The $size operator counts array elements in both queries and aggregation pipelines. Use the query form for exact-length matches and the aggregation form when you need computed counts or range comparisons.
Pair it with set operators like $setIntersection for overlap scoring, or with $slice to extract portions of arrays after you know their size. Next in the series: $slice.
$size for exact array-length filters$size + $expr for “at least N” logic$ifNull: [ "$tags", [] ] before $size$setIntersection for overlap counts0, not null$size with $gt or $lt — it only accepts exact integers$size without checking$bsonSize for document bytes)$size to flatten nested arrays before counting$sizeUse these points when counting array elements in MongoDB.
Array length.
PurposeTwo forms.
SyntaxInteger only.
Query ruleRange filters.
PatternEmpty array.
Edge caseMove on to $slice to extract portions of arrays, or review $setIntersection for overlap logic.
5 people found this page helpful