Regex Tester & Debugger.

A regular expression is a formal pattern language that describes a set of strings. At its core, a regex pattern is a sequence of characters where literals match themselves, metacharacters define structure (. matches any character, ^ anchors to line start, $ to line end), and quantifiers control repetition (* for zero-or-more, + for one-or-more, ? for zero-or-one, {n,m} for bounded ranges). The engine scans a target string left-to-right and attempts to match the pattern at each position. When it succeeds, it returns a match object containing the full match, any captured sub-expressions, and the match index. Developers use regular expressions for input validation, data extraction from structured text, log parsing, URL routing, search-and-replace transformations, and tokenizing source code — any task where the structure of text needs to be described programmatically rather than hardcoded character-by-character.

This tool runs directly on the ECMAScript (JavaScript) Regex engine built into your browser — the same V8 engine that powers Chrome and Node.js. This is a deliberate design choice for frontend and full-stack JavaScript developers: a pattern that validates in this tool will behave identically in your React form handler, your Express route definition, or your Node.js data pipeline. The ECMAScript regex flavor supports character classes, quantifiers, alternation, capturing and non-capturing groups, named capture groups (?<name>...), lookaheads (?=...) and (?!...), lookbehinds (?<=...) and (?<!...), and Unicode property escapes (p{Letter}). It does not support PCRE-specific features like atomic groups or possessive quantifiers, which is an important distinction if you are porting patterns from PHP, Python, or a .NET environment.

Flags are single-character modifiers appended after the closing delimiter that change how the engine interprets the pattern. The global flag (g) instructs the engine to find all non-overlapping matches in the string rather than stopping after the first. The case-insensitive flag (i) makes the pattern match uppercase and lowercase letters interchangeably — [a-z] will also match [A-Z]. The multiline flag (m) changes the behavior of the ^ and $ anchors: without it, they match only the very start and end of the entire string; with it, they match the start and end of each individual line separated by newline characters. The dotAll flag (s), introduced in ES2018, makes the dot (.) metacharacter match newline characters ( , ) in addition to all other characters — without it, the dot skips newlines, which can cause patterns to fail silently on multi-line strings.

Yes. This regex tester online is built on a strict static architecture with zero backend infrastructure. The JavaScript Regex engine that evaluates your pattern and test string runs entirely inside your own browser's local sandbox — the same isolated JavaScript context that executes any other script on the page. No string, character, or byte of your test data is transmitted over a network. There are no server-side API endpoints receiving your input, no request logs on a remote server, and no third-party analytics pipelines reading form contents. You can verify this directly: open your browser's DevTools Network panel, type in the test area, and confirm that no outbound POST or XHR requests are made. Input and pattern state are persisted only to your own device's localStorage.

A capture group is a sub-expression enclosed in parentheses that causes the engine to record the text matched by that sub-expression as a separate result alongside the full match. When you call String.prototype.matchAll() in JavaScript, each result object contains index 0 (the full match) and indices 1, 2, 3… for each capture group in left-to-right order of their opening parenthesis. For example, the pattern (d{4})-(d{2})-(d{2}) applied to "2024-06-15" yields match[1]="2024", match[2]="06", match[3]="15". Named capture groups extend this by assigning string keys: (?<year>d{4})-(?<month>d{2})-(?<day>d{2}) makes the values accessible as match.groups.year, match.groups.month, match.groups.day — eliminating the fragility of positional indexing. Non-capturing groups (?:...) group sub-expressions for quantifier application or alternation without consuming a capture slot.

These three JavaScript methods expose the regex engine at different levels of verbosity. RegExp.prototype.test(string) is the lightest — it returns a boolean true/false and is the correct choice for pure validation scenarios like form field checks where you only need a pass/fail signal. String.prototype.match(regex) without the g flag returns a single match object (full match + groups + index), and with g returns a flat array of full match strings with no group data. String.prototype.matchAll(regex) requires the g flag and returns an iterator of complete match objects — each containing the full match, all captured groups, named groups, and the match index — making it the correct tool for extraction tasks where you need structured data from every occurrence of a pattern in a string. This tool uses matchAll() internally to power the capture group extraction panel.