Regex Tester — Test, Debug & Explain Regular Expressions Online

A regex tester is an interactive tool where you write a regular expression, provide sample text, and immediately see which substrings match. Unlike running code in an IDE, a tester shows all matches at once with highlighting, lists every capture group value, and lets you toggle flags without recompiling.

Regex syntax is dense — a missing escape, wrong quantifier, or forgotten global flag causes silent bugs. Testing interactively catches these mistakes on representative input before deployment.

Front-end and back-end developers validate form patterns (email, phone, password rules) and parse API responses. DevOps engineers extract fields from log lines and configuration snippets. QA testers confirm search filters behave on edge-case strings. Data analysts pull structured fields from messy exports.

Students learning regex use Explain mode to connect symbols like \d+ and (?=…) with plain English. Technical writers prototype validation rules for documentation examples. Security reviewers test redaction patterns on sample PII before applying them to live streams.

Start with a template if you are new — Email address or URL loads a proven pattern and realistic sample text. Edit the pattern character by character and watch the highlight update instantly.

Enable the g (global) flag to find all matches; without it only the first match returns. Use i for case-insensitive matching, m when ^ and $ should match each line in multiline logs, and s when dot must match newline characters.

Switch to Matches to read capture group values and copy them. Use Replace to verify substitution strings before putting them in code. Split shows how your pattern divides text into parts — useful for CSV-like or tokenization tasks.

This tool uses your browser's native RegExp implementation — the same engine as JavaScript in Node.js and modern browsers. Named capture groups (?<name>…), lookbehind (?<=…), and the d (indices) flag require ES2018 or later.

The Explain panel and match indices reflect ECMAScript rules. If you target Python, Java, or PHP in production, re-test there after prototyping here — character classes, flag names, and replacement syntax differ.

g (global) — find every non-overlapping match, not just the first. Required for match counts above one and for global replace.

i (ignore case) — A and a are equivalent. Essential for user-facing search where capitalization varies.

m (multiline) — ^ and $ anchor to each line break, not only the start/end of the entire string.

s (dotAll) — dot (.) matches newline characters. Without s, dot stops at line breaks.

u (unicode) — enables \u{…} escapes and Unicode-aware character classes.

y (sticky) — matches only at the current lastIndex position (advanced iteration scenarios).

d (indices) — populates start/end indices for each capture group in match results.

Replace preview applies your pattern and replacement string using JavaScript String.replace semantics. Use $1, $2 for numbered groups, $& for the full match, $` for text before the match, $' for text after, $$ for a literal dollar sign, and $<name> for named groups.

Split mode runs String.split with your regex — each resulting part is numbered so you can verify delimiter behavior on multiline or structured text.

Explain tokenizes your pattern into chips colored by role: anchors, quantifiers, groups, character classes, escapes, and literals. Hover chips in the visual row, then read the detailed list below for each token's meaning.

The Reference tab is a searchable cheat sheet for \d, \b, lookahead, quantifiers, and replacement tokens. Search for a term like boundary or lookahead to jump to the syntax you need.

Templates load vetted patterns for common tasks: email, URL, IPv4, ISO dates, US phone numbers, hex colors, HTML tags, semver versions, markdown links, and named-date groups. Each template includes sample text so you see matches immediately.

Share copies a URL with your pattern, flags, test string, and replacement encoded in the hash. Bookmark or send the link to restore the exact scenario — nothing is stored on our servers.

The benchmark runs your pattern one thousand times against the current test string and reports approximate milliseconds. Nested quantifiers like (a+)+ can cause catastrophic backtracking on long inputs — the tool shows a warning when it detects risky nesting.

Always test regex on production-sized samples in a controlled environment. Simpler patterns with possessive or atomic semantics may be unavailable in JavaScript — refactor or use alternative approaches when warnings appear.

Browser testers like this one keep data local and give instant feedback — ideal for quick validation and learning. Installable desktop tools may support more regex flavors (PCRE, .NET) when you need byte-identical behavior with server-side engines.

Unit tests in code remain essential for regression coverage — use this tester to discover the right pattern, then lock it into tests with edge cases. Command-line tools like grep suit batch file scanning; this page suits interactive debugging and explanation.

Compared to reading regex from documentation alone, live highlighting shows exactly what matched — especially for greedy vs lazy quantifiers and alternation order.

Patterns and test strings are processed in your browser. Local storage remembers your last session on this device. Share links encode state in the URL fragment — the fragment is not sent to servers when loading the page. Clear browser data or click Clear to reset.

Forgetting the g flag when you expect multiple matches. Forgetting i when input case varies. Using dot without s flag on multiline HTML or logs. Unescaped special characters (. * + ? [ ] ( ) { } | \ ^ $) in literal segments. Over-capturing with greedy .* instead of precise character classes.