Regex Tester

Type a pattern in the box above, paste some text under it, and every match lights up as you type. This regex tester lists each match with its numbered and named groups and their positions, replaces and splits text, checks a list line by line, and explains the pattern in plain English, piece by piece.

It also turns common Python, PCRE, Java, .NET and Go syntax into JavaScript before testing, offers ready-made patterns to start from, and writes the code for six languages. Everything runs in your browser and nothing is uploaded.

A regex tester online should work the moment the page loads, and this one does: the first pattern in the library, an email address finder, is already filled in with sample text, so you see what a result looks like before you type anything. There is no account, no install and no button to press. Results update about a tenth of a second after you stop typing.

Matching happens in a background worker, a separate thread of your browser. That keeps the page responsive with long texts, and it lets the page stop a pattern that runs longer than 1.5 seconds. A pattern that would freeze a normal page simply returns a message here, and you can fix it and carry on.

The Test string box takes whatever you paste: log lines, CSV rows, HTML, source code or ordinary prose. Long inputs are fine, though the table lists the first 500 matches and the counter stops at 5,000, shown as 5000+.

Parentheses in a pattern capture the text they match, and seeing those captures is often the whole point of testing. In Match mode the table on the right lists every match in four columns: its number, the matched text, its position as start–end character offsets, and its groups.

Numbered groups appear as $1, $2 and so on. Named groups, written (?<year>\d{4}) in JavaScript, show their name instead, such as year: 2026. A group that took no part in the match shows a dash, which is different from a group that matched an empty string. Turn on the d flag to also see where each group starts, written as @ followed by the offset.

When you want a regex tester with capture groups you can take elsewhere, press CSV above the table. The file regex-matches.csv has one row per match with the number, start, end, match and one column per group, and it opens cleanly in Excel or Google Sheets. Non-capturing groups (?:…) group without capturing, so they add no column.

Positions count JavaScript characters, which are UTF-16 code units, so an emoji or a rare symbol counts as two. That is the same count your JavaScript code sees through match.index.

Switch the mode to Replace and a replacement box appears. It starts with [$&], which wraps every match in square brackets, so you can see at once what will change. The result appears on the right with a Copy button.

The replacement uses JavaScript syntax: $1 to $99 insert numbered groups, $<name> inserts a named group, $& inserts the whole match, $` the text before it, $' the text after it, and $$ a literal dollar sign. For example, the pattern (\d{4})-(\d{2})-(\d{2}) with the replacement $3/$2/$1 turns 2026-10-21 into 21/10/2026.

Without the g flag only the first match is replaced, and the page reminds you of this under the result. A regex tester with replace preview is the safest way to try a bulk edit before you run it in an editor or a script, because you see the full output first. Other languages write group references differently; the flavour table further down lists them.

Split cuts the test string wherever the pattern matches and lists the parts, numbered and in quotes, so empty parts and stray spaces are easy to spot. A pattern such as \s*,\s* splits a comma list and trims the spaces around each item. If the pattern has capture groups, the captured separators appear in the list as well, which is how JavaScript's split works. Up to 1,000 parts are shown.

Test each line checks every line of the test string on its own and marks it with a tick or a cross, with a total such as 7 of 9 lines match. This is the mode for validation patterns that use ^ and $, like a postcode or a username rule: paste good and bad examples, one per line, and see at a glance which ones pass. The g flag is ignored here, because each line gets a single yes or no.

When a pattern does not behave, three things help: knowing what each part means, seeing exactly what matched, and knowing whether it is slow. The card What this pattern means splits the pattern into pieces and explains each one in plain English, indented to show nesting. A character class becomes a list of what it allows, a quantifier is described as one or more times or between 2 and 5 times, and a lookahead is labelled as not part of the match.

The match table then shows each hit with its position and groups, and the counter shows how many milliseconds the run took. A time that jumps from 1 ms to hundreds of milliseconds as you add text is an early warning of backtracking trouble.

To be clear about what it is: this regex tester and debugger combination explains and measures, but it does not step through the engine's backtracking one move at a time. For most bugs, such as a missing escape, a greedy .* that eats too much, or a forgotten m flag, the explanation and the table point to the cause quickly.

Every test on this page runs on your browser's own JavaScript engine through new RegExp. That makes it a true regex tester javascript developers can rely on: what matches here matches in the same browser in your code, including named groups, lookbehind of any length, the s and d flags, and \p{…} Unicode classes with the u flag.

Current browsers have supported these features for years. Node.js uses the same V8 engine as Chrome, so results there match Chrome's. The v flag is not offered on this page.

Mind the backslashes when you move a pattern into code. In a literal such as /\d+/ they stay single, but inside a string each one is doubled: new RegExp("\\d+"). The JavaScript tab under Use it in code writes the literal form with any / escaped, plus a matchAll loop and a replace line.

Java's java.util.regex is close to JavaScript for everyday patterns. Choose Java as the flavour and the converter handles the extras it knows: atomic groups (?>…) and possessive quantifiers such as a++ are approximated as normal groups and greedy quantifiers, \Q…\E literal text is escaped, \h becomes [ \t], and \A and \z become anchors. A note marks each approximation, because atomic and possessive forms stop backtracking and the plain versions do not, so a few patterns can match differently.

In Java source every backslash is doubled, so \d is written "\\d". The Java tab writes Pattern.compile with the pattern already escaped as a Java string and adds Pattern.CASE_INSENSITIVE when the i flag is on; add Pattern.MULTILINE or Pattern.DOTALL yourself for m and s. Java needs lookbehind with a bounded length, so a lookbehind with + or * that works here can fail to compile there.

As a regex tester for java code it gets you to the right pattern quickly. Run the final version once in your own project to confirm.

Choose .NET (C#) as the flavour for patterns from C#, VB.NET or PowerShell. .NET writes named groups as (?<name>…), the same as JavaScript, so most patterns need no change at all. Atomic groups, \A, \z and leading inline flags are converted with notes, as for Java.

.NET has two features with no JavaScript equivalent: balancing groups such as (?<open-close>…), used to match nested brackets, and conditionals (?(…)…). The note says so instead of guessing, and those patterns cannot be tested here. Like JavaScript, .NET allows lookbehind of any length, but its \d matches digits from every script unless you use RegexOptions.ECMAScript.

The C# tab writes a verbatim @"…" string, so backslashes stay single, with RegexOptions.IgnoreCase for the i flag; add RegexOptions.Multiline or RegexOptions.Singleline for m and s. Used as a regex tester for c# work, it is quickest for checking groups and replacements before you write the code.

PCRE (PHP) covers preg_match and preg_replace patterns. Paste the part between the delimiters, without the slashes and modifiers, and set flags with the buttons. Converted PCRE extras: \h becomes [ \t], POSIX classes such as [[:alpha:]] and [[:digit:]] are expanded, \Q…\E is escaped, atomic groups and possessive quantifiers are approximated, and a leading (?i) or (?s) becomes a flag. Recursion such as (?R) and conditionals cannot be converted, and the note says so. The PHP tab writes preg_match_all and preg_replace with the u modifier added, so UTF-8 text is handled properly.

Go uses the RE2 engine, which never backtracks and so never hangs, but it leaves out lookahead, lookbehind and backreferences such as \1. This page will happily test those, so a pattern can work here and then fail in regexp.MustCompile. Keep Go patterns to groups, classes, alternation and quantifiers. Go supports (?P<name>…) named groups, which the converter rewrites for testing, and the Go tab adds (?i) when you use the i flag.

Under the tool, Use it in code has six tabs: JavaScript, Python, PHP, Java, C# and Go. Each one writes your current pattern, in its converted JavaScript form, the way that language expects it, with the escaping done for you: a literal in JavaScript, a raw string in Python, a quoted pattern with the u modifier in PHP, an escaped string in Java, a verbatim string in C# and a backquoted string in Go.

The snippets carry over the flags each language has a simple equivalent for, and show a typical use: finding all matches, printing each one or replacing with group 1. Treat them as a starting point, check the flags, and run them once with real data. A tool such as the JSON Formatter or the Diff Checker helps when you compare the output before and after a change.

Press Share and a link is copied to your clipboard. It holds the pattern, the flags and up to 1,500 characters of the test string, and opening it fills them in again. The flavour menu is not stored, so pick it again for a Python or Java pattern.

Everything sits after the # in the link. Browsers do not send that part to the server, so the pattern stays out of server logs, but anyone who has the link can read it. Do not share links that contain passwords, tokens or personal data.

The page is a regex tester free for everyone to use, with no sign-up. Your pattern and test text are processed by a worker inside your own browser and are never uploaded, so it is fine to paste real logs or data while you work.

Only a share link takes your pattern elsewhere, and only when you press Share and send the link to someone. If a run is stopped for taking too long, nothing is lost: change the pattern and it runs again.

Once the pattern works, copy the snippet for your language and test it once in your project. For related jobs, the JSON Formatter tidies API responses you want to search, the Diff Checker compares text before and after a replace, and the Hash Generator makes checksums of the cleaned file.