Google Search Console Regex Builder

Builder is the safe default. Each line you enter is treated as literal text, regex characters are escaped automatically, and the Match behavior, Multiple terms and Case-sensitive controls determine the pattern.

• Builder: entering acme.com is interpreted literally and becomes acme\.com, so the dot does not act as a wildcard.
• Custom regex: SERPbeam uses the expression exactly as you type it. Builder-only controls such as Contains, Starts with, OR/AND and the case-sensitive checkbox no longer modify that custom expression.
• Dimension and Filter action still matter in Custom mode: Queries vs Pages changes where you use the filter, while Matches vs Doesn't match changes which rows are included.
• Switching modes does not erase the other mode: your Builder terms and Custom regex are kept separately while you move between them.

The dimension changes the context, labels, suggested sample data and the Search Console path shown beside the generated regex. It does not automatically change the regex syntax.

• Queries: use this for search terms such as brand queries, product intent, questions, locations or recurring modifiers. Example: acme pricing.
• Pages / URLs: use this for landing-page addresses, folders, locales, templates or content types. Example: https://example.com/blog/seo-audit.
• Why the distinction matters: /blog/ makes sense as a page-folder pattern, while how to usually makes sense as a query pattern, even though both are valid regex strings.

This is one of the most important controls. The generated pattern can stay identical while the report meaning flips completely.

• Matches regex: keep rows that match the expression. A brand regex therefore produces a brand-only report.
• Doesn't match: keep rows that do not match the expression. The exact same brand regex therefore becomes a non-brand report.
• Example: with pattern (?:acme|acme\.com), the query acme pricing is Included under Matches regex and Filtered out under Doesn't match.
• Why this is preferable to negative regex: Search Console already has an exclusion action, so you usually do not need unsupported negative lookarounds such as (?!...).

Search Console regex can match part of a value by default. Anchors make position significant. Assume the term is seo:

• Contains: generates seo. It can match seo tools, best seo tools or a URL containing seo anywhere.
• Starts with: generates ^seo. It matches seo tools but not best seo tools.
• Ends with: generates seo$. It matches technical seo but not seo checklist.
• Exact: generates ^seo$. Only the complete value seo matches.
• With multiple OR terms: the anchor applies to the whole group. For seo and ppc, Exact becomes ^(?:seo|ppc)$.

Enter one term per line. The combination control tells SERPbeam how those lines relate to each other.

• Any term (OR): one match is enough. Terms blog and guide become (?:blog|guide).
• Every term (AND): all terms must occur, in any order. Terms seo and audit become an RE2-safe pattern equivalent to (?:seo.*audit|audit.*seo).
• Why AND looks longer: RE2 does not support lookahead, so the builder expands possible term orders instead of generating (?=.*seo)(?=.*audit).
• AND is limited to five terms: the number of possible orders grows very quickly, so the tool stops before producing an impractically large expression.
• Exact disables AND: Exact means the whole value must equal one complete entered alternative, so the UI automatically switches to Any term and disables Every term.
• Starts with + AND: all terms must be present and one of them must occur at the beginning. Ends with + AND similarly requires one entered term at the end.

Builder mode deliberately separates ordinary text from regex syntax so you can paste real brand names, folders or phrases without manually escaping them.

• One literal term per line: blank lines are ignored and surrounding whitespace is trimmed.
• Regex characters are escaped: dots, plus signs, parentheses, brackets and similar characters are treated as text. For example, c++ is escaped rather than interpreted as quantifier syntax.
• Case-sensitive off: this follows Search Console's usual case-insensitive regex behavior. Acme, ACME and acme can all match the same generated term.
• Case-sensitive on: the builder adds the RE2 flag prefix (?-i). A pattern generated from Acme then distinguishes uppercase and lowercase.
• Custom mode: the Builder checkbox is hidden. If you intentionally need case-sensitive custom regex, include the appropriate RE2 flag in the expression yourself.

• Brand variants: switches to Builder → Queries → Matches regex → Contains → Any term. It loads example brand spellings so the output becomes a brand-inclusion pattern.
• Non-brand variants: uses the same type of brand pattern but switches the Filter action to Doesn't match. This demonstrates that non-brand segmentation is primarily an exclusion decision, not a special negative regex.
• Content folders: switches to Builder → Pages / URLs → Matches regex → Contains → Any term and loads /blog/, /guides/ and /resources/.
• Question queries: switches to Custom regex → Queries → Matches regex and loads ^(who|what|where|when|why|how)\b to demonstrate intentional regex syntax.
• Preset side effects: selecting a preset replaces the relevant example terms or custom expression, loads matching sample values and resets Builder case sensitivity to off.

• Generated filter: updates immediately as Builder controls or the Custom regex change.
• Search Console path: shows the selected dimension and whether you should choose Matches regex or Doesn't match regex when pasting the expression.
• Copy: copies only the regex pattern, not explanatory text or delimiters.
• Sample values: enter one query or URL per line. The tester evaluates up to 25 non-empty samples.
• Included: the row would remain after applying the combination of your regex and current Filter action.
• Filtered out: the row would be removed. Switching Matches to Doesn't match can therefore flip the same sample from Included to Filtered out without changing the expression.
• Use the tester before copying: include examples that should match and examples that definitely should not. This is the easiest way to catch an expression that is broader than intended.

Custom mode is for people who intentionally need regex syntax. SERPbeam scans for several common incompatibilities, but the warning system is not a complete RE2 parser.

• Lookaround: expressions such as (?=...), (?!...), (?<=...) and (?<!...) are flagged because RE2 does not support lookaround.
• Backreferences: constructs such as \1 or named backreferences are flagged.
• Atomic groups and possessive quantifiers: these are also flagged because they are outside the conservative RE2 subset used here.
• “No common conflicts detected” is not certification: it means the tool did not find the specific unsupported constructs it checks for.
• Browser testing is a convenience: generated Builder expressions use syntax shared with JavaScript and RE2, but Custom regex can differ between engines. Search Console is the final validator.