Regex Tester & Debugger

Test and debug regular expressions in real-time. See matches highlighted, capture groups extracted, and get explanations. Free online regex tester.

Last updated: June 1, 2026

Regular Expression

//g

Global (g)Case Insensitive (i)Multiline (m)DotAll (s)

Test String

What is Regex Tester?

A regex (regular expression) tester is a development tool that lets you write, test, and debug regular expressions against sample text in real-time. Regular expressions are powerful pattern-matching sequences used in every programming language to search, validate, extract, and transform text. They can match email addresses, phone numbers, URLs, dates, IP addresses, and virtually any text pattern. However, regex syntax is notoriously difficult to write correctly — a single misplaced character can change the meaning entirely. This tool provides instant visual feedback showing exactly what your pattern matches, which capture groups are extracted, and where errors occur, making regex development dramatically faster than trial-and-error in code.

How It Works

Enter your regular expression pattern in the pattern field and your test string in the text area. The tool compiles your regex using JavaScript's RegExp engine and executes it against your text in real-time. Matches are highlighted directly in the text with distinct colors for different capture groups. The tool displays all match details: the full match, captured groups (numbered and named), match positions (start/end indices), and the total number of matches found. If your regex has a syntax error, the tool shows a descriptive error message explaining what went wrong. You can toggle flags (global, case-insensitive, multiline, dotAll, unicode, sticky) to modify matching behavior.

Examples

Email pattern matching

Input

Pattern: [\w.]+@[\w]+\.[a-z]{2,}
Text: Contact us at hello@example.com or support@test.org

Output

Match 1: hello@example.com (pos 17-34)
Match 2: support@test.org (pos 38-53)

Tips & Best Practices

💡

Use non-greedy quantifiers (.*?) when you want to match the shortest possible string, not the longest.

💡

Named capture groups (?<name>...) make regex more readable than numbered groups, especially in complex patterns.

💡

The ^ anchor matches start-of-line in multiline mode (m flag) but start-of-string without it. This is a common source of bugs.

Common Use Cases

•Validating form input patterns for email addresses, phone numbers, and postal codes
•Extracting structured data from unstructured text like log files, HTML, and CSV data
•Building search-and-replace patterns for code refactoring across large codebases
•Creating URL routing patterns for web frameworks like Express, Next.js, and Django
•Writing input sanitization rules to strip dangerous characters and prevent injection attacks
•Parsing and transforming date formats, currency values, and other structured text patterns

Frequently Asked Questions

What regex flavors are supported?▼

This tool uses JavaScript's built-in RegExp engine (ECMAScript). It supports most common patterns including lookaheads (?=), lookbehinds (?<=), named groups (?<name>), non-greedy quantifiers (*?, +?), and character classes.

Can I see capture groups?▼

Yes, all capture groups are highlighted with distinct colors and listed separately with their matched values and positions. Named groups display their names alongside the captured text.

What flags are supported?▼

All standard JavaScript regex flags: g (global - find all matches), i (case-insensitive), m (multiline - ^ and $ match line boundaries), s (dotAll - . matches newlines), u (unicode), and y (sticky - match from lastIndex).

Why isn't my regex matching?▼

Common issues: forgetting the 'g' flag for multiple matches, not escaping special characters (. * + ? need backslashes for literal matching), or incorrect anchoring. The tool's error highlighting helps identify the exact issue.

Can I test regex for other languages?▼

JavaScript regex is compatible with most languages for common patterns. However, some features differ — Python has (?P<name>) syntax, Java requires double-escaping. Test language-specific features in their respective environments.

What's the difference between .* and .*?▼

.* is greedy — it matches as much text as possible. .*? is non-greedy (lazy) — it matches as little as possible. This distinction matters when you have multiple potential match endpoints in your text.