Regex Tester
Test regular expressions with live match highlighting.
By Syed Mubashir Ali · Last updated
When to use a regex tester
Regular expressions are compact, which makes them easy to get subtly wrong: a missing anchor matches too much, a greedy .* swallows half the line, a forgotten flag finds one match instead of fifty. Testing against real sample text before the pattern goes into code, a search-and-replace or a validation rule catches those mistakes while they're cheap.
Paste a few lines of the real data, including the awkward cases, such as an email with a plus sign or a date with single-digit months, and refine the pattern until exactly the right parts light up. Use the capture groups list to check that each group grabs what your code expects. Because this tester uses the browser's own JavaScript engine, a pattern that works here behaves the same in JavaScript and TypeScript code, Node.js, and most browser-based tools. Everything runs locally, so you can test against log files or customer data without uploading them.
Common regex mistakes this tester catches
Forgetting the global flag
The single most common surprise: your pattern works, but only the first match is found. JavaScript's match() and replace() stop after one match unless the g flag is set. The tester flags this explicitly when matches exist but g is off.
Greedy quantifiers eating too much
A pattern like <.*> intended to match one HTML tag will match from the first < to the last > on the line. Watching the highlight stretch across your test string makes the problem obvious; switching to <.*?> (lazy) fixes it. Seeing it visually beats reading about it.
Catastrophic backtracking
Nested quantifiers like (a+)+$ can take exponential time on certain inputs: the classic ReDoS pattern. The tester's worker thread times out after a second and tells you the pattern is too slow, rather than freezing your tab. If you see that warning, rewrite with atomic groups or a simpler structure.
How to Use Regex Tester
- 1Enter your regular expression pattern in the pattern field, without the surrounding slashes.
- 2Tick the flags you need: g (global, every match), i (case-insensitive), m (multiline), s (dot-all) and u (unicode).
- 3Paste or type your test string, up to 20,000 characters.
- 4Matches are highlighted in the text as you type, and the match count updates live.
- 5Check the match list for each match's value, position and capture groups ($1, $2… and any named groups), or copy all matches.
- 6Use the Find & Replace panel to preview replacements with $1, $2, $& group references before using them in code.
Frequently Asked Questions
What regex flavour is used?
JavaScript's built-in RegExp engine, the same one in Node.js and every modern browser. That's PCRE-like but not identical: lookbehind (?<=…), named groups (?<name>…) and Unicode property escapes \p{L} (with the u flag) all work, while possessive quantifiers and recursion don't.
How do I see capture groups?
Wrap part of the pattern in parentheses and each match in the list shows what that group captured, as $1, $2 and so on, the same numbers you'd use in a replacement. Named groups such as (?<year>\d{4}) are listed by name. For example, (\w+)@(\w+)\.com on 'ana@example.com' gives $1 'ana' and $2 'example'.
Why does it only find one match?
Without the g flag, a JavaScript regex stops at the first match. Tick g to find every match in the text; the tester reminds you when it's off.
Why are some patterns marked invalid?
If your pattern has a syntax error, such as an unmatched bracket or an invalid escape, the tester shows the error message from the JavaScript engine instead of matches, so you can see what to fix.
Can I test multiline patterns?
Yes. Turn on m so ^ and $ match at the start and end of every line, not just the whole text, and s (dot-all) if you need . to match line breaks too.
What happens with a pattern that never finishes?
Some patterns, like (a+)+$ on a long run of a's, take exponentially long. The tester runs your pattern on a separate worker thread and stops it after a second, so the page stays responsive and you're told the pattern is too slow.
How does the Find & Replace preview work?
Type a replacement string using $1, $2 for capture groups, $& for the whole match, and $$ for a literal dollar sign. The preview shows the result live. Enable the g flag to replace every match instead of just the first: the same behaviour as JavaScript's String.replace.
Can I use the pattern library entries in my own code?
Yes. Select a pattern from the library to load it into the pattern field, then copy it. The patterns are standard JavaScript regex. They work identically in Node.js, browsers, and TypeScript. Just remember the credit card pattern is shape-only and shouldn't be used for real validation.
About Regex Tester
Regular expressions are one of the most powerful (and tricky) tools in a developer's toolkit. Our Regex Tester gives you a live environment to build, test, and debug patterns without switching between browser consoles or external tools.
As you type, the pattern is compiled in real time and applied to your test string. Every match is highlighted inline and listed below with its value, character index and capture groups. Invalid patterns display the engine's error message immediately, so you know exactly what to fix.
The pattern library covers the patterns developers reach for most: emails, URLs, phone numbers, IP addresses, dates, hex colours. Each loads with a single click and auto-enables the global flag. The Find & Replace panel goes further: previewing substitutions with capture group references before you commit them to code or a bulk rename.
Because the tester uses your browser's actual JavaScript engine (in a worker thread, so catastrophic patterns can't freeze the page), behaviour here matches Node.js and browser code exactly. There's no translation layer and no surprises when you copy a working pattern into production.