Regex Tester

How to test a regex

1. Type or paste a pattern between the two / characters, for example (?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2}).
2. Tick the flags you need. g (global) finds every match instead of stopping at the first, which most testing needs turned on.
3. Paste the text to test against. Matches are highlighted live, and the Matches panel lists each one's position, full text, and any capturing groups.
4. Switch to Replace to write a replacement ($1, $<name>, $&) and see the result before you use it in code.
5. Copy the ready-made /pattern/flags literal or new RegExp(...) call from the snippet box, or press Copy share link to send the whole thing to someone else.

If the pattern is invalid, the box outlines in red and the exact error from JavaScript's own RegExp constructor appears above the test string — the same message your code would throw.

Regex cheat sheet

The tester has a click-to-insert cheat sheet under the tool (press Regex cheat sheet to open it). The tokens you'll use most:

Groups and lookaround: (...) capturing, (?<name>...) named capturing, (?:...) non-capturing, (?=...) lookahead, (?!...) negative lookahead, (?<=...) lookbehind, (?<!...) negative lookbehind.

JavaScript regex flags explained

The tester only shows d and v as options when your browser supports them (both are recent additions to the language); g, i, m, s, u and y work everywhere.

Named vs numbered capturing groups, and how replace uses them

Matching (?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2}) (flag g) against:

Launch: 2026-09-25. Renewal: 2027-01-01.

finds 2 matches, each with three named groups: year, month and day. Replacing with $<day>/$<month>/$<year> gives:

Launch: 25/09/2026. Renewal: 01/01/2027.

The same replacement with numbered groups instead of named ones would be $3/$2/$1 — named groups just make it obvious which is which once a pattern has more than one or two. As a JS snippet:

const regex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g;
// or: const regex = new RegExp("(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})", "g");
text.replace(regex, "$<day>/$<month>/$<year>");

Common regex examples

These are starting points, not production-ready validators — the email pattern above, for instance, accepts plenty of strings that aren't deliverable addresses. For anything user-facing (email, phone, postal code), a working regex plus an actual delivery check (send a code, call an API) beats a "perfect" pattern that doesn't exist.

Why is my regex slow? (Catastrophic backtracking)

Some patterns can make the regex engine try an exponential number of ways to fail before giving up. The classic example is nested repetition, like /(a+)+$/: against a string of 28 a's followed by a character that breaks the match, the engine backtracks through every way to group those a's into one-or-more chunks before it can finally say "no match", and the work roughly doubles with each extra character.

Press Slow pattern in the tool to load exactly that example against aaaaaaaaaaaaaaaaaaaaaaaaaaaa! and watch what happens: instead of the tab freezing, matching runs in a Web Worker with a 1-second timeout. If it's hit, the worker is terminated and replaced and you see "Pattern took too long: possible catastrophic backtracking" instead of a hung page. The fix is usually to make the repeated part more specific (so there's only one way to split the input) or restructure the pattern, for example a+$ or (?>a+)+$ where the engine supports atomic groups (JavaScript doesn't, yet — a+$ is the practical fix here).

JavaScript vs PCRE vs Python regex differences

"Regex" isn't one language — it's a family, and the differences matter once you copy a pattern between them:

• Named groups: (?<name>...) in JavaScript and .NET; (?P<name>...) in Python and PCRE. Compiling (?P<year>\d+) here fails with: Invalid regular expression: /(?P<year>\d+)/: Invalid group — exactly what your JS code would throw.
• Lookbehind: supported in JavaScript (since 2018), Python and PCRE, but only fixed-width in some older PCRE builds; JavaScript's is unrestricted-width.
• POSIX classes like [[:alpha:]] work in PCRE but aren't recognized by JavaScript; use \p{L} with the u flag instead.
• Possessive quantifiers (a++) and atomic groups ((?>...)), both used in PCRE to avoid catastrophic backtracking, don't exist in JavaScript.
• Backreferences and flags mostly agree, but Python's re.VERBOSE/re.X (ignore whitespace and allow comments in the pattern) has no JavaScript equivalent.

regex101.com lets you switch the "flavor" it tests against (PCRE, JavaScript, Python, and more), which is worth using when you need to match what a non-JS backend will actually run. This tool is deliberately narrower and only tests the one flavor your browser and Node.js use.

More developer tools

• JSON formatter & validator: format, minify or validate a JSON string you pulled out with a regex.
• URL decode: decode a percent-encoded value before you write a pattern against it.
• Base64 decode: for Base64 text found inside a larger string you're testing.
• JWT decoder: read a token's JSON payload, then check individual claims with a regex.

Frequently asked questions