MongoDB $not Operator

What Is $not?

$not means logical NOT. In a query it inverts an operator on a field. In aggregation it flips a boolean expression to the opposite value.

$not = logical negation

Query (negate a field operator):
  { price: { $not: { $lt: 10 } } }
  // keep docs where price is NOT < 10

Aggregation (flip a boolean):
  { $not: [ { $gt: [ "$price", 10 ] } ] }
  // true when price is NOT > 10

5  not < 10 → false (dropped)
15 not < 10 → true  (kept)

sibling tips:
  simple ≠ value → prefer $ne
  many exclusions → consider $nor

How to Use $not in MongoDB

Pick query mode (invert a field operator) or expression mode (boolean flip).

1. For filtering: wrap an operator under a field — { price: { $not: { $lt: 10 } } }.
2. For a boolean: use $addFields / $project with { $not: [ expr ] }.
3. Put one expression inside the aggregation array form.
4. Prefer $ne for simple “not equal to this value” checks.

Pseudocode

// Filter mode
for each document:
    if NOT (field matches operator-expression):
        keep document
    else:
        drop document

// Expression mode
for each document:
    result = NOT evaluate(expression)   // true ↔ false
    emit { ..., field: result }

Cheat Sheet

Keep these facts handy while writing NOT conditions.

Live Preview

Watch query $not test “price is not less than 10”.

price = 15
inner: price < 10 → false
$not → true (kept)

Worked Walkthrough — Not Less Than 10

Keep products whose price is not less than 10 (same idea as “price ≥ 10”, plus missing-field quirks).

Documents:
  { name: "Pen",  price: 5 }
  { name: "Book", price: 15 }

Filter: { price: { $not: { $lt: 10 } } }

Pen:  5  < 10 → true  → NOT → false → drop
Book: 15 < 10 → false → NOT → true  → keep

Result: only Book

MongoDB Examples

We use two products. First filter with query $not, then flip a boolean in aggregation. Run these in mongosh after inserting the sample data once.

db.products.insertMany([
  { _id: 1, name: "Pen", price: 5 },
  { _id: 2, name: "Book", price: 15 }
]);

db.products.find()

[
  { _id: 1, name: "Pen", price: 5 },
  { _id: 2, name: "Book", price: 15 }
]

NOT (price < 10)

  Pen 5   → 5 < 10 is true  → NOT → drop
  Book 15 → 15 < 10 is false → NOT → keep

db.products.find({
  price: { $not: { $lt: 10 } }
});

[
  { _id: 2, name: "Book", price: 15 }
]

db.products.aggregate([
  {
    $addFields: {
      notOverTen: {
        $not: [
          { $gt: ["$price", 10] }
        ]
      }
    }
  }
]);

[
  { _id: 1, name: "Pen", price: 5, notOverTen: true },
  { _id: 2, name: "Book", price: 15, notOverTen: false }
]

Performance Notes

When $not: { $lt: x } is logically “≥ x” for existing numbers, consider writing $gte directly for clearer intent.

Key Takeaways