Free Regex Tester & Regular Expression Tester

Live Regular Expression Testing

Test regular expressions instantly while typing. Every change to your pattern or test string updates the results in real time, making it easier to debug complex expressions.

Regex Validation

Quickly determine whether your regular expression is valid. Syntax errors are detected immediately before the pattern is executed.

Pattern Matching

Find every occurrence that matches your regular expression and visualize exactly where each match appears inside your text.

Capture Groups

Display captured values from parentheses so you can understand how each part of your regular expression behaves.

Step 1 — Enter a Regex Pattern

Type any valid regular expression such as \d+, \w+, [A-Za-z]+, or a more advanced pattern containing groups, quantifiers, and assertions.

Step 2 — Paste Test Text

Enter the text you want to search. The Regex Tester continuously scans the text and highlights every successful match.

Step 3 — Select Regex Flags

Enable flags such as Global (g), Ignore Case (i), Multiline (m), Dot All (s), or Unicode (u) depending on your use case.

Step 4 — Review Results

Instantly view highlighted matches, capture groups, replacement output, regex explanations, and previous test history to verify your expression behaves as expected.

.

The dot matches any single character except line breaks unless the Dot All (s) flag is enabled.

*

Matches zero or more occurrences of the preceding character or group.

+

Matches one or more occurrences of the preceding character or group.

?

Makes the preceding character optional or converts greedy matching into lazy matching.

[]

Defines a character class. For example, [0-9] matches any digit, while [A-Z] matches uppercase letters.

()

Creates a capture group that stores matched text for later use or replacement.

{}

Specifies how many times a pattern should repeat, such as {2} or {1,5}.

^

Matches the beginning of a string or line when multiline mode is enabled.

$

Matches the end of a string or line.

|

Acts as a logical OR operator, allowing one of several patterns to match.

\d

Matches any numeric digit from 0 to 9.

\w

Matches letters, numbers, and underscores.

\s

Matches whitespace characters including spaces, tabs, and line breaks.

Global (g)

Finds every match in the text instead of stopping after the first successful match.

Ignore Case (i)

Performs case-insensitive matching so uppercase and lowercase letters are treated the same.

Multiline (m)

Changes the behavior of the ^ and $ anchors so they match the beginning and end of each line instead of the entire string.

Dot All (s)

Allows the dot (.) to match newline characters in addition to normal characters.

Unicode (u)

Enables full Unicode support, allowing your regex to correctly process international characters and emoji.

Email Validation

Validate standard email addresses entered into registration forms and contact pages.

Phone Numbers

Match local and international phone number formats while allowing optional separators.

Usernames

Restrict usernames to specific lengths and permitted characters.

Passwords

Create password validation rules requiring uppercase letters, lowercase letters, numbers, and special characters.

URLs

Verify website addresses including HTTP, HTTPS, domains, and optional paths.

Dates

Match dates written in formats such as YYYY-MM-DD, MM/DD/YYYY, or DD/MM/YYYY.

IPv4 & IPv6

Validate IP addresses for networking tools, server applications, and API development.

HTML Tags

Locate HTML elements or extract specific tags while processing web content.

Whitespace

Find extra spaces, tabs, blank lines, and formatting issues in text files.

Numbers

Extract integers, decimals, currency values, and other numeric data from documents.

Hex Colors

Match CSS hexadecimal colors such as #FFFFFF and #1A73E8.

UUIDs

Validate universally unique identifiers commonly used by databases and APIs.

Credit Card Numbers

Detect common credit card formats before applying additional verification methods.

ZIP & Postal Codes

Validate postal code formats for shipping forms and address validation systems.

Regex Email

^[^\s@]+@[^\s@]+\.[^\s@]+$

A practical pattern for validating standard email addresses used in registration forms and contact pages.

Regex Phone Number

^\+?[0-9\s\-()]{7,20}$

Matches many international phone number formats including optional country codes and separators.

Regex URL

https?:\/\/[^\s/$.?#].[^\s]*

Matches HTTP and HTTPS website URLs with optional paths and query strings.

Regex Password

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$

Requires at least one uppercase letter, one lowercase letter, one number, and a minimum length of eight characters.

Regex Date

^\d{4}-\d{2}-\d{2}$

Matches dates formatted as YYYY-MM-DD.

Regex HTML Tags

<[^>]+>

Finds HTML tags within a document. Useful for parsing or cleaning text.

Regex Numbers

^-?\d+(\.\d+)?$

Matches positive, negative, integer, and decimal numbers.

Regex Whitespace

\s+

Finds one or more whitespace characters including spaces, tabs, and line breaks.

Regex Hex Color

^#([A-Fa-f0-9]{3}|[A-Fa-f0-9]{6})$

Matches three-digit and six-digit CSS hexadecimal color values.

Regex UUID

^[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}$

Validates UUID/GUID values commonly used by databases and APIs.

Regex IPv4

^(\d{1,3}\.){3}\d{1,3}$

Matches IPv4 addresses. Production validation should also verify each octet is between 0 and 255.

Regex IPv6

^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$

Matches the full IPv6 address format.

.

Matches any character except a newline (unless the s flag is enabled).

\d

Matches any digit from 0 through 9.

\D

Matches any non-digit character.

\w

Matches letters, digits, and underscores.

\W

Matches characters that are not letters, digits, or underscores.

\s

Matches whitespace including spaces, tabs, and newlines.

\S

Matches any non-whitespace character.

^

Beginning of a string or beginning of a line in multiline mode.

$

End of a string or end of a line in multiline mode.

*

Zero or more repetitions.

+

One or more repetitions.

?

Optional element or lazy quantifier.

{n}

Exactly n repetitions.

{n,m}

Between n and m repetitions.

[]

Character class matching one character from the specified set.

()

Capture group used for grouping and extracting matched text.

|

Logical OR operator allowing multiple alternative patterns.

\b

Matches a word boundary.

\B

Matches a position that is not a word boundary.

(?: )

Creates a non-capturing group.

Keep Patterns Simple

Prefer several smaller, readable expressions over one massive regex that attempts to solve every possible case.

Test Real Data

Always test against realistic examples, invalid inputs, and edge cases before using a regex in production.

Use Anchors When Needed

Add ^ and $ if the entire string must match instead of allowing partial matches.

Avoid Catastrophic Backtracking

Nested quantifiers and overly greedy patterns can dramatically reduce performance on large inputs.

Escape Special Characters

Characters such as ., +, *, (, and ) have special meanings and should be escaped when matching literal text.

Use Capture Groups Carefully

Capture only the values you actually need. When grouping without extraction, use non-capturing groups whenever possible.

Document Complex Expressions

Add comments or documentation explaining complicated regular expressions so they remain maintainable over time.

Validate, Don't Assume

A regex can verify format, but additional application logic may still be required for complete validation.

Forgetting to Escape Characters

Symbols like ., +, *, ?, and () are metacharacters. Escape them with a backslash when matching literal text.

Using Greedy Quantifiers Everywhere

Greedy matching can consume more text than intended. Consider lazy quantifiers when appropriate.

Ignoring Regex Flags

Forgetting the correct flags can produce completely different matching behavior. Verify whether you need global, multiline, case-insensitive, Unicode, or dot-all matching.

Trying to Parse Everything with Regex

Some formats, such as complete HTML or programming languages, are better handled using dedicated parsers instead of regular expressions.

Form Validation

Validate email addresses, usernames, passwords, phone numbers, ZIP codes, and other user input before submission.

Data Extraction

Extract names, numbers, dates, URLs, IDs, or other structured information from large blocks of text.

Search & Replace

Quickly replace matching text using capture groups and replacement patterns during development.

API Development

Validate request parameters, route patterns, tokens, identifiers, and serialized data.

Log Analysis

Search application logs to locate IP addresses, timestamps, error messages, stack traces, and request IDs.

Web Scraping

Locate specific text patterns before parsing documents or processing downloaded content.

Text Processing

Clean whitespace, remove duplicate characters, normalize formatting, and automate repetitive edits.

Programming

Useful for JavaScript, Python, PHP, Java, C#, Go, Ruby, Perl, Rust, and many other programming languages.

Database Queries

Many database engines support regex searching for advanced filtering and pattern matching.

DevOps & Automation

Automate configuration management, file processing, shell scripts, CI/CD pipelines, and monitoring tools.

Cybersecurity

Detect suspicious strings, indicators of compromise, malicious URLs, and log anomalies.

Learning Regex

Experiment with syntax, flags, quantifiers, capture groups, and replacement rules in a safe environment.