RegEx Tester & Debugger

▸ Regular Expression Pattern

/ /

g - Global i - Case Insensitive m - Multiline s - Dotall u - Unicode

Enter a pattern and test string to begin 0 matches

▸ Test String

▸ Match Results

▸ Match Details

No matches yet. Enter a pattern and test string above.

▸ Pattern Explanation

Enter a pattern above to see an explanation

▸ Replace/Substitution

Enable Replace Mode

▸ Quick Reference

⚠ JavaScript RegEx Engine - This tool uses JavaScript's native regex engine. Some features may differ from PCRE, Python, or other regex flavors (e.g., no lookbehinds in older browsers, different Unicode handling).

Character Classes

\d - Digit (0-9)
\w - Word character (a-z, A-Z, 0-9, _)
\s - Whitespace
. - Any character (except newline)
[abc] - Any of a, b, or c
[^abc] - Not a, b, or c

Quantifiers

* - 0 or more
+ - 1 or more
? - 0 or 1
{n} - Exactly n times
{n,} - n or more times
{n,m} - Between n and m times

Anchors

^ - Start of string
$ - End of string
\b - Word boundary
\B - Not word boundary

Groups

(abc) - Capture group
(?:abc) - Non-capturing group
a|b - Alternation (a or b)
(?=abc) - Positive lookahead
(?!abc) - Negative lookahead

🔍 What are Regular Expressions?

Regular Expressions (RegEx) are powerful pattern-matching tools used to search, validate, and manipulate text. Think of them as a specialized search language that lets you describe complex text patterns with precision.

Instead of searching for exact strings like "hello", regex lets you search for patterns like "any email address" or "all phone numbers" or "URLs starting with https". This makes regex indispensable for data validation, text processing, log parsing, and countless other development tasks.

Why developers rely on regex:

Powerful: Match complex patterns that would take hundreds of lines of code otherwise
Universal: Supported in virtually every programming language
Concise: Express complex logic in a compact syntax
Fast: Highly optimized engines make pattern matching lightning-quick

Common use cases include form validation (emails, passwords, phone numbers), log file parsing, data extraction from text, search and replace operations, and URL routing in web frameworks.

🛠️ How to Use This Tool

Getting Started

Testing regex patterns is simple:

Enter Pattern: Type your regex pattern in the top input field (between the slashes)
Set Flags: Use checkboxes or type flags directly (g, i, m, s, u)
Add Test String: Paste or type the text you want to test against
See Results: Matches highlight instantly with detailed information

Understanding Flags

g (Global): Find all matches, not just the first one. Essential for search-and-replace operations.

i (Case Insensitive): Match both uppercase and lowercase letters. "Hello" matches "hello", "HELLO", etc.

m (Multiline): Makes ^ and $ match line starts/ends instead of just string start/end.

s (Dotall): Makes . match newline characters too (normally it doesn't).

u (Unicode): Enables full Unicode support for matching international characters.

Core Features

Real-Time Highlighting: See your matches highlighted in the test string as you type. Different colors show different capture groups.

Pattern Explanation: Get a human-readable breakdown of what your regex pattern does. Perfect for learning or debugging complex patterns.

Match Details: View all matches with their positions, capture groups, and values. Click to see exactly what was captured.

Replace Mode: Test substitution patterns with capture group references ($1, $2, etc.). See the result before using it in your code.

Pattern Library

Click "Common Patterns Library" to access pre-built regex for emails, URLs, phone numbers, passwords, and more. Click any pattern to load it instantly.

Export Options

Copy All: Copy all matches to clipboard
Export JSON: Download matches as structured JSON data
Export CSV: Download matches as CSV for spreadsheet analysis

🔒 Privacy First: All regex testing happens in your browser. Your patterns and test strings never leave your device.

💡 Common Use Cases

Form Validation

Validate user input before submission. Test email addresses, phone numbers, passwords, usernames, and more. Use our pattern library for common validation patterns, or build custom ones for your specific requirements.

Log File Parsing

Extract specific information from log files—timestamps, error codes, IP addresses, user IDs. Regex excels at finding structured data within unstructured text. Test your patterns here before running them on production logs.

Data Extraction

Pull specific data from HTML, CSV, or text files. Extract URLs from documents, phone numbers from contact lists, or product codes from invoices. The match details show exactly what was captured.

Search and Replace

Transform text with pattern-based replacements. Use capture groups to rearrange data (e.g., "LastName, FirstName" → "FirstName LastName"). Test your replacement pattern in Replace Mode before applying it to real data.

URL Routing

Design and test URL patterns for web frameworks. Validate route parameters, extract dynamic segments, and ensure your routing logic works correctly before deploying.

Code Refactoring

Find and replace code patterns across your codebase. Test complex search patterns here to ensure they match exactly what you want—nothing more, nothing less.

Data Cleaning

Normalize inconsistent data formats. Remove unwanted characters, standardize phone number formats, or clean up messy CSV data. Test your cleaning patterns to avoid unintended changes.

⚡ Tips & Tricks

Start Simple, Build Up

Don't try to write the perfect regex in one go. Start with a simple pattern that matches some cases, then refine it incrementally. Test each change to see how it affects your matches.

Use the Pattern Library

Don't reinvent the wheel. Our pattern library includes battle-tested regex for common tasks. Click a pattern to load it, then modify it for your specific needs.

Understand Greedy vs Lazy

By default, quantifiers (* + {n,m}) are greedy—they match as much as possible. Add ? to make them lazy: .*? matches as little as possible. Test both to see the difference.

Use Non-Capturing Groups

If you need grouping but don't need to capture the value, use (?:...) instead of (...). It's more efficient and keeps your capture groups numbered correctly.

Test Edge Cases

Test your regex with empty strings, very long strings, special characters, and Unicode. What works for "john@example.com" might break on "josé@café.com".

Escape Special Characters

Characters like . * + ? ^ $ { } [ ] ( ) | \ have special meaning in regex. To match them literally, escape with backslash: \. matches an actual period.

Use Anchors Wisely

^ and $ anchor your pattern to the start/end of the string. Without them, your pattern might match substrings you didn't intend. Test with and without anchors to see the difference.

Check Browser Compatibility

This tool uses JavaScript's regex engine. Some features (like lookbehinds) may not work in older browsers. The flavor note at the bottom reminds you of this.

Save Your Patterns

Use the pattern history feature to save patterns you use frequently. Your recent patterns are stored locally and persist across sessions.

❓ Frequently Asked Questions

Is my data safe?

Absolutely. This tool runs 100% client-side in your browser. Your regex patterns and test strings never leave your device. No server processing, no data collection, no privacy concerns. Perfect for testing patterns against sensitive data.

What regex flavor does this use?

JavaScript RegEx. This tool uses JavaScript's native regex engine, which is similar to but not identical to PCRE, Python, or other flavors. Most common features work identically, but some advanced features (like lookbehinds in older browsers) may differ.

Why aren't my matches showing up?

Common issues: (1) Missing the 'g' flag for multiple matches, (2) Pattern is too strict (try removing anchors ^ $), (3) Case sensitivity (add 'i' flag), (4) Special characters not escaped. Check the pattern explanation for hints.

What's the difference between () and (?:)?

Capturing vs non-capturing groups. (...) captures the matched text for later use (in replacements or code). (?:...) groups without capturing, which is faster and doesn't affect capture group numbering.

How do I match a literal dot or asterisk?

Escape with backslash. Use \. to match a period, \* to match an asterisk, etc. Any special regex character can be escaped this way to match it literally.

Can I test multiline text?

Yes! Paste multiline text into the test string area. Use the 'm' flag to make ^ and $ match line boundaries instead of just string boundaries.

How do I use capture groups in replacements?

Enable Replace Mode and use $1, $2, etc. to reference capture groups. $& references the entire match. Example: pattern (\\w+) (\\w+) with replacement $2 $1 swaps two words.

Why is my regex so slow?

Complex patterns with nested quantifiers can cause "catastrophic backtracking." Simplify your pattern, use non-capturing groups (?:...), or make quantifiers lazy with ?. Test with shorter strings first.

Can I save my patterns?

Yes, locally. Your recent patterns are saved in your browser's local storage. They persist across sessions but are device-specific. Use the history feature to access them.

How do I report a bug or request a feature?

Head over to our Contact page to send feedback. We're always improving and appreciate hearing from users!

REGEX Tester & Debugger