Regex Tester

The dot (.) is a special metacharacter that matches any single character (except newlines by default). If you want to match a literal period/dot character, you need to escape it with a backslash: \. For example, to match "example.com", use the pattern example\.com instead of example.com which would match "exampleXcom" where X is any character.

Use curly braces with numbers to specify exact counts or ranges. For example: \d{3} matches exactly 3 digits, \d{3,5} matches 3 to 5 digits, and \d{3,} matches 3 or more digits. This is more precise than using + (one or more) or * (zero or more) quantifiers.

Capture groups are portions of a regex pattern enclosed in parentheses ( ) that "capture" the matched text for later use. For example, in the pattern (\d{3})-(\d{4}), the two groups capture the area code and number separately from a phone number like "555-1234". You can reference these groups in replacements using $1, $2, etc., or access them programmatically in your code.

By default, quantifiers like *, +, and {n,m} are greedy—they match as much text as possible. For example, .* in the string "<div>content</div>" matches the entire string. Adding a ? after the quantifier makes it lazy: .*? matches as little as possible, so it would match just "<div>" first. Use lazy matching when you want to match the shortest possible string.

Use \b to match a position between a word character (\w) and a non-word character, or at the start/end of a string. For example, \bcat\b matches "cat" as a whole word but not "category" or "scat". Word boundaries are essential for matching complete words without accidentally matching parts of longer words.

Regular expressions are fundamentally limited and cannot fully parse nested or recursive structures like HTML, XML, or balanced parentheses. While you can write regex patterns to match simple, non-nested cases, attempting to match properly nested structures will fail or produce incorrect results. For parsing HTML or XML, use dedicated parsing libraries like DOMParser, BeautifulSoup, or xml2js instead.

If you're working with Unicode characters (emoji, accented letters, non-Latin scripts), enable the Unicode flag (u). Without it, character classes like \w or . may not work correctly with Unicode. For example, use /[\u0400-\u04FF]+/u to match Cyrillic characters, or /\p{Emoji}/u to match emoji when supported by your regex engine.

To match literal special characters like . * + ? ^ $ [ ] { } ( ) | \, you need to escape them with a backslash. For example, to match "example.com", use example\.com. To match a backslash itself, use \\. If you're dynamically building regex patterns from user input, use a function to escape all special characters to prevent regex injection vulnerabilities.

Lookaheads and lookbehinds are zero-width assertions that check for patterns without including them in the match. Positive lookahead (?=...) ensures a pattern follows, negative lookahead (?!...) ensures it doesn't. For example, \d+(?= dollars) matches numbers followed by " dollars" but doesn't include " dollars" in the match. Lookbehinds work similarly: (?<=...) checks what comes before, (?<!...) checks what doesn't come before.

Yes, absolutely. All regex testing and matching happens entirely in your browser using JavaScript. No patterns or test strings are ever sent to our servers or any third party. You can even use this tool offline once the page is loaded. Your privacy and data security are completely protected. This tool is safe to use with sensitive data or proprietary patterns.