What is a regular expression?

A regular expression (regex or regexp) is a sequence of characters that defines a search pattern. It uses a special syntax to describe text patterns — for example, \d+ matches one or more digits, and \b\w+@\w+\.\w+\b matches email addresses. Regular expressions are supported by virtually every programming language, text editor, and command-line tool, making them one of the most universally useful skills in software development.

Which regex flavor is supported?

This tool uses the JavaScript RegExp engine, which is the native regex implementation built into your browser. It supports ECMAScript regular expression syntax, including character classes, quantifiers, groups, backreferences, lookahead, lookbehind, named capture groups, and all standard flags. If your regex works here, it will work in any JavaScript or TypeScript code. Note that some advanced features available in PCRE (Perl Compatible Regular Expressions) or Python's regex module — like recursive patterns or possessive quantifiers — are not supported in JavaScript.

What flags can I use?

Six flags are supported as toggle switches: g (global — find all matches), i (case insensitive), m (multiline — ^ and $ match per line), s (dotall — . matches newlines), u (Unicode mode), and y (sticky — match only at lastIndex). You can combine multiple flags — for example, enabling both g and i will find all case-insensitive matches. The flags string is displayed next to your pattern in the /pattern/flags format.

Can I use capture groups?

Yes. Capture groups are created with parentheses in your pattern — for example, (\w+)@(\w+)\.(\w+) creates three groups. The tool automatically detects the number of capture groups and displays each group's value for every match, labeled as $1, $2, $3, etc. Non-capturing groups (?:...) match but do not capture, and named groups (? ...) capture and are accessible by name in your code. Backreferences like \1 are also supported.

Does it support replace operations?

Yes. Toggle on 'Replace mode' to enter a replacement string. You can use $1, $2, etc. to reference capture groups, $& for the full match, $` for the portion before the match, and $' for the portion after. The tool shows a live preview of the replaced text and provides a 'Copy result' button to copy it to your clipboard. Without the global (g) flag, only the first match is replaced; with g, all matches are replaced.

What's the maximum input size?

The tool supports test strings up to 500,000 characters (approximately 500 KB). This limit prevents performance issues that can arise from running complex regex patterns on very large inputs in the browser. For most practical use cases — validating form input, parsing log lines, extracting data from documents — this is more than sufficient. If you need to process larger text, consider splitting it into smaller chunks or using a server-side regex tool.

Can I test multiline strings?

Yes. The test string input accepts multiline text — just type or paste text with line breaks. To match patterns across line boundaries, enable the 'm' (multiline) flag so that ^ and $ match at the start and end of each line rather than just the start and end of the entire string. Enable the 's' (dotall) flag if you want . to match newline characters as well.

Does it store my data?

No. All regex testing happens entirely in your browser using JavaScript. Your pattern, test string, and replacement text are never uploaded to a server, stored in a database, or sent anywhere. The tool has no backend — what you type stays on your device. You can safely test patterns with sensitive data like emails, phone numbers, or internal log formats without any privacy concerns.

🛠️DevToolsHub

Regex Tester

Test regular expressions with live match highlighting and groups.

What is Regex Tester?

A Regex Testeris an interactive tool that lets you write, test, and debug regular expressions in real time. You enter a pattern, provide a test string, and the tool instantly highlights every match, shows capture group values, and reports match positions — all without leaving your browser. It's the fastest way to experiment with regex syntax and verify that your patterns behave the way you expect.

Regular expressions (regex or regexp) are a powerful mini-language for describing text patterns. They're used across virtually every programming language, text editor, and command-line tool for tasks like input validation (is this email address valid?), data extraction (pull all URLs from an HTML document), search and replace (normalize phone number formats), and parsing (split log lines into structured fields). Regex is supported natively in JavaScript, Python, Java, Go, Rust, Perl, grep, sed, awk, and dozens of other environments.

However, regex syntax is notoriously dense and error-prone. A single misplaced quantifier, missing backslash, or unbalanced parenthesis can completely change what your pattern matches — or cause it to throw a syntax error. Testing regex inline in your code means writing test cases, running your application, and reading console output. A dedicated regex tester eliminates that friction: you type a pattern, see matches highlighted instantly, and iterate until the pattern is correct.

Common use cases for an online regex tester include: validating email addresses, phone numbers, and postal codes; extracting data from structured text like log files or CSV rows; finding and replacing specific patterns across a document; testing URL routing patterns; parsing query strings; matching hashtags or mentions in social media text; and verifying that your regex works before deploying it to production code. Whether you're a beginner learning regex syntax or an experienced developer fine-tuning a complex pattern, a tester gives you immediate visual feedback that dramatically speeds up the development process.

How to Use Regex Tester

Enter your regex patternin the "Regular Expression" field. Use the monospace input to type patterns like \b(\w+)@(\w+)\.(\w+)\b. The pattern is tested live as you type.
Toggle flags using the switches below the pattern field. The g flag finds all matches; i makes matching case-insensitive; m enables multiline mode; s allows . to match newlines; u enables Unicode mode; and y enables sticky matching.
Enter your test stringin the "Test String" textarea. This is the text your pattern will be matched against. The tool auto-tests as you type (after a 300 ms debounce).
Review the results: a match count badge shows how many matches were found, and each match is highlighted in yellow within the test string so you can see exactly what your pattern captures.
Expand the Match Detailssection to see each match's value, position (character offset), length, and any capture group values. Capture groups are labeled as $1, $2, etc.
Enable Replace mode to test search-and-replace operations. Enter a replacement string using $1, $2 for groups or $& for the full match, and see the output preview instantly. Use the Copy result button to copy the replaced text.
Click Load Example to try a pre-filled email extraction pattern, or Clear to start over. Expand the Regex Cheatsheet at the bottom for a quick syntax reference.

Regex Syntax Guide

Character Classes

Character classes match a single character from a set. Use square brackets to define custom sets, or shorthand escapes for common categories.

[abc]Any one of a, b, or c

[^abc]Any character except a, b, or c

[a-z]Any lowercase letter a through z

[a-zA-Z0-9]Any alphanumeric character

\dAny digit (equivalent to [0-9])

\DAny non-digit character

\wAny word character (letters, digits, underscore)

\WAny non-word character

\sAny whitespace (space, tab, newline)

\SAny non-whitespace character

.Any character except newline (with s flag, includes newline)

Quantifiers

Quantifiers specify how many times the preceding element must appear. Append ? to make any quantifier lazy (match as few as possible).

*Zero or more occurrences

+One or more occurrences

?Zero or one occurrence (optional)

{n}Exactly n occurrences

{n,}At least n occurrences

{n,m}Between n and m occurrences

*?Lazy: zero or more (fewest possible)

+?Lazy: one or more (fewest possible)

Groups

Groups let you combine multiple elements and capture matched substrings. Non-capturing groups match but don't store the result. Lookahead and lookbehind assertions check for (or against) a pattern without consuming input.

(abc)Capturing group — stores matched text

(?:abc)Non-capturing group — matches but doesn't store

(?=abc)Positive lookahead — matches if abc follows

(?!abc)Negative lookahead — matches if abc doesn't follow

(?<=abc)Positive lookbehind — matches if abc precedes

(?<!abc)Negative lookbehind — matches if abc doesn't precede

(?<name>x)Named capturing group — access by name

\1Backreference to the first capturing group

Anchors

Anchors match positions within the string rather than actual characters. They're zero-width assertions.

^Start of string (or line with m flag)

$End of string (or line with m flag)

\bWord boundary — between a word char and non-word char

\BNot a word boundary

Flags

Flags modify how the regex engine interprets the pattern and performs matching. Combine multiple flags for compound behavior.

gGlobal — find all matches, not just the first

iCase insensitive — ignore letter case

mMultiline — ^ and $ match per line, not just string boundaries

sDotall — . matches newline characters

uUnicode — treat pattern and string as Unicode code points

ySticky — match only at lastIndex position

Features

Live match highlighting — matches are highlighted in yellow within your test string as you type, giving you instant visual feedback.
Capture group support — each match displays its capture group values, labeled $1, $2, etc., so you can verify what each group captures.
Replace mode — toggle on replace mode to test search-and-replace operations with $1, $&, and other replacement tokens. Copy the result with one click.
Six regex flags — toggle g, i, m, s, u, and y flags individually with user-friendly switches.
Match details — for each match, see the matched text, character position (index), length, and all capture group values in a clean, scrollable list.
Auto-detection of capture groups — the tool automatically counts capture groups in your pattern and displays the count, so you always know how many groups to expect.
Built-in cheatsheet — a collapsible regex syntax reference covering character classes, quantifiers, groups, anchors, flags, and escaping — no need to tab out to documentation.
Debounced auto-testing— the tool waits 300 ms after you stop typing before running the regex, preventing lag on large inputs while still feeling instant.
Error handling — invalid regex patterns (unbalanced parentheses, bad quantifiers, etc.) produce clear error messages instead of crashing the tool.
100% client-side — all regex testing happens in your browser using the native JavaScript RegExp engine. Your data never leaves your device.
Responsive design — works on mobile, tablet, and desktop with full dark mode support.

Frequently Asked Questions