What is a regular expression (regex)?

A regular expression (regex) is a sequence of characters that defines a search pattern. It is used to match, search, and manipulate text. For example, the pattern \d+ matches one or more digits. Regex is supported in virtually every programming language including JavaScript, Python, Java, and PHP.

What do regex flags like g, i, m, and s mean?

Regex flags modify how the pattern is applied. 'g' (global) finds all matches instead of stopping at the first. 'i' (case-insensitive) ignores letter casing. 'm' (multiline) makes ^ and $ match the start/end of each line. 's' (dotAll) makes the dot (.) match newline characters as well.

How do I test a regex pattern online?

Enter your regex pattern in the pattern input field, select the desired flags (global, case-insensitive, etc.), and type or paste your test string. Our tool highlights all matches in real time, shows captured groups, and displays match positions. You can also use the replace feature to test substitutions.

What are capturing groups in regex?

Capturing groups are portions of a regex pattern enclosed in parentheses (). They capture the matched text so you can reference it later. For example, in the pattern (\d{3})-(\d{4}), group 1 captures the first three digits and group 2 captures the last four. Named groups use the syntax (? ...) for clearer references.

Regex Tester - Test Regular Expressions Online

Regular Expression

/ /

g global i case insensitive m multiline s dotAll

Test String

The quick brown fox jumps over the lazy dog. Contact us at hello@example.com or support@filecraft.pro. Call 555-123-4567 or (800) 555-0199.

📋 Match Results

0 matches

Enter a regex pattern to see matches

🔄 Replace

Replacement Pattern

Result

Replace result will appear here...

⚡ Common Patterns

⚡ Real-Time Testing

See matches highlighted instantly as you type your regex pattern or test string. No need to press a button — results update automatically. Captured groups and match positions are displayed for every match.

🔒 100% Private

All regex matching runs entirely in your browser using JavaScript. Your patterns and test strings are never sent to any server. Bookmark this page and use it offline once cached.

🔄 Search & Replace

Test regex replacements with backreferences like $1, $2, and named groups. Preview the replaced output in real time before applying it to your code.

Regular Expression Testing & Debugging

🔍 Test Regex for Email Validation

Validate email addresses with regex patterns. Test common email patterns like [\w.+-]+@[\w-]+\.[\w.]+ against your data. Our highlighter shows exactly which parts of your string match, so you can refine your pattern for edge cases.

📞 Phone Number Regex Patterns

Match US and international phone numbers with regex. Test patterns for formats like (555) 123-4567, 555-123-4567, or +1-555-123-4567. Use our quick-fill buttons to load common phone patterns instantly.

🔗 URL and Domain Regex Testing

Extract and validate URLs from text using regex. Test patterns for HTTP/HTTPS links, domains, and paths. Our tool highlights all matched URLs and displays captured groups for protocol, domain, and path segments.

🛡️ Regex for Data Cleaning and Parsing

Use regex to clean log files, parse CSV data, or extract information from structured text. Test replacement patterns with backreferences to reformat dates, swap names, or strip unwanted characters from your data.

Regex Quick Reference

Regular expressions use special characters and sequences to define patterns. Here's a quick reference for the most commonly used regex syntax elements.

Common Regex Syntax

. — Matches any character except newline (unless s flag is set)
\d — Matches any digit (0-9)
\w — Matches any word character (a-z, A-Z, 0-9, _)
\s — Matches any whitespace character (space, tab, newline)
^ — Matches the start of the string (or line with m flag)
$ — Matches the end of the string (or line with m flag)
* — Matches 0 or more of the preceding element
+ — Matches 1 or more of the preceding element
? — Matches 0 or 1 of the preceding element
{n,m} — Matches between n and m occurrences
[abc] — Character class: matches a, b, or c
(abc) — Capturing group
(?:abc) — Non-capturing group
a|b — Alternation: matches a or b
\b — Word boundary

How to Test a Regular Expression

Type your pattern — say \b\w+@\w+\.\w+\b — and pick flags: g to find every match rather than just the first, i for case-insensitivity, m to make ^ and $ work per-line.
Paste sample text that includes both strings that should match and strings that shouldn't — testing only positives is how subtly wrong patterns escape into production.
Read the live highlights. Matches light up as you type, with capture groups broken out, so you can tighten the pattern iteratively instead of guessing.

The Five Concepts That Unlock Regex

Character classes — \d (digit), \w (word character), \s (whitespace), [a-f0-9] (custom set). Quantifiers — + (one or more), * (zero or more), ? (optional), {2,4} (a counted range). Anchors — ^ and $ pin a match to the start or end, the difference between "contains a number" and "is a number". Groups — ( ) capture parts of the match for extraction or backreference. Alternation — cat|dog matches either. Nearly every practical pattern is just these five combined.

The classic beginner trap is greediness: quantifiers match as much as possible, so ".*" applied to say "hi" and "bye" grabs from the first quote to the last. Adding ? makes it lazy — ".*?" stops at the first closing quote. Watching this happen live in the tester teaches it faster than any tutorial. For a structured walkthrough from zero, read our regular expressions beginner's guide.

Patterns Worth Stealing

Email (pragmatic):   ^[\w.+-]+@[\w-]+\.[\w.]+$
URL:                 https?://[^\s]+
Date (YYYY-MM-DD):   ^\d{4}-\d{2}-\d{2}$
Time (24h):          ^([01]\d|2[0-3]):[0-5]\d$
Hex color:           ^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$
Trim whitespace:     ^\s+|\s+$   (replace with "")
Duplicate words:     \b(\w+)\s+\1\b

Paste any of these into the tester with your own data to see how they behave — and where they break. A pragmatic email pattern, for instance, deliberately rejects some technically-valid addresses; whether that trade-off is right depends on your application, and the only way to know is to test against real samples.

Frequently Asked Questions

Which regex flavor does this tester use?

JavaScript (ECMAScript), since it runs in your browser. Core syntax is shared with Python, Java, and PCRE; the differences appear in advanced features like lookbehind and named groups, so verify those in your target language too.

Why does my pattern match in the tester but not in my code?

Usually string escaping: in code, backslashes inside quoted strings need doubling ("\\d+"), or a raw string in Python (r"\d+"). Second most common: a missing g flag, so only the first match is replaced.

Why does . not match my multi-line text?

By design, . matches everything except newlines. Use the s (dotAll) flag, or match whitespace explicitly with [\s\S].

Is my test data sent to a server?

No — matching runs locally in your browser, so testing against real logs or customer data doesn't expose it.

Should I validate emails with regex at all?

Use a simple pattern to catch obvious typos, then confirm with a verification email — the only real proof an address works. Fully RFC-compliant email regexes run to hundreds of characters and still can't tell you whether the mailbox exists.

🔍 Regex Tester