Which programming languages is this compatible with?

This tool runs in your browser using JavaScript's regex engine. The code generator converts flags into PHP modifiers and Python re constants, and rewrites named groups as (?P ) for Python. Advanced features such as lookbehinds or Unicode property escapes aren't available in every language.

Regex Tester Online: Test, Explain & Debug Regular Expressions

Q: Why does it only match the first occurrence?

By default, Regex stops after the first match. To find all occurrences in the text, you need to add the 'g' (Global) flag in the flags input box.

Q: What are 'Capture Groups'?

Capture groups are parts of the pattern enclosed in parentheses ( ). They allow you to extract specific parts of the matched string (like extracting just the domain from an email) and reuse them with $1, $2 variables.

Q: Why does test() return true, then false, with the g flag?

With the g or y flag, a JavaScript RegExp remembers where the last match ended (lastIndex) and starts the next search from there, so calling test() repeatedly on the same object can alternate between true and false. This tool creates a fresh regex for every test, so results don't change. In your own code, drop the g flag or reset regex.lastIndex = 0 before testing.

Q: Can a regex freeze the page?

Patterns with nested quantifiers such as (a+)+ can trigger catastrophic backtracking and take an extremely long time on some inputs. This tool runs matching in a Web Worker and stops it after 1.5 seconds, so the page stays responsive.

Regular Expression

/ /

Unit Tests

*Checks if each line matches as expected.

Real-time Check

{{ sandboxMatches.length }} {{ sandboxMatches.length === 1 ? 'match' : 'matches' }} found ({{ zeroWidthCount }} zero-length) (showing the first 5,000):

Structure Visualizer

Enter a regex pattern to see its structure.

Explanation

Explanation will appear here.

Capture Groups ($1, $2...)

#	Content
${{ i + 1 }}	{{ g }}

Click to insert:

Email Address

US Zip Code

US Phone No.

Date (YYYY-MM-DD)

URL

Strong Password

JavaScript

{{ codeSnippets.js }}

PHP

{{ codeSnippets.php }}

Python

{{ codeSnippets.python }}

{{ note }}

Matching uses the JavaScript regex engine. Some syntax, such as lookbehinds or Unicode property escapes, isn't supported in every language.

Common Tokens

Related tools

Base64 Converter Dead Pixel Checker Input Device Tester

Regex Cheat Sheet & Basic Rules

A quick reference for common regular expression metacharacters and syntax. Bookmark this for your development needs.

1. Special Characters (Metacharacters)

Symbol	Meaning	Example
.	Any character (except newline)	`a.c` → abc, aXc
\d	Digit (0-9)	`\d{3}` → 123
\w	Word character [a-zA-Z0-9_]	`\w+` → user_id
\s	Whitespace (space, tab, newline)
[ ]	Character class (any of these)	`[abc]` → a, b, or c
[^ ]	Negation (not these)	`[^0-9]` → Non-digit
\|	OR (Alternative)	`jpg\|png`
\	Escape character	`\.` → Literal dot

2. Quantifiers (Repetition)

Symbol	Meaning	Example
*	0 or more times	`a*` → (empty), a, aa...
+	1 or more times	`a+` → a, aa, aaa...
?	0 or 1 time (Optional)	`https?` → http, https
{n}	Exactly n times	`\d{4}` → 2025
{n,}	n or more times	`\d{8,}` → 8+ digits
{n,m}	Between n and m times	`\d{2,4}` → 2 to 4 digits

3. Anchors (Position)

Symbol	Meaning	Example
^	Start of line/string	`^http` → Starts with http
$	End of line/string	`jpg$` → Ends with jpg

4. Flags (Options)

Options specified after the regex pattern (e.g., /pattern/g). You can input these in the small box to the right.

Flag	Name	Behavior
g	Global	Find all matches rather than stopping after the first match.
i	Ignore Case	Case-insensitive search (matches both 'A' and 'a').
m	Multiline	^ and $ match start/end of each line, not just the whole string.

Useful Regex Snippets (Top 10)

Use Case	Pattern	Note
Email	`^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$`	Basic validation
US Zip Code	`^\d{5}(-\d{4})?$`	5 digits or 5+4
Phone (US)	`^$?\d{3}$?[-.\s]?\d{3}[-.\s]?\d{4}$`	Allows (123) 456-7890
Date (ISO)	`^\d{4}-\d{2}-\d{2}$`	YYYY-MM-DD
URL	`https?://[\w!?/+\-_~=;.,*&@#$%()'[\]]+`	Starts with http/s
Password (Strong)	`^(?=.[a-z])(?=.[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$`	8+ chars, upper, lower, digit
Username	`^[a-zA-Z0-9_-]{3,16}$`	Alphanumeric, 3-16 chars
Integer	`^\d+$`	Numbers only
Hex Color	`^#([a-fA-F0-9]{6}\|[a-fA-F0-9]{3})$`	#ffffff or #fff
Slug	`^[a-z0-9]+(?:-[a-z0-9]+)*$`	URL-friendly text

FAQ

Why does it only match the first occurrence?

By default, Regex stops searching after finding the first match. To find all instances in the text, you must enable the Global flag. Enter g in the small input box on the right side of the main regex input.

What are "Capture Groups"?

Capture groups are parts of your pattern enclosed in parentheses ( ). They allow you to isolate and extract specific parts of the matched text.

For example, in the pattern (\d{4})-(\d{2}), $1 would contain the year and $2 would contain the month. This is useful for data extraction and replacement.

Is the code valid for all languages?

This tool runs in the browser and uses the JavaScript regex engine. While basic syntax (like \d, +, *) is standard across PHP, Python, and Java, some advanced features (like lookbehinds) may differ.

The code generator converts g to preg_match_all and other flags to modifiers for PHP, and rewrites named groups (?<name>) as (?P<name>) and flags as re.IGNORECASE and friends for Python. Always double-check the documentation for your target language.

Why does test() return true, then false, with the g flag?

With the g (or y) flag, a JavaScript RegExp remembers where the last match ended in lastIndex and starts the next search from there. Running /a/g.test('a') three times on the same object returns true → false → true.

This tool creates a fresh regex for every unit test, so the results never depend on the order you run them. In your own code, drop the g flag for simple checks or set regex.lastIndex = 0 before calling test().

Can a regex freeze the page?

Patterns with nested quantifiers such as (a+)+ can trigger catastrophic backtracking: on a string that almost matches, the work grows exponentially.

This tool runs matching in a separate thread (a Web Worker) and stops it after 1.5 seconds, then shows a warning so you can rewrite the pattern. The page stays responsive the whole time.

Regex Tester & Visualizer