The $regexMatch operator checks whether a regular expression pattern appears in a string and returns true or false. Use it for validation, filtering, and conditional logic — without extracting match text.
true or false.
input + regex.
Filter in pipelines.
Branch on pattern.
Email, SKU, format.
Check vs extract.
In MongoDB’s aggregation framework, the $regexMatch operator tests whether a regular expression pattern matches anywhere in a string. The result is a boolean: true if at least one match exists, false otherwise.
Unlike $regexFind and $regexFindAll, $regexMatch does not return matched text, positions, or capture groups. It answers a simple question: “Does this pattern appear in the string?”
Use $regexMatch inside the aggregation $match stage to filter documents by a string pattern. Use $project to add a validation flag like isValidEmail: true.
The $regexMatch operator shares the same argument shape as $regexFind:
{
$regexMatch: {
input: <string expression>,
regex: <pattern expression>,
options: <options expression> // optional
}
}true // pattern found in input
false // no match, or input is nullinput — the string to test (field path or expression).regex — the pattern string or BSON regex literal.options — optional flags like "i" (case insensitive).true when the pattern matches at least once.false when there is no match or when input is null.$match, $project, $addFields, $set, or $cond (MongoDB 4.2+).| Question | Answer |
|---|---|
| Operator type | Aggregation expression operator (string / regex) |
| Syntax | { $regexMatch: { input, regex, options? } } |
| Output | true or false |
| Extracts text? | No — boolean only |
| Common stages | $match, $project, $cond |
{
$regexMatch: {
input: "$email",
regex: "@"
}
}Contains @
{
options: "i"
}Ignore case
$match: {
$expr: { $regexMatch: ... }
}Filter docs
falsePattern absent
Validate email format, filter posts with hashtags, branch with $cond, and run case-insensitive checks using $regexMatch.
Add a boolean hasEmailFormat field with $regexMatch.
Suppose you have a users collection:
[
{
"_id": 1,
"name": "Alice",
"contact": "alice@example.com"
},
{
"_id": 2,
"name": "Bob",
"contact": "bob-phone-only"
},
{
"_id": 3,
"name": "Carol",
"bio": "MongoDB fan #database #nosql"
}
]Test whether contact looks like an email address:
db.users.aggregate([
{
$project: {
name: 1,
contact: 1,
hasEmailFormat: {
$regexMatch: {
input: "$contact",
regex: "^[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}$"
}
}
}
}
])The pattern checks for user@domain.tld structure. $regexMatch returns true or false only — no matched substring is returned.
Filter documents in $match and branch with $cond.
Keep only documents whose bio contains a hashtag:
db.users.aggregate([
{
$match: {
$expr: {
$regexMatch: {
input: "$bio",
regex: "#\\w+"
}
}
}
},
{
$project: { name: 1, bio: 1 }
}
])
// Returns Carol onlyWrap $regexMatch in $expr inside $match so MongoDB evaluates it as an aggregation expression, not a query operator.
Assign a label based on whether the contact field is email-like:
db.users.aggregate([
{
$project: {
name: 1,
contact: 1,
contactType: {
$cond: [
{
$regexMatch: {
input: "$contact",
regex: "@"
}
},
"email",
"other"
]
}
}
}
])
// Alice: "email", Bob: "other"$cond uses the boolean from $regexMatch as its condition. This is cleaner than comparing $regexFind results to null when you only need yes/no.
Test whether a SKU starts with PRO regardless of case:
db.products.aggregate([
{
$project: {
sku: 1,
isProLine: {
$regexMatch: {
input: "$sku",
regex: "^PRO-",
options: "i"
}
}
}
}
])
// "pro-1001" → true
// "DEV-2002" → falseThe i option makes the pattern case insensitive. ^PRO- anchors the match to the start of the string.
Flag contacts that look like US phone numbers:
db.users.aggregate([
{
$project: {
name: 1,
contact: 1,
looksLikePhone: {
$regexMatch: {
input: "$contact",
regex: "^\\d{3}-\\d{3}-\\d{4}$"
}
}
}
}
])
// "555-123-4567" → true
// "alice@example.com" → false\d{3}-\d{3}-\d{4} matches a simple ###-###-#### format. Use $regexMatch for quick format checks; use $regexFind if you need to extract the digits.
$match + $expr to keep documents whose fields match a regex.$cond based on pattern presence.$regexMatch WorksThe pipeline resolves the string (input) and compiles the pattern (regex) with any options.
MongoDB scans the string for at least one substring that satisfies the pattern. It stops as soon as a match is found.
true if a match exists; false if not. No match text or position is included.
Use in $match, $cond, or store as a validation flag.
The $regexMatch operator tests whether a regular expression pattern appears in a string and returns true or false. It is the right choice when you need validation or filtering without extracting match details.
Pair it with $match and $expr to filter documents, or with $cond for branching. For matched text, use $regexFind or $regexFindAll. Next in the series: $reverseArray.
$regexMatch when you only need true/false$expr when using inside aggregation $matchoptions: "i" for case-insensitive checks$regexFind when you need the matched substringidx from $regexMatch$regexMatch without $expr in aggregation $match$regexFind to null when a boolean suffices$regexMatch with query $regex$regexMatchUse these points when testing patterns in aggregation pipelines.
true or false.
PurposeSame shape as $regexFind.
SyntaxCheck only.
OutputFilter documents.
Filteringnull input or no match.
Edge caseMove on to $reverseArray for array manipulation, or review $regexFindAll to extract every match.
5 people found this page helpful