Regex Tester

A regular expression (regex or regexp) is a sequence of characters that defines a search pattern. Developers, data analysts, and system administrators use regex to find, validate, extract, and replace text inside strings, log files, databases, and source code. The pattern is matched against a target string by a regex engine — in this tool, the JavaScript engine built into your browser.

Regex syntax originates from formal language theory and was popularized in Unix tools like grep, sed, and awk in the 1970s. Today every major programming language — JavaScript, Python, Java, Go, Rust, PHP, Ruby — ships a regex engine, and the syntax is largely compatible across all of them.

A pattern like \b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b matches most standard email addresses. Breaking it down: \b anchors to word boundaries, [A-Za-z0-9._%+-]+ matches the local part (one or more allowed characters), @ is literal, [A-Za-z0-9.-]+ matches the domain label, \. matches a literal dot, and [A-Z|a-z]{2,} requires a TLD of two or more letters.

This online regex tester lets you write a pattern, choose flags, paste a test string, and instantly see every match highlighted in yellow along with its character index and any named or numbered capture groups. You can also specify a replacement string and preview the full substituted output — all in real time without sending data to any server.

Under the hood this tool calls new RegExp(pattern, flags) to compile your pattern, then runs the engine against your test string. When the global flag (g) is active, the engine loops via regex.exec(testString) until no further match is found, collecting each match object — its full text, start index, and any capture groups. Without the global flag, only the first match is returned.

Replacement uses the native String.prototype.replace(regex, replacement) method. Special replacement tokens such as $1, $2 refer to numbered capture groups, and $& inserts the full matched text — the same convention used by JavaScript, Java, and most PCRE-compatible engines.

If the pattern is syntactically invalid (for example an unclosed bracket [), the JavaScript engine throws a SyntaxError. This tool catches that error and displays the engine's message below the pattern field so you can diagnose the problem immediately.

Regex Flags Explained

Regex syntax can look intimidating at first, but most patterns are built from a small set of building blocks. The table below covers the constructs you will use most often when testing patterns with this tool.

The built-in pattern library in this regex tester covers the patterns developers reach for most often. Here is an expanded reference with the full patterns and when to use each one.

Email Address Validation

Pattern: \b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b

This pattern is suitable for client-side pre-validation. It allows dots, plus signs, hyphens, underscores, and percent signs in the local part — all legal per RFC 5321. It does not cover every edge case of the full RFC (such as quoted strings), but it catches the vast majority of typos.

URLs

Pattern: https?:\/\/[^\s]+

Matches any URL starting with http:// or https:// and running until the next whitespace. Use this to extract links from plain text logs or messages.

US Phone Numbers

Pattern: \(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}

Matches formats like (555) 867-5309, 555-867-5309, and 5558675309. The \(? and \)? make the area code parentheses optional.

IP Addresses

Pattern: \b(?:\d{1,3}\.){3}\d{1,3}\b

Matches any four-octet numeric sequence separated by dots. Note this does not validate that each octet is ≤ 255 — further validation in application code is recommended.

ISO Dates

Pattern: \d{4}-\d{2}-\d{2}

Matches YYYY-MM-DD format as used in databases, JSON APIs, and log files. Combine with ^ and $ anchors if the date must occupy its own field.

Hex Color Codes

Pattern: #[0-9A-Fa-f]{6}\b

Matches six-digit CSS hex colors. Extend to #[0-9A-Fa-f]{3,8}\b to also match three-digit shorthand and eight-digit RGBA variants.

The replacement feature in this tool calls JavaScript's String.prototype.replace(regex, replacement). This is more powerful than a simple find-and-replace because the replacement string can reference parts of each match through special tokens.

• $& — inserts the entire matched substring.
• $1, $2, … — inserts the text captured by the first, second, … capture group in the pattern.
• $` — inserts the portion of the string before the match.
• $' — inserts the portion of the string after the match.

For example, if your pattern is (\d{4})-(\d{2})-(\d{2}) and your replacement is $2/$3/$1, then the date 2025-06-07 becomes 06/07/2025 — converting from ISO format to US format in a single substitution.

When the global flag is active, every match in the test string is replaced. Without it, only the first match is substituted. This mirrors how JavaScript's String.replace behaves natively.

Capture groups are also shown individually in the Match Details panel. Each match card lists the captured substrings as $1, $2, and so on. This is invaluable when debugging complex patterns that extract structured data — for example, parsing dates, parsing log lines, or splitting a full name into first and last parts.