Test regular expressions live with highlighted matches, capture groups and a replace preview, on the JavaScript RegExp engine. Free, in your browser.

Who Uses Regex Tester

Developers checking a pattern against real input before it goes anywhere near production code. Anyone writing a validation rule for an email, a PAN or a phone number and needing to see what it rejects. Engineers debugging a regex that works on one string and silently fails on another. Learners watching which part of the text each group actually captures.

Regex Tester Features

Live Matching: See matches highlighted in real-time as you type
Match Details: View all matches with groups and index positions
Common Patterns: Quick-insert presets for email, URL, phone, IP, date
Flag Support: Toggle global, case-insensitive, multiline, dotAll flags

How to Use Regex Tester

Test regex patterns in three steps

Enter Pattern: Type your regex or pick a common preset
Enter Test String: Paste text to test against
View Matches: See highlighted matches and group details

Frequently Asked Questions

Is this regex tester free?

Yes, test unlimited patterns with no signup. Live matching, capture group extraction, flag toggles (g/i/m/s), common presets (email, URL, phone), and match details are all free - powered by JavaScript's native RegExp engine.

Which regex engine does it use?

JavaScript's built-in RegExp engine - the same one used in browsers and Node.js. Syntax may differ slightly from PCRE (PHP/Python).

What flags are supported?

Global (g), case-insensitive (i), multiline (m), dotAll (s), unicode (u) and sticky (y). Toggle them with the flag buttons.

Does it show capture groups?

Yes! Each match shows its captured groups with labels (Group 1, Group 2, etc.) along with the full match and index position.

What common patterns are included?

Email, URL, phone (India), phone (E.164), IPv4, date (DD/MM/YYYY), hex color, HTML tags, and numbers. Click any preset to auto-fill the pattern.

Is my test data safe?

Yes, everything runs locally in your browser. No data is sent to any server.

Related: regex tester, regex debugger, regular expression tester, regex pattern tester, javascript regex tester, regex match tester

3-step workflow · live

Test a regular expression in three steps

From a pattern to checked matches without writing a test file. No sign-up and nothing to install.

STEP 01
Type a pattern
Write your regex between the slashes, or load one of the common patterns.
No slashes needed
STEP 02
Paste sample text
Use real data: a log line, a form value or an API response.
Edge cases included
STEP 03
Read the matches
Every match is highlighted, with its index and capture groups listed below.
Updates as you type

Guide

How to use this regex tester

The tester runs your pattern on the JavaScript RegExp engine, the one your browser and Node.js use.

Runs in your browser: your pattern and text never leave the page

1
Write the pattern
Type it without the surrounding slashes. A red note explains any syntax error straight away.
2
Set the flags
Turn on g for every match, i to ignore case, m for line anchors, s, u or y when you need them.
3
Check the details
Each match shows its position, length, numbered groups and named groups.
4
Try a replacement
Type a replacement such as $1 to preview the text after String.replace, then copy it.

Guide

What makes a regex reliable

Four habits that separate a pattern that works today from one that keeps working.

Test data

Test the near misses

A pattern that matches good input is half done. It must also reject the input that is almost right.

Valid examples
Almost-valid examples
Empty and very long input

Anchors

Anchor validation

Without ^ and $, a validation pattern passes any text that merely contains a match.

^ at the start
$ at the end
m flag for each line

Quantifiers

Be specific

Broad pieces like .* match more than you expect. Name the characters you actually want.

[0-9] over .
{2,4} over +
Lazy *? when needed

Readability

Name your groups

(?<year>\d{4}) explains itself. Group 3 doesn't, six months later.

(?<name>...)
Comment in code
Split huge patterns

Syntax

The four building blocks of a pattern

Almost every regular expression is made of these pieces.

Characters

Classes

Match one character from a set: \d is a digit, \w a word character, [aeiou] a vowel.

\d \w \s
[a-z] ranges
[^...] negates

How many

Quantifiers

Say how many times the piece before repeats. They are greedy unless you add ?.

* + ?
{n} {n,} {n,m}
*? +? for lazy

Capture

Groups

Brackets group pieces and capture what they matched, numbered from 1.

(...) captures
(?:...) doesn't
(?<name>...) named

Position

Anchors and lookarounds

Match a position, not a character: the start, the end, a word edge, or what comes next.

^ $ \b
(?=...) lookahead
(?<=...) lookbehind

Guide

Where regex earns its keep

Different jobs, same idea: describe text precisely enough for a machine to find it.

Web developers

Validation

Form fields, URL routes and input cleaning all lean on short, well-tested patterns.

Good habit: anchor with ^ and $ · test bad input · keep it short

Sysadmins and DevOps

Logs

Pulling errors, IPs and request IDs out of logs is regex work, before it goes into grep or a log tool.

Good habit: test on real lines · check the tool's regex flavour

Data teams

Cleaning

Extracting codes, dates and numbers from messy text columns before analysis.

Good habit: named groups · replace preview · spot-check rows

QA engineers

Assertions

Checking that responses contain the right shape of data without hard-coding values.

Good habit: match the format, not the value · cover edge cases

The engine

How JavaScript regex behaves

This tester uses JavaScript's RegExp, so these rules apply to every result you see.

The rules

What the JavaScript engine does by default.

Stops at the first match unless g is on
Case-sensitive unless i is on
. skips newlines unless s is on
Quantifiers are greedy by default
Named groups use (?<name>...)

The six flags here

Each flag changes how the whole pattern runs.

g: Find every match, not just the first
i: Ignore upper and lower case
m: ^ and $ match at each line
s: . also matches newlines
u: Full Unicode, \p{...} escapes
y: Match only at the current position

Common mistakes

These make a pattern match too much, too little, or slowly.

Forgetting to escape . in a domain
No ^ and $ on a validation pattern
Greedy .* swallowing the rest of the line
Nested quantifiers like (a+)+
Copying Python syntax like (?P<name>)

Guide

Keeping patterns healthy in a codebase

A regex is code. Treat it like code and it stays readable.

1
Keep the test text
Save the sample text you tested with next to the pattern, ideally as a unit test.
2
Comment what it means
A one-line comment saying what the pattern accepts saves the next person from decoding it.
3
Reuse, don't retype
Put shared patterns such as email or phone in one place, so a fix lands everywhere.
4
Re-test on change
After any edit, paste the old test text back in and check nothing that passed now fails.

Compare

This tester vs the browser console vs a desktop regex tool

All three can test a pattern. The difference is how much you see at once.

Feature	CleverTools tester	Browser console	Desktop regex tools
Live highlighting	✓ As you type	✗ Run by hand	✓ Usually
Groups listed per match	✓ Numbered and named	Inspect arrays	✓ Usually
Engine	✓ JavaScript	✓ JavaScript	Often several flavours
Python or PCRE syntax	✗ JavaScript only	✗ No	✓ Often
Works on a phone	✓ Yes	✗ No	✗ No
Data leaves your device	✓ Never	✓ Never	✓ Never

Cleaning JSON after you extract it? Format and check it with the JSON Formatter.

Pro tips

Pro tips for faster, safer patterns

Small habits that prevent the classic regex bugs.

Escape the dot

In example.com the dot matches any character. Write example\.com to match a real dot.

Anchor validators

^\d{6}$ checks the whole value is six digits. Without anchors, abc123456xyz passes.

Use lazy when needed

<.+?> stops at the first >, where <.+> runs to the last one on the line.

Avoid nested repeats

Patterns like (a+)+ can take a very long time on text that almost matches.

Skip unused captures

Use (?:...) for grouping you don't need to read back. It keeps group numbers tidy.

Preview replacements

Test $1 and $<name> here before running a find-and-replace across a codebase.

Don't over-validate email

A simple pattern plus a confirmation email beats a giant pattern that rejects real addresses.

Strip, then match

Remove spaces and dashes from phone numbers first, then validate the digits that are left.

Pro tip: check the flavour before you paste

Python writes named groups as (?P<name>...) and JavaScript as (?<name>...). Patterns copied between languages often fail on small differences like this, so test them in the engine you will actually run.

Quantifiers

Greedy or lazy? Which quantifier to use

Both repeat the piece before them. They differ in whether they grab as much text as they can, or as little.

Default · grabs the most

.*greedy

Greedy: * + {n,}

Matches as much as it can, then gives back only what it must. On <b>bold</b>, the pattern <.*> matches the whole string.

Right when you want everything up to the last delimiter

Add ? · takes the least

.*?lazy

Lazy: *? +? {n,}?

Matches as little as it can. On the same text, <.*?> matches <b> and then </b> as two separate matches with the g flag.

Right when you want each delimited piece on its own

TagsLazy: <.+?> one tag at a time.

Quoted textBetter: "[^"]*" with no dot at all.

Rest of lineGreedy: .* after a fixed prefix.

Every timeTest both on your real text here.

Verdict: reach for a negated class like [^>]* first, then lazy quantifiers. Paste both into the studio above and compare the highlights.

Use cases

Who uses this regex tester

Six everyday jobs that start with a pattern.

Form validation

Check email, phone, PIN code and PAN patterns against good and bad samples.

Log digging

Pull request IDs, IP addresses or error codes out of a pasted block of logs.

Find and replace

Preview a codebase-wide replacement with $1 groups before you run it.

Data cleaning

Extract dates, amounts or codes from messy text exported from a spreadsheet.

Writing tests

Build the assertion pattern for an API response and see it match.

Learning regex

Load a preset, change one character and watch exactly what changes.

Working with timestamps in logs? Read them with the Unix Timestamp Converter.

FAQ

Frequently asked questions

Quick answers about the engine, flags and capture groups.

Is this regex tester free?

Which regex engine does it use?

JavaScript's built-in RegExp engine - the same one used in browsers and Node.js. Syntax may differ slightly from PCRE (PHP/Python).

What flags are supported?

Global (g), case-insensitive (i), multiline (m), dotAll (s), unicode (u) and sticky (y). Toggle them with the flag buttons.

Does it show capture groups?

Yes! Each match shows its captured groups with labels (Group 1, Group 2, etc.) along with the full match and index position.

What common patterns are included?

Email, URL, phone (India), phone (E.164), IPv4, date (DD/MM/YYYY), hex color, HTML tags, and numbers. Click any preset to auto-fill the pattern.

Is my test data safe?

Yes, everything runs locally in your browser. No data is sent to any server.

Reviews

What people say

Reviews from people who used this tool.

Loading reviews…

Presets

Popular presets

Jump to a version of this tool already set up for a specific need.

Who Uses Regex Tester

Frequently Asked Questions

Is this regex tester free?

Which regex engine does it use?

JavaScript's built-in RegExp engine - the same one used in browsers and Node.js. Syntax may differ slightly from PCRE (PHP/Python).

What flags are supported?

Global (g), case-insensitive (i), multiline (m), dotAll (s), unicode (u) and sticky (y). Toggle them with the flag buttons.

Does it show capture groups?

Yes! Each match shows its captured groups with labels (Group 1, Group 2, etc.) along with the full match and index position.

What common patterns are included?

Email, URL, phone (India), phone (E.164), IPv4, date (DD/MM/YYYY), hex color, HTML tags, and numbers. Click any preset to auto-fill the pattern.

Is my test data safe?

Yes, everything runs locally in your browser. No data is sent to any server.

Feature

CleverTools tester

Browser console

Desktop regex tools

Live highlighting

✓ As you type

✗ Run by hand

✓ Usually

Groups listed per match

✓ Numbered and named

Inspect arrays

✓ Usually

Engine

✓ JavaScript

Often several flavours

Python or PCRE syntax

✗ JavaScript only

✗ No

✓ Often

Works on a phone

✓ Yes

✗ No

Data leaves your device

✓ Never

Developer tool · Free

Regex Tester: Live Matches, Groups and Flags

Type a regular expression and see every match highlighted as you type, with capture groups, flags and a replace preview. Runs on the JavaScript RegExp engine in your browser.

Regex Studio

Pattern · flags · live matches · groups · replace

Runs in your browser Free · No sign-up

Pattern and text

Regular expression

Test string

3 lines · 147 chars

Flags

Uses the JavaScript RegExp engine. A 2 second limit guards against catastrophic backtracking.

Common patterns

Replace with (optional)

Shows the text after String.replace. Use $1, $2 or $<name> for groups.

Matches

Groups

Flags

Highlighted text

Hello world! Contact us at support@example.com or sales@company.org.
Visit https://clevertools.in for free tools.
Call +91 98765 43210 for support.

Match details

Type a pattern or pick a common one. Matches appear here as you type.

No sign-up needed Nothing leaves your device Live as you type JavaScript RegExp engine

Flags to toggle: 6
Ready-made patterns: 9
Runaway pattern limit: 2s
Patterns sent anywhere: 0

Runs in your browserYour pattern and text are tested with the browser's own RegExp engine. Nothing is sent.

The real JS engineThe same RegExp your JavaScript and Node.js code use, so a match here matches there.

Runaway guardA 2 second limit and a 10,000 match cap stop a bad pattern from freezing the results.

Free, no sign-upNo account, no limits. Nine common patterns ready to load with one click.

What's next

More tools for text and code

Tools that pick up where this one leaves off.

Regex Tester - Free Online Tool

Test a regular expression in three steps

Type a pattern

Paste sample text

Read the matches

How to use this regex tester

Write the pattern

Set the flags

Check the details

Try a replacement

What makes a regex reliable

Test the near misses

Anchor validation

Be specific

Name your groups

The four building blocks of a pattern

Classes

Quantifiers

Groups

Anchors and lookarounds

Where regex earns its keep

Web developers

Sysadmins and DevOps

Data teams

QA engineers

How JavaScript regex behaves

The rules

The six flags here

Common mistakes

Keeping patterns healthy in a codebase

Keep the test text

Comment what it means

Reuse, don't retype

Re-test on change

This tester vs the browser console vs a desktop regex tool

Pro tips for faster, safer patterns

Escape the dot

Anchor validators

Use lazy when needed

Avoid nested repeats

Skip unused captures

Preview replacements

Don't over-validate email

Strip, then match

Greedy or lazy? Which quantifier to use

Greedy: * + {n,}

Lazy: *? +? {n,}?

Who uses this regex tester

Form validation

Log digging

Find and replace

Data cleaning

Writing tests

Learning regex

Frequently asked questions

What people say

Popular presets

More free developer tools

Regex Tester - Free Online Tool

Regex Studio

Pattern and text

Flags

Common patterns

Matches

More tools for text and code

Test a regular expression in three steps

Type a pattern

Paste sample text

Read the matches

How to use this regex tester

Write the pattern

Set the flags

Check the details

Try a replacement

What makes a regex reliable

Test the near misses

Anchor validation

Be specific

Name your groups

The four building blocks of a pattern