MongoDB $let Operator

What Is $let?

$let is a MongoDB aggregation expression that defines local variables, then evaluates one final expression that can use them. Compute a value once, give it a name, and reuse it with $$name.

$let = name a value, then use it

{ $let: {
    vars: { total: { $multiply: ["$price", "$qty"] } },
    in: "$$total"
  }
}

$price  → document field
$$total → $let variable

vars run first → then in

How to Use $let in MongoDB

Define variables in vars, then return a result from in.

1. Choose an expression stage ($addFields or $project).
2. In vars, name each temporary value (for example total = price × qty).
3. In in, build the final result using $$total (double dollar).
4. Keep variable names short and clear—they exist only inside this $let.

Pseudocode

for each document:
    // evaluate vars (can read document fields with $)
    total = price * qty

    // evaluate in (can read vars with $$)
    result = total          // or total - discount, etc.

    emit { ..., field: result }

Cheat Sheet

Keep these facts handy while naming aggregation variables.

Live Preview

Watch $let compute total = price × qty, then optionally subtract a discount in in.

document = { price: 50, qty: 3 }

vars:
  total = 50 × 3 → 150

in:
  $$total → 150

result → 150

Worked Walkthrough — Line Total

One order line: a Notebook costs 50 and quantity is 3. We name that product total, then reuse it.

Document:
  { item: "Notebook", price: 50, qty: 3 }

vars:
  total = $multiply(["$price", "$qty"])
        = 50 × 3
        = 150

in (example A): "$$total"           → 150
in (example B): $$total − 20        → 130

Without $let you would write multiply twice.
With $let you compute once and reuse $$total.

MongoDB Examples

We use one order line. First store the sample, then compute total with $let, then reuse it for a discount. Run these in mongosh after inserting the sample data once.

db.orders.insertOne({
  _id: 1,
  item: "Notebook",
  price: 50,
  qty: 3
});

db.orders.find()

{
  _id: 1,
  item: "Notebook",
  price: 50,
  qty: 3
}

price 50  ×  qty 3  →  total 150

$let names that 150 as $$total
so later steps can reuse it

db.orders.aggregate([
  {
    $addFields: {
      lineTotal: {
        $let: {
          vars: {
            total: { $multiply: ["$price", "$qty"] }
          },
          in: "$$total"
        }
      }
    }
  }
]);

{
  _id: 1,
  item: "Notebook",
  price: 50,
  qty: 3,
  lineTotal: 150
}

db.orders.aggregate([
  {
    $addFields: {
      afterDiscount: {
        $let: {
          vars: {
            total: { $multiply: ["$price", "$qty"] }
          },
          in: { $subtract: ["$$total", 20] }
        }
      }
    }
  }
]);

{
  _id: 1,
  item: "Notebook",
  price: 50,
  qty: 3,
  afterDiscount: 130
}

Performance Notes

$let is about clarity and avoiding duplicate work inside one expression. If many later stages need the value, write it once with $addFields instead.

Key Takeaways