The $let operator defines local variables inside an aggregation expression. Compute a value once in vars, then reuse it in in — cleaner than repeating the same sub-expression many times.
Name and store values.
vars + in.
Double dollar variables.
Avoid repetition.
Totals, labels, logic.
Scoped inner vars.
In MongoDB’s aggregation framework, the $let operator binds one or more variables to expressions, then evaluates a final in expression that can reference those variables. For example, you might compute price × quantity once as $$lineTotal, then use it for tax, discount, and final amount fields without duplicating the multiplication.
Think of $let as a small let block inside your pipeline — similar to declaring a variable in JavaScript before using it in a return expression.
Inside in, reference variables with double dollar signs: "$$total". A single $ refers to document fields like "$price". This is the same $$ convention used by $filter and $map.
The $let operator takes a vars object and an in expression:
{
$let: {
vars: {
<varName1>: <expression1>,
<varName2>: <expression2>
},
in: <expression using $$varName1, $$varName2>
}
}// Single variable
{ $let: {
vars: { total: { $multiply: [ "$price", "$qty" ] } },
in: "$$total"
}}
// Multiple variables
{ $let: {
vars: {
subtotal: { $multiply: [ "$price", "$qty" ] },
tax: { $multiply: [ { $multiply: [ "$price", "$qty" ] }, 0.1 ] }
},
in: { $add: [ "$$subtotal", "$$tax" ] }
}}vars — object mapping variable names to expressions (computed once per document).in — the final expression whose result becomes the output value.$$varName (double dollar) inside in.vars can reference earlier variables in the same vars object.$project, $addFields, $set, $cond, and nested expressions.$let can be nested — inner $let scopes are separate from outer ones.$price → field path on the current document$$total → local variable defined in $let (or $filter / $map)"active" (no dollar prefix)| Question | Answer |
|---|---|
| Operator type | Aggregation expression operator (variables) |
| Syntax | { $let: { vars: {...}, in: ... } } |
| Variable reference | $$varName (double dollar) |
| Output | Result of the in expression |
| Common stages | $project, $addFields, $cond |
{
$let: {
vars: {
total: {
$multiply: [
"$price", "$qty"
]
}
},
in: "$$total"
}
}Compute and return
{
$let: {
vars: {
a: "$x",
b: "$y"
},
in: {
$add: ["$$a", "$$b"]
}
}
}Two variables
{
$let: {
vars: {
t: { $add: [
"$a", "$b"
]}
},
in: {
$gte: ["$$t", 100]
}
}
}Reuse in condition
{
$let: {
vars: { x: "$a" },
in: {
$let: {
vars: { y: "$b" },
in: {
$add: ["$$x","$$y"]
}
}
}
}
}Inner scope
Walk through sample order line items, compute totals with $let, and build readable multi-step expressions without repetition.
Start with an orders collection and use $let to calculate a line total from price and quantity.
Suppose you have an orders collection with line item fields:
[
{ "_id": ObjectId("609c26812e9274a86871bc6a"), "item": "Notebook", "price": 12.50, "quantity": 3 },
{ "_id": ObjectId("609c26812e9274a86871bc6b"), "item": "Pen Pack", "price": 8.99, "quantity": 2 },
{ "_id": ObjectId("609c26812e9274a86871bc6c"), "item": "Stapler", "price": 15.00, "quantity": 1 }
]Compute price × quantity once and return it as lineTotal:
db.orders.aggregate([
{
$project: {
item: 1,
price: 1,
quantity: 1,
lineTotal: {
$let: {
vars: {
total: {
$multiply: [ "$price", "$quantity" ]
}
},
in: "$$total"
}
}
}
}
])vars.total evaluates $multiply once per document.in: "$$total" returns that value as the lineTotal field.in.Use multiple variables, combine with tax logic, and drive conditional labels.
Define subtotal once, then compute tax and final amount from it:
db.orders.aggregate([
{
$project: {
item: 1,
pricing: {
$let: {
vars: {
subtotal: {
$multiply: [ "$price", "$quantity" ]
}
},
in: {
subtotal: "$$subtotal",
tax: {
$multiply: [ "$$subtotal", 0.1 ]
},
grandTotal: {
$multiply: [
"$$subtotal",
1.1
]
}
}
}
}
}
}
])$$subtotal is referenced three times inside in without repeating { $multiply: [ "$price", "$quantity" ] }. This keeps the pipeline readable and avoids calculation drift if the formula changes.
Label orders as “bulk” or “standard” based on line total:
db.orders.aggregate([
{
$project: {
item: 1,
orderType: {
$let: {
vars: {
total: {
$multiply: [ "$price", "$quantity" ]
}
},
in: {
$cond: [
{ $gte: [ "$$total", 30 ] },
"bulk",
"standard"
]
}
}
}
}
}
])$let computes $$total first, then $cond uses it in the condition. You could add more fields in the same in block that also reference $$total.
Apply a discount rate based on quantity, then compute the final price:
db.orders.aggregate([
{
$project: {
item: 1,
finalPrice: {
$let: {
vars: {
base: {
$multiply: [ "$price", "$quantity" ]
}
},
in: {
$let: {
vars: {
rate: {
$cond: [
{ $gte: [ "$quantity", 3 ] },
0.9,
1.0
]
}
},
in: {
$multiply: [ "$$base", "$$rate" ]
}
}
}
}
}
}
}
])The outer $let defines $$base. The inner $let defines $$rate and can use $$base from the outer scope. Notebook (qty 3) gets a 10% discount: 37.5 × 0.9 = 33.75.
Later entries in vars can use earlier variables:
db.orders.aggregate([
{
$project: {
item: 1,
summary: {
$let: {
vars: {
subtotal: {
$multiply: [ "$price", "$quantity" ]
},
tax: {
$multiply: [
"$$subtotal",
0.1
]
}
},
in: {
subtotal: "$$subtotal",
tax: "$$tax",
total: {
$add: [ "$$subtotal", "$$tax" ]
}
}
}
}
}
}
])The tax variable references $$subtotal defined earlier in the same vars object. MongoDB evaluates vars in order, so dependencies must be declared before use.
subtotal or margin instead of nested operator trees.$cond or $switch using precomputed variables.$let WorksEach variable in vars is computed from field paths or expressions, in declaration order.
Inside in, use $$varName to read the bound values for the current document.
MongoDB evaluates in and returns its result as the output of the surrounding $let.
You get named intermediate values and less duplicated logic in your pipeline.
The $let operator is a small but powerful tool for writing readable aggregation expressions. It lets you name intermediate results, reuse them across fields, and nest scoped variables for multi-step calculations — without repeating the same sub-expression everywhere.
For beginners, remember the pattern: define values in vars, reference them with $$name in in, and keep variable names short but meaningful. When expressions grow complex, reach for $let before adding more nesting.
subtotal or margin$$varName inside invars$letin focused — return an object or value you need$ for local variables (use $$)vars$let when one level with multiple vars suffices$let as a pipeline stage (it is an expression operator)$let with JavaScript let outside the pipeline$letUse these points when writing variable expressions in MongoDB.
vars + in pattern.
PurposeDouble dollar vars.
SyntaxCompute once.
UsagePrecompute conditions.
PatternInner scopes OK.
AdvancedMove on to $literal for fixed literal values, or review $cond for conditional branching.
5 people found this page helpful