The $expr operator lets you use aggregation expressions inside find() queries and $match stages. It unlocks field-to-field comparisons, arithmetic filters, and dynamic conditions that standard query operators cannot handle alone.
Aggregation ops in filters.
{ $expr: { ... } }
Compare two document fields.
Filter in aggregation pipelines.
Budget checks, validation.
"$field" inside expressions.
In MongoDB, the $expr operator bridges query filters and aggregation expressions. Standard query operators like { salary: { $gt: 50000 } } compare a field to a literal value. With $expr, you can write { $expr: { $gt: [ "$spent", "$budget" ] } } to find documents where one field exceeds another — something regular queries cannot do directly.
Inside $expr, field names need a $ prefix: "$spent", not "spent". This is aggregation expression syntax. Wrap comparison operators like $gt, $eq, or $and inside $expr.
The $expr operator wraps any aggregation expression for use in a query filter:
{ $expr: <aggregation expression> }Common patterns inside $expr:
// Compare two fields:
{ $expr: { $gt: [ "$spent", "$budget" ] } }
// Combine conditions:
{ $expr: { $and: [
{ $eq: [ "$status", "active" ] },
{ $gte: [ "$score", 80 ] }
] } }$expr — wraps an aggregation expression for use in find() or $match."$fieldName" with a dollar sign inside the expression.$eq, $gt, $gte, $lt, $lte, $ne.$and, $or, $not.$add, $subtract, $multiply, $divide.Know when you need $expr:
{ salary: { $gt: 50000 } } (field vs literal){ $expr: { $gt: [ "$spent", "$budget" ] } } (field vs field)$expr when comparing fields or doing math in filters| Question | Answer |
|---|---|
| Operator type | Query operator (wraps aggregation expressions) |
| Syntax | { $expr: <aggregation expression> } |
| Field references | "$fieldName" with $ prefix |
| Key use case | Compare two fields on the same document |
| Common stages | find(), $match |
{
$expr: {
$gt: [
"$spent",
"$budget"
]
}
}spent > budget
{
$expr: {
$and: [
{ $eq: ["$status","active"] },
{ $gte: ["$score", 80] }
]
}
}Multiple conditions
{
$expr: {
$lt: [
"$salePrice",
{ $multiply: ["$price", 0.5] }
]
}
}sale < 50% of price
{
$match: {
$expr: {
$eq: ["$dept","Sales"]
}
}
}Aggregation pipeline
Walk through sample budget data, filter documents where spending exceeds budget using $expr, and explore arithmetic and compound conditions.
Use a departments collection and find records where spent exceeds budget with $expr.
Suppose you have a departments collection tracking spending against budget:
[
{ "_id": ObjectId("609c26812e9274a86871bc6a"), "name": "Marketing", "budget": 10000, "spent": 12500 },
{ "_id": ObjectId("609c26812e9274a86871bc6b"), "name": "Engineering", "budget": 50000, "spent": 42000 },
{ "_id": ObjectId("609c26812e9274a86871bc6c"), "name": "Sales", "budget": 8000, "spent": 9500 }
]Use $expr to compare two fields on the same document:
db.departments.find({
$expr: {
$gt: [ "$spent", "$budget" ]
}
})12500 > 10000 → matched (over budget).42000 > 50000 → excluded (under budget).9500 > 8000 → matched (over budget).{ spent: { $gt: 10000 } } cannot compare two fields.Combine $expr with arithmetic, logical operators, and aggregation pipelines.
Find products where the sale price is less than half the original price:
db.products.find({
$expr: {
$lt: [
"$salePrice",
{ $multiply: [ "$price", 0.5 ] }
]
}
})$multiply computes half the original price inside the filter. $lt then compares salePrice against that computed value.
Find active employees with a score of at least 80:
db.employees.find({
$expr: {
$and: [
{ $eq: [ "$status", "active" ] },
{ $gte: [ "$score", 80 ] }
]
}
})Both conditions inside $and must be true. This pattern works when you need aggregation-style comparisons in a standard find() query.
The same syntax works inside aggregation pipelines:
db.departments.aggregate([
{
$match: {
$expr: {
$gt: [ "$spent", "$budget" ]
}
}
},
{
$project: {
name: 1,
budget: 1,
spent: 1,
overspend: {
$subtract: [ "$spent", "$budget" ]
}
}
}
])$expr filters over-budget departments in $match, then a later $project stage computes how much each department overspent.
spent > budget, actual ≠ expected, or similar cross-field checks.$and, $or, and comparisons in a single find() or $match filter.$expr WorksFor each document, MongoDB runs the aggregation expression inside $expr — comparing fields, computing arithmetic, or checking conditions.
Comparison and logical operators produce a boolean result for each document, just like in aggregation $project stages.
Documents where the expression is true continue through find() or $match. Others are excluded.
You get documents matching field-to-field rules that standard query operators alone cannot express.
The $expr operator unlocks the full power of aggregation expressions inside query filters. It is the go-to tool when you need to compare fields on the same document, apply arithmetic in filters, or write dynamic conditions that standard query operators cannot handle.
For beginners, remember: wrap your aggregation expression in { $expr: ... }, use "$field" with a dollar prefix for field references, and reserve $expr for cases where regular query syntax is not enough.
$expr when comparing two fields on the same document$ inside the expression$and and $or for compound conditions$expr filters early in pipelines for performance$expr for simple field-vs-literal comparisons$ prefix on field references inside expressions$expr inside $project (it is a query operator)$expr when standard query syntax works fine$expr supports every aggregation stage operator$exprUse these points when writing dynamic MongoDB queries.
Aggregation ops in filters.
Purpose{ $expr: { ... } }
Compare "$a" and "$b".
UsageBudget, validation rules.
Use caseFields need "$field".
Edge caseMove on to $filter for array filtering, or review $eq for equality comparisons.
5 people found this page helpful