What is a regex tester?

A regex tester is an online tool that lets you write regular expression patterns and test them against sample text in real-time. As you type your pattern, the tester highlights all matches, shows capture groups, and reports any syntax errors. It's essential for building and debugging regex patterns before using them in code.

How do I test a regex pattern online?

Enter your regex pattern in the pattern field, add your test text below, and see matches highlighted instantly. Toggle flags (g, i, m, s) to modify behavior. Our regex tester shows match count, capture groups, and match positions in real-time as you type.

What are regex flags?

Regex flags modify how the pattern matching works: 'g' (global) finds all matches instead of stopping at the first. 'i' (case-insensitive) ignores uppercase/lowercase. 'm' (multiline) makes ^ and $ match line boundaries. 's' (dotAll) makes . match newlines. 'u' (unicode) enables full unicode matching.

What are capture groups in regex?

Capture groups are parts of the pattern enclosed in parentheses (). They capture the matched text for later use. For example, (\d{3})-(\d{4}) matching '555-1234' captures '555' as group 1 and '1234' as group 2. Use (?:...) for non-capturing groups when you don't need the value.

How do I use regex replace?

In replace mode, enter a replacement string that can reference capture groups with $1, $2, etc. For example, pattern (\w+)@(\w+) with replacement '$1 at $2' transforms 'user@domain' into 'user at domain'. Our regex tester shows the replacement result in real-time.

What's the difference between greedy and lazy matching?

Greedy quantifiers (+, *, {n}) match as much text as possible. Lazy quantifiers (+?, *?, {n}?) match as little as possible. For example, given ' bold ', the greedy / / matches the entire string, while the lazy / / matches just ' ' and ' ' separately.

Does this regex tester work with JavaScript?

Yes, our regex tester uses the JavaScript regex engine (same as Chrome, Node.js, and all modern browsers). Patterns tested here will work identically in JavaScript code. Note that some features like lookbehind may not work in older browsers.

Regex Tester

Our regex tester lets you write and test regular expressions in real-time with instant match highlighting. See all matches, capture groups, and match indices as you type. Supports all JavaScript regex flags (global, case-insensitive, multiline, dotAll, unicode, sticky). Includes a replace mode for search-and-replace testing, plus a comprehensive regex cheat sheet for quick reference.

star 4.9 (1,800 ratings)

calendar_today Updated: April 2026

auto_awesome AI Insights AI

New

Regular Expression

/ /

global | case-insensitive | multiline | dotAll | unicode

info Enter a pattern to start matching

0 matches

Test String

find_replace Replace Mode

Replacement String (use $1, $2 for groups)

Result

Match Details

No matches yet

auto_awesome AI Analysis

Regex Analysis:

Pattern: Matches email-like patterns
Matches found: 2
Capture groups: None

Tip: Use the 'g' flag to find all matches in the test string.

lightbulb Tips

•\d = digit, \w = word, \s = space
•Use 'g' flag to find all matches
•Escape special chars: \. \( \[ \+
•Use (?:...) for non-capturing groups

How to Use This Calculator

edit

Enter Pattern

Type your regex pattern in the pattern field. Syntax errors are highlighted in real-time.

text_fields

Add Test Text

Paste or type the text you want to test against. Matches are highlighted instantly.

tune

Toggle Flags

Enable flags like global (g), case-insensitive (i), or multiline (m) to modify matching behavior.

visibility

View Results

See all matches, capture groups, and match positions. Use replace mode to test search-and-replace.

The Formula

Regular expressions are patterns used to match character combinations in strings. The regex engine scans the test string left-to-right, attempting to match the pattern at each position. Flags modify matching behavior — 'g' finds all matches, 'i' ignores case, 'm' makes ^ and $ match line boundaries.

new RegExp(pattern, flags).exec(testString)

lightbulb Variables Explained

pattern The regular expression pattern to match against
flags Regex flags: g (global), i (case-insensitive), m (multiline), s (dotAll), u (unicode)
testString The input text to test the pattern against
exec() Returns match details including captured groups and indices

tips_and_updates Pro Tips

Use the 'g' flag to find all matches, not just the first one

Escape special characters with backslash: \.  \[ \] \{ \} \+ \* \?

Use (?:...) for non-capturing groups when you don't need the match value

\d = digit, \w = word char, \s = whitespace, \b = word boundary

Use .+? (lazy) instead of .+ (greedy) to match as little as possible

The 'm' flag makes ^ and $ match start/end of each line, not just the string

Test edge cases: empty strings, special characters, and very long inputs

Test Regular Expressions Online

Our free regex tester lets you build, test, and debug regular expressions with live match highlighting. See matches, capture groups, and replacement results instantly as you type. Works with JavaScript regex syntax.

Online Regex Tester with Live Preview

Type your regex pattern and see matches highlighted in real-time. Our regex tester supports all JavaScript flags including global, case-insensitive, multiline, and dotAll. Every match is highlighted with capture groups displayed separately for easy debugging.

Regex Pattern Builder & Debugger

Build complex regex patterns with our interactive tool. See exactly what your pattern matches and why. Capture groups are numbered and displayed, making it easy to build patterns for data extraction, validation, and text processing.

Regex Cheat Sheet & Reference

Quick reference for common regex syntax: character classes (\d, \w, \s), quantifiers (+, *, ?, {n}), anchors (^, $, \b), groups and alternation, lookahead and lookbehind. Everything you need to build regex patterns right next to the tester.

Frequently Asked Questions

Related Tools

View all General View all arrow_forward

widgets