The $ne operator checks whether two values are not equal. Use it in $match to exclude specific values, or in expression stages like $project and $cond to get a true/false result.
Exclude matching values.
Query filter vs expression.
Filter out unwanted rows.
true or false in $project.
Exclusions, validation.
Know inclusion behavior.
In MongoDB, the $ne operator tests inequality in two contexts. In a $match stage, { status: { $ne: "archived" } } keeps documents where status is anything other than "archived". In an aggregation expression, { $ne: [ "$role", "admin" ] } returns true or false for each document.
Unlike $eq, there is no shorthand for $ne. You must write { field: { $ne: value } } explicitly. Also, query $ne matches documents where the field is missing or null.
$ne has two forms depending on where you use it:
$match or find filters){ field: { $ne: <value> } }$project, $cond, etc.){ $ne: [ <expression1>, <expression2> ] }true or false.$project, $addFields, $cond, and $filter.$nin instead.{ status: "active" } or { status: { $eq: "active" } }{ status: { $ne: "archived" } } (exclude one value){ status: { $nin: ["archived", "cancelled"] } } (exclude many values)| Question | Answer |
|---|---|
| Operator type | Comparison operator (query + expression) |
| Query syntax | { field: { $ne: value } } |
| Expression syntax | { $ne: [ expr1, expr2 ] } |
| Expression output | true or false |
| Missing fields | Query $ne matches documents without the field |
{
status: { $ne: "archived" }
}Exclude archived
{
$ne: [ "$role", "admin" ]
}Returns true/false
{
$ne: [ "$expected", "$actual" ]
}Detect mismatch
{
status: { $exists: true, $ne: null }
}Field present, not null
Exclude archived orders, filter in find(), add boolean flags, and power conditional logic with $ne.
Use an orders collection and filter out archived orders with $match.
Suppose you have an orders collection with orderId, customer, and status:
[
{ "_id": ObjectId("609c26812e9274a86871bc6a"), "orderId": "ORD-101", "customer": "Alice", "status": "active" },
{ "_id": ObjectId("609c26812e9274a86871bc6b"), "orderId": "ORD-102", "customer": "Bob", "status": "archived" },
{ "_id": ObjectId("609c26812e9274a86871bc6c"), "orderId": "ORD-103", "customer": "Carol", "status": "pending" }
]Find orders that are not archived:
db.orders.aggregate([
{
$match: {
status: { $ne: "archived" }
}
}
])active) and Carol (pending) pass the filter.archived) is excluded because his status equals the excluded value.status field would also match $ne.Use find(), add boolean flags, compare fields, and build conditional labels.
Exclude cancelled orders outside an aggregation pipeline:
db.orders.find({
status: { $ne: "cancelled" }
})$ne in find() uses the same query form as $match. It is one of the most common ways to exclude a single unwanted value.
Flag users who are not admins on every document:
db.users.aggregate([
{
$project: {
name: 1,
role: 1,
isNotAdmin: {
$ne: [ "$role", "admin" ]
}
}
}
])The expression form does not filter documents. It adds true or false to every document based on whether role differs from "admin".
Label inventory items as “mismatch” when expected and actual counts differ:
db.inventory.aggregate([
{
$project: {
item: 1,
expected: 1,
actual: 1,
checkResult: {
$cond: [
{ $ne: [ "$expected", "$actual" ] },
"mismatch",
"ok"
]
}
}
}
])When $ne returns true (values differ), $cond outputs "mismatch". When they are equal, it outputs "ok". This is the inverse of an $eq-based check.
Combine $exists with $ne when you only want documents with a real value:
db.orders.find({
status: { $exists: true, $ne: null }
})
// Matches documents that HAVE a status field
// and status is not null
// (unlike $ne alone, which also matches missing fields)Plain { status: { $ne: null } } matches documents without status. Adding $exists: true narrows the filter to documents where the field is present and not null.
expected and actual fields differ.$ne WorksIn $match, it checks a field against an excluded value. In expressions, it evaluates two operands like "$role" and "admin".
MongoDB checks whether the values are not equal using BSON comparison rules. Missing fields count as not equal in query form.
In $match, non-matching documents pass through. In expressions, true or false is stored in the output field.
You get excluded results or boolean fields ready for validation and conditional logic.
The $ne operator is the go-to tool for excluding a single value in MongoDB queries and for testing inequality in aggregation expressions. It complements $eq and pairs naturally with $cond for mismatch detection.
Remember there is no shorthand for $ne, query form matches missing fields, and $nin is better for excluding multiple values. Next in the series: $nin.
$ne to exclude a single unwanted value$exists: true when missing fields should not match$nin when excluding multiple values at once$cond for mismatch labels$ne like $eq has$ne matches documents without the field$ne on the same field (use $nin instead)$ne with query filter syntax$neUse these points when writing not-equal filters and expressions.
Exclude one value.
PurposeQuery vs expression.
SyntaxMust use $ne explicitly.
CriticalQuery $ne includes them.
Edge caseFor multiple exclusions.
RelatedMove on to $nin for excluding multiple values, or review $eq for equality checks.
5 people found this page helpful