The $regex operator filters documents where a string field matches a regular expression pattern. Use it for partial text search, prefix filters, email domain checks, and flexible pattern matching in find() and $match.
Regex on strings.
Pattern and flags.
Option i.
Start / end anchors.
Search, filter, validate.
Regex vs full-text.
In MongoDB, the $regex operator performs pattern matching on string fields. A document matches when the field value satisfies the regular expression. For example, { name: { $regex: "john", $options: "i" } } finds names containing “john” in any case.
$regex is a query operator used in find() filters and $match stages. It does not transform field values — it only includes or excludes documents based on whether the pattern matches.
In mongosh you can write a shorthand: { name: /^john/i }. In application drivers, prefer the explicit { $regex: "pattern", $options: "i" } form for clarity and portability.
The $regex operator is applied to a field with a pattern and optional flags:
{ field: { $regex: <pattern>, $options: <options> } }{ field: /pattern/options }
// Example:
{ name: /^admin/i }i — case insensitive matching.m — multiline mode (^ and $ match line boundaries).x — extended mode (ignore whitespace in the pattern).s — dot (.) matches newline characters.$options: "im".$regex applies to string fields (or values coerced to strings in some contexts).^ to anchor at the start and $ to anchor at the end.\. for a dot, \\ for backslash.$not to exclude pattern matches: { field: { $not: { $regex: ... } } }.$text operator and text indexes.^prefix (case-sensitive) can use indexes; .*suffix often cannot| Question | Answer |
|---|---|
| Operator type | Query operator (pattern matching) |
| Syntax | { field: { $regex: pattern, $options: flags } } |
| Common usage | find(), $match |
| Case insensitive | $options: "i" |
| Exclude pattern | { $not: { $regex: ... } } |
{
name: {
$regex: "john",
$options: "i"
}
}Substring search
{
sku: {
$regex: "^PRO-"
}
}Prefix anchor
{
email: {
$regex: "@gmail\\.com$"
}
}Suffix anchor
{
email: {
$not: {
$regex: "^test"
}
}
}Not test accounts
Search users by name, filter SKU prefixes, match email domains, exclude test accounts, and use $regex in aggregation pipelines.
Find users whose name contains a substring with case-insensitive $regex.
Suppose you have a users collection:
[
{ "_id": 1, "name": "John Smith", "email": "john@example.com" },
{ "_id": 2, "name": "Jane Johnson", "email": "jane@gmail.com" },
{ "_id": 3, "name": "Bob Wilson", "email": "test.bob@example.com" },
{ "_id": 4, "name": "johnny Lee", "email": "johnny@corp.com" }
]Find names containing “john” in any case:
db.users.find({
name: {
$regex: "john",
$options: "i"
}
})The i option makes the match case insensitive. “John”, “john”, and “JOHN” all match anywhere in the string.
Prefix filters, domain matching, exclusions, and pipeline $match.
Find products whose SKU starts with PRO-:
db.products.find({
sku: { $regex: "^PRO-" }
})
// Matches: PRO-1001, PRO-ABCD
// Does not match: XPRO-1001The ^ anchor means “starts with.” Prefix patterns like this can use indexes when case-sensitive and anchored at the beginning.
Find users with Gmail addresses (escape the dot in .com):
db.users.find({
email: {
$regex: "@gmail\\.com$",
$options: "i"
}
})$ anchors the match at the end. \. matches a literal dot. Together they target emails ending with @gmail.com.
Keep users whose email does not start with test:
db.users.find({
email: {
$not: { $regex: "^test", $options: "i" }
}
})$not negates the regex match. This excludes test.bob@example.com while keeping normal addresses.
Filter a pipeline early for names matching a pattern:
db.users.aggregate([
{
$match: {
name: { $regex: "^J", $options: "i" }
}
},
{
$project: {
name: 1,
email: 1
}
}
])
// Names starting with J (case insensitive)$regex works the same in $match as in find(). Place the filter early to reduce documents processed by later stages.
Match if either name or email contains a term:
db.users.find({
$or: [
{ name: { $regex: "john", $options: "i" } },
{ email: { $regex: "john", $options: "i" } }
]
})Combine $or with $regex when the search term might appear in different fields.
$not + $regex.$regex WorksThe regex engine compiles the pattern and options (i, m, etc.) for each query.
MongoDB checks whether the field string matches the pattern. Non-string or missing fields typically do not match.
In find() or $match, only documents that pass the regex test continue in the result set.
Pattern-based queries without exact equality on full strings.
The $regex operator brings regular expression pattern matching to MongoDB queries. Use it for substring search, prefix and suffix filters, and exclusions with $not. Remember to escape special characters and choose patterns that work with your indexes when performance matters.
For extracting matched text inside pipelines, use $regexFind. Next in the series: $regexFind.
^prefix for index-friendly prefix searches (case-sensitive)$options: "i" for case-insensitive search$match with $regex early in pipelines$text for large-scale full-text search.* on huge collections without indexes. when matching literal dots (e.g. domains)$regex with aggregation $regexFind$regexUse these points when writing pattern-matching queries in MongoDB.
Regex on strings.
PurposePattern and flags.
SyntaxStart / end anchors.
PatternsExclude matches.
Exclusion^prefix helps.
PerformanceMove on to $regexFind to extract matched substrings in pipelines, or review $not for negation.
5 people found this page helpful