Free Regex Tester — Test Regular Expressions Online with Highlighting

Regular expressions are one of the most powerful and most feared tools in a developer's arsenal. They can validate email addresses in one line, extract data from unstructured text, and transform entire documents with surgical precision. They can also produce write-only code that nobody — including you in two weeks — can decipher.

The difference between regex mastery and regex fear is practice and visualization. Our free regex tester highlights matches in real-time as you type your pattern. You see exactly what matches and what does not, which makes learning and debugging dramatically easier. It runs in your browser — your text and patterns never leave your device. Unlike Regex101 or RegExr, there are no ads competing for your attention.

Regex Basics for Beginners

A regular expression is a pattern that describes a set of strings. At its simplest, it is just literal text: the regex cat matches the text "cat" anywhere it appears. But the real power comes from special characters that match categories and quantities.

Think of regex like a search query with superpowers. Normal search finds exact text. Regex finds patterns. "Find all phone numbers" is impossible with normal search because phone numbers are formatted differently. With regex, one pattern catches them all.

Here is the foundation you need:

• Literal characters match themselves: abc matches "abc"
• Special characters have meaning: . * + ? [ ] ( ) { } ^ $ | \
• Escape with backslash to match special characters literally: \. matches a period, \$ matches a dollar sign

Character Classes — Matching Types of Characters

Character classes match a single character from a defined set. These are the building blocks of every useful regex pattern.

Pattern	Matches	Example
.	Any character except newline	h.t matches "hat", "hot", "h7t"
\d	Any digit (0-9)	\d\d matches "42", "07", "99"
\D	Any non-digit	\D matches "a", "!", " "
\w	Word character (letter, digit, _)	\w+ matches "hello", "var_1"
\W	Non-word character	\W matches " ", "!", "@"
\s	Whitespace (space, tab, newline)	\s+ matches " " (spaces)
\S	Non-whitespace	\S+ matches "hello"
[abc]	Any character in the set	[aeiou] matches vowels
[^abc]	Any character NOT in the set	[^0-9] matches non-digits
[a-z]	Character range	[A-Za-z] matches any letter

Quantifiers — How Many to Match

Character classes match one character. Quantifiers specify how many times that character (or group) should appear.

Quantifier	Meaning	Example
*	Zero or more	ab*c matches "ac", "abc", "abbc"
+	One or more	ab+c matches "abc", "abbc" (not "ac")
?	Zero or one (optional)	colou?r matches "color" and "colour"
{3}	Exactly N times	\d{3} matches "123" (three digits)
{2,5}	Between N and M times	\w{2,5} matches 2-5 word chars
{3,}	N or more times	\d{3,} matches 3+ digits

Greedy vs. lazy: By default, quantifiers are greedy — they match as much as possible. Adding ? after the quantifier makes it lazy (matches as little as possible). This matters when matching delimited content: ".*" greedily matches "first" and "second" as one match, while ".*?" lazily matches "first" and "second" as two separate matches.

Sell Custom Apparel — We Handle Printing & Free Shipping

Groups, Capturing, and Alternation

Groups use parentheses to combine multiple tokens into a single unit. The pattern (abc)+ matches "abc", "abcabc", "abcabcabc" — one or more repetitions of the entire group.

Capturing groups remember what they matched. In the pattern (\d{3})-(\d{4}) applied to "555-1234", group 1 captures "555" and group 2 captures "1234". This is essential for find-and-replace operations where you reuse captured text in the replacement.

Non-capturing groups use (?:...) when you need grouping but do not need to capture. This is slightly more efficient and keeps your group numbering clean.

Alternation uses the pipe | to match one pattern or another. cat|dog matches "cat" or "dog". (Mon|Tues|Wednes|Thurs|Fri|Satur|Sun)day matches any day of the week.

Lookaheads and Lookbehinds

Lookaheads and lookbehinds are advanced features that match a position without consuming characters. They answer the question "what is next to this?" without including it in the match.

• Positive lookahead (?=...): Match only if followed by the pattern. \d+(?=%) matches digits only when followed by a percent sign — "50" in "50%" but not "50" in "50 dollars."
• Negative lookahead (?!...): Match only if NOT followed by the pattern. \d+(?!%) matches digits not followed by a percent sign.
• Positive lookbehind (?<=...): Match only if preceded by the pattern. (?<=\$)\d+ matches digits preceded by a dollar sign — "50" in "$50" but not in "50 items."
• Negative lookbehind (?<!...): Match only if NOT preceded by the pattern.

Lookbehinds have limited support in some regex engines. JavaScript added lookbehind support in ES2018, so modern browsers handle them fine. Python and Java have supported them for years.

10 Most Useful Regex Patterns

These patterns cover the vast majority of real-world regex needs. Copy them, modify them, test them in our tool.

#	Use Case	Pattern
1	Email address	[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}
2	URL (http/https)	https?://[^\s/$.?#].[^\s]*
3	US phone number	\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}
4	IPv4 address	\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b
5	Date (MM/DD/YYYY)	\b\d{1,2}[/-]\d{1,2}[/-]\d{2,4}\b
6	Hex color code	#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})\b
7	HTML tags	<[^>]+>
8	Duplicate words	\b(\w+)\s+\1\b
9	Strong password	^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^a-zA-Z\d]).{8,}$
10	Zip code (US)	\b\d{5}(-\d{4})?\b

Important caveat: The email regex above is a practical approximation. The actual RFC 5322 email specification is absurdly complex and produces a regex that is thousands of characters long. For real email validation, use a dedicated library. For quick pattern matching and data extraction, the simplified pattern works well.

Common Regex Pitfalls to Avoid

Catastrophic Backtracking

Nested quantifiers like (a+)+ or (a|a)+ can cause the regex engine to explore exponentially many paths, freezing your browser or crashing your server. If your regex hangs on certain inputs, look for nested repetition and simplify it.

Greedy Matching on HTML

The pattern <.*> intended to match one HTML tag will greedily match from the first < to the last > on the line, consuming everything between. Use <.*?> (lazy) or better yet <[^>]+> (negated class) instead.

Forgetting to Escape Dots

An unescaped . matches any character. The pattern example.com matches "example.com" but also "exampleXcom." Use example\.com to match the literal domain.

Not Anchoring Patterns

Without anchors, \d{3} matches "123" inside "abc12345xyz." If you want to match exactly three digits and nothing more, use ^\d{3}$. Use \b for word boundaries when you want to match whole words.

Real-World Regex Use Cases

SEO redirect rules: Server redirect configurations (nginx, Apache, Cloudflare) use regex to match URL patterns. ^/blog/(\d{4})/(\d{2})/(.*)$ matches date-based blog URLs and captures the year, month, and slug for rewriting.

Log parsing: Server logs, application logs, and analytics data are text-based. Regex extracts IP addresses, timestamps, error codes, and request paths from unstructured log lines. Sysadmins use regex daily for this.

Data validation: Form inputs, API parameters, and user-submitted data all need validation. Regex validates email formats, phone number patterns, postal codes, and custom formats without writing complex parsing logic.

Data extraction: Scraping structured data from semi-structured text — extracting prices from product descriptions, dates from articles, or coordinates from address blocks.

IDE search: VS Code, Sublime Text, IntelliJ, and every major IDE supports regex search. Finding all function calls matching a pattern, renaming variables across files, or cleaning up code formatting — regex handles it in seconds.

Frequently Asked Questions

What is a regular expression?

A regular expression (regex) is a sequence of characters that defines a search pattern. Instead of searching for exact text, regex lets you search for patterns — like "any three digits followed by a dash" or "any word ending in -ing." Regex is supported in virtually every programming language, text editor, and command-line tool.

Why should I test regex before using it in code?

Regex patterns are easy to get wrong and hard to debug in code. A tester lets you see matches in real-time against sample text, catching false positives and missed matches before the pattern reaches production. It is far faster to iterate on a regex in a visual tester than to modify code, rebuild, and test repeatedly.

What do the regex flags g, i, and m mean?

The "g" flag (global) finds all matches instead of stopping at the first one. The "i" flag (case-insensitive) ignores uppercase/lowercase distinctions. The "m" flag (multiline) makes ^ and $ match the start and end of each line instead of the entire string. These are the three most commonly used flags.

What is the difference between greedy and lazy matching?

Greedy matching (default) matches as much text as possible. The pattern .* will consume the entire line. Lazy matching (adding ?) matches as little as possible. For example, matching HTML tags with <.*> greedily matches everything between the first and last angle bracket, while <.*?> matches each individual tag.

Do regex patterns work the same across all programming languages?

Mostly, but not exactly. Basic syntax (character classes, quantifiers, groups) is the same everywhere. Advanced features like lookbehind, named groups, and Unicode properties vary by engine. JavaScript, Python, Java, Go, and Ruby each have slight differences. Our tester uses the JavaScript regex engine, which covers the vast majority of common patterns.

What are lookaheads and lookbehinds?

Lookaheads and lookbehinds are zero-width assertions that match a position without consuming characters. A positive lookahead (?=...) asserts that what follows matches the pattern. A negative lookahead (?!...) asserts that what follows does NOT match. Lookbehinds do the same for what precedes the current position.