The regex tester is a live playground for regular expressions: put your pattern in the query bar and your sample text in the input pane, and every match is highlighted in structured JSON as you type. It's the fastest way to confirm a pattern does what you think before you paste it into code.
Your pattern and your test text never leave the page — everything runs in your browser with no upload and no account. That makes it safe to try patterns against real log lines, user data or API payloads without sending them to a server.
It's built for developers writing validation rules, log parsers and find-and-replace patterns, and for anyone learning regex who wants immediate, readable feedback on what each match captured.
Type your regular expression in the query bar and paste the text you want to test in the input area. You can write a bare pattern like ([a-z]+)@(\w+), or a full /pattern/flags literal like /error/gi — inline flags in the literal are merged with the toggles below.
Global (g) finds every match instead of just the first; ignore case (i) makes the pattern case-insensitive; multiline (m) lets ^ and $ match at line breaks; dot-all (s) lets . match newlines. Toggle them on and the results update instantly.
Each match reports the matched text, its index in the input, the numbered captures array, and a groups object for any named groups like (?<user>...). matchCount gives the total, so you can see at a glance how many times your pattern hit.
Parentheses create capture groups, returned in order in captures. Add a name with (?<name>...) and it also appears under groups, keyed by name — ideal for pulling structured fields such as user and host out of an email or a date out of a log line.
Paste your test text into the input pane, type your pattern in the query bar, and matches appear immediately as structured JSON. It's completely free, needs no account, and runs entirely in your browser so nothing is uploaded.
Write (?<name>...) around the part you want to capture, for example (?<user>[a-z]+)@(?<host>\w+). Each match's groups object then contains keys like user and host with their captured values, alongside the numbered captures array.
That's usually catastrophic backtracking: nested or overlapping quantifiers like (a+)+ or (.*)* force the engine to try an exponential number of ways to match, especially on input that almost-but-doesn't match. Make quantifiers more specific, avoid nesting them, and prefer character classes over broad . patterns. This tester caps output at 1000 matches to keep results readable, but that cap cannot prevent catastrophic backtracking itself — a pathological pattern can still hang the tab, so simplify the pattern if it does.
Yes. Both a bare pattern and a /.../ literal work. If the literal carries inline flags, such as /foo/gi, those flags are merged with the g/i/m/s toggles, so you don't have to re-enter them.
No. The pattern and the text are matched locally in your browser using the native JavaScript regex engine. Nothing is uploaded, logged or stored, so it's safe for production data.