MongoDB $not Operator

What You’ll Learn

The $not operator negates a condition. In queries it inverts an operator on a field (e.g., “not less than 10”). In aggregation expressions it flips a boolean result from true to false.

Definition and Usage

In MongoDB, $not performs logical negation in two contexts. As a query operator, it inverts a single operator on a field: { price: { $not: { $lt: 10 } } } matches documents where price is not less than 10 (equivalent to { price: { $gte: 10 } } for numeric fields).

As an aggregation expression, { $not: <expression> } returns true when the inner expression is false, and vice versa. Wrap $or, $and, or comparison expressions inside $not for complex inverted logic.

📝 Syntax

$not has two forms depending on where you use it:

Query form (negate an operator on a field)

{ field: { $not: <operator expression> } }

Aggregation expression form (negate a boolean)

{ $not: <boolean expression> }

Syntax Rules

• Query form — negates one operator expression on a specific field.
• Expression form — inverts a boolean result; use in $project, $addFields, or $expr.
• Query $not also matches documents where the field is missing or null.
• Cannot use query $not at the top level of a filter (must be on a field).
• For simple value inequality, prefer $ne over $not.
• Wrap $or inside expression $not to replicate $nor logic.

Examples Gallery

Negate price comparisons in queries, filter with regex exclusion, flip booleans in $project, and build NOR logic in $expr.

[
  { "_id": ObjectId("609c26812e9274a86871bc6a"), "name": "Widget",  "price": 25 },
  { "_id": ObjectId("609c26812e9274a86871bc6b"), "name": "Budget",  "price": 5 },
  { "_id": ObjectId("609c26812e9274a86871bc6c"), "name": "Premium", "price": 99 },
  { "_id": ObjectId("609c26812e9274a86871bc6d"), "name": "Mid",     "price": 10 }
]

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

// Equivalent to:
// db.products.find({ price: { $gte: 10 } })

{ "name": "Widget",  "price": 25 }
{ "name": "Premium", "price": 99 }
{ "name": "Mid",     "price": 10 }

db.users.find({
  name: {
    $not: { $regex: /^test/i }
  }
})

// "Alice"     → included
// "testUser"  → excluded
// "TestAdmin" → excluded (case-insensitive)

db.products.aggregate([
  {
    $project: {
      name: 1,
      price: 1,
      isFullPrice: {
        $not: { $lt: [ "$price", 20 ] }
      }
    }
  }
])

// price: 5  → isFullPrice: false ($lt 20 is true, $not flips it)
// price: 25 → isFullPrice: true
// price: 99 → isFullPrice: true

db.products.find({
  $expr: {
    $not: {
      $or: [
        { $eq: [ "$inStock", false ] },
        { $lt: [ "$price", 10 ] }
      ]
    }
  }
})

// Matches products that are NOT (out of stock OR under $10)

db.users.aggregate([
  {
    $match: {
      age: { $not: { $lt: 18 } }
    }
  },
  {
    $project: {
      name: 1,
      age: 1
    }
  }
])

🚀 Use Cases

• Inverted comparisons — express “not less than” or “not greater than” on numeric fields.
• Regex exclusion — exclude documents matching a text pattern.
• Boolean flags — flip true/false in $project for reporting.
• NOR in expressions — wrap $or with $not inside $expr.

💡 Best Practices