MongoDB Operators

What Are MongoDB Operators?

MongoDB operators are special keys that start with $. They tell MongoDB how to work with your data—not just which field to look at.

You use operators to query, update, aggregate, transform, compare, and manipulate documents. Without them, you could only match exact field values; with them, you can express ranges, logic, math, arrays, and pipeline stages.

Operator = instruction that starts with $

Examples:
  $gt     → greater than (query / expression)
  $set    → set a field value (update / stage)
  $match  → filter documents in a pipeline
  $sum    → total values in a $group

Browse every tutorial in the left sidebar.

How MongoDB Operators Work

An operator is a named action. You place it where MongoDB expects an expression, filter, update, or stage. MongoDB reads the $name, applies the rule, and returns or modifies documents accordingly.

1. Pick the context (query, update, or aggregation).
2. Choose an operator that matches your goal (compare, set, filter, sum…).
3. Pass field paths, literals, or nested expressions as arguments.
4. Run the command; only matching or transformed documents are affected.

// Query filter
db.students.find({ score: { $gte: 80 } })

// Update
db.students.updateOne(
  { name: "Asha" },
  { $set: { grade: "A" } }
)

// Aggregation expression
db.students.aggregate([
  { $project: { total: { $add: ["$math", "$science"] } } }
])

How It Works

1. Query: $gte keeps documents where score is at least 80.
2. Update: $set writes grade: "A" on the matching student.
3. Aggregation: $add computes a per-document total inside $project.

MongoDB Operator Syntax

Almost every operator uses the $operator form. The $ prefix marks a reserved name so MongoDB does not treat it as a normal field.

{ $operatorName: <argument> }

// Field-path in aggregation (different meaning of $):
"$fieldName"   → value of that field on the current document

{ price: { $gt: 100 } }

{ $set: { status: "shipped" } }

{ $match: { city: "Chennai" } }

{ total: { $sum: "$amount" } }

Tip: $field as an operator means “run this action.” "$field" as a string path means “read this field.” Beginners often mix those two meanings—keep them separate.

Pseudocode

Use this mental model before you type mongosh syntax.

goal = what you need (filter / change / transform / total)

if goal is "find matching docs":
    use query operators ($gt, $in, $and, ...)
else if goal is "change stored fields":
    use update operators ($set, $unset, $push, ...)
else if goal is "pipeline analytics":
    use stages ($match, $group, ...)
    and expression / accumulator operators inside them

for each document:
    apply the operator rule
    keep, change, or emit the result

How It Works

1. Start from the goal, not from a random operator name.
2. Pick the family that matches that goal (query, update, or aggregation).
3. Apply the operator to each document (or each group) and collect results.

Operator Categories

Major families below. The left sidebar lists individual tutorials—this section only explains when each family is useful.

For rollups inside $group, see the accumulators hub. For pipeline steps, see aggregation stages.

Common MongoDB Operators

A short starter set. Open any name for a full tutorial when a page exists; use the sidebar for the complete catalog.

Worked Example

Small students collection. We filter high scores with $gte, then average them with $group and $avg.

db.students.insertMany([
  { _id: 1, name: "Asha",  score: 92 },
  { _id: 2, name: "Ben",   score: 74 },
  { _id: 3, name: "Chitra", score: 88 }
]);

[
  { _id: 1, name: "Asha", score: 92 },
  { _id: 2, name: "Ben", score: 74 },
  { _id: 3, name: "Chitra", score: 88 }
]

db.students.aggregate([
  { $match: { score: { $gte: 80 } } },
  {
    $group: {
      _id: null,
      avgHighScore: { $avg: "$score" },
      count: { $sum: 1 }
    }
  }
]);

[
  { _id: null, avgHighScore: 90, count: 2 }
]

Choosing the Right Operator

Match the job to the family first; then pick a specific operator.

Performance Notes

Use explain() when a query feels slow. Prefer correct indexes and smaller working sets over micro-optimizing a single operator choice.

Key Takeaways