Regex Check Online — Regular Expression Tester & Debugger

Free regex check online tool with real-time match highlighting, capture group inspection, and flag support. Test JavaScript regex, Ruby regex patterns, and more — paste your pattern and test string to see matches instantly.

Regex Tester: Use this regex check online tool to enter a regex pattern and test string — see matches highlighted instantly. Supports JavaScript regex syntax with flags (g, i, m, s). Also useful as a Ruby regex test tool since most basic patterns are cross-compatible. View capture groups, match indices, and replacement results.

Loading Tool...

This tool requires JavaScript to run.

Please enable JavaScript in your browser to use this free online tool. All processing happens locally in your browser for maximum privacy and speed.

Key Takeaways

Real-time match highlighting as you type the pattern
Supports JavaScript regex flags: global (g), case-insensitive (i), multiline (m)
Shows numbered capture groups and named groups
Test replacement patterns with $1, $2 backreferences
Common patterns: email, URL, phone, IP address, date formats

What is Regex Tester?

Regex Tester — A regex check online tool (regex tester) is a free utility that lets you write, test, and debug regular expressions against sample text with real-time match highlighting. Works for JavaScript, Ruby regex test, Python, and other flavors.

Regex check online — test and debug regular expressions with this free regex tester. Enter your regex pattern and test string to see matches highlighted in real time as you type. The tool supports JavaScript regex syntax with all flags — global (g), case-insensitive (i), multiline (m), dotAll (s), and unicode (u). Also works as a Ruby regex test tool since most standard regex patterns (character classes, quantifiers, anchors, groups) are compatible across JavaScript and Ruby. Inspect numbered and named capture groups, view match indices, and test replacement patterns with backreferences ($1, $2). Useful for building form validation rules, log parsing patterns, text extraction logic, and search-and-replace operations before adding them to your code.

How to Use Regex Tester

1
Enter your regular expression pattern in the regex input field.
2
Paste or type the test string you want to match against.
3
Toggle regex flags (global, case-insensitive, multiline) as needed.
4
Review highlighted matches, capture groups, and match indices — refine your pattern until it works correctly.

Key Features

Real-time match highlighting as you type the pattern

Full JavaScript regex flag support: g, i, m, s, u, y

Numbered and named capture group inspection

Match index positions shown for each match

Replacement pattern testing with $1, $2 backreferences

100% client-side — no data sent to any server

Use Cases

Build and test form validation patterns (email, phone, URL, password)

Create log parsing regex for extracting timestamps, IPs, and error codes

Design search-and-replace rules for text processing pipelines

Validate data extraction patterns before deploying to production

Debug why a regex pattern is not matching expected input

About Regex Tester

What Are Regular Expressions?

Regular expressions (regex) are a domain-specific language for pattern matching in text. Invented in the 1950s by mathematician Stephen Cole Kleene, they were first implemented in Unix tools like grep in the 1970s. Today, regex is built into every major programming language (JavaScript, Python, Java, Go, Rust, PHP, Ruby) and every text editor (VS Code, Sublime, vim, Emacs). A regex pattern describes what text looks like — not the exact text — letting you match, extract, validate, or replace based on structure.

Essential Regex Syntax Reference

Pattern	Matches	Example
`.`	Any single character (except newline)	`c.t` matches cat, cut, c8t
`\d`	Any digit 0-9	`\d\d` matches 42, 99
`\w`	Word char (a-z, A-Z, 0-9, _)	`\w+` matches hello_world
`\s`	Whitespace (space, tab, newline)	`a\sb` matches "a b"
`[abc]`	Character class (a OR b OR c)	`[aeiou]` matches vowels
`[^abc]`	Negated class (NOT a, b, or c)	`[^0-9]` = non-digit
`*`	0 or more (greedy)	`a*` matches "", "a", "aaa"
`+`	1 or more (greedy)	`a+` matches "a", "aaa"
`?`	0 or 1 (optional)	`colou?r` matches color/colour
`{n}`	Exactly n	`\d{3}` matches 3 digits
`{n,m}`	Between n and m (inclusive)	`\d{3,5}` = 3-5 digits
`^` / `$`	Start / end of string (or line w/ m flag)	`^abc$` exact match
`(abc)`	Capture group	`(\d+)-(\d+)` captures both
`(?:abc)`	Non-capturing group	`(?:ab)+` repeated ab
`(?<name>abc)`	Named capture group	`(?<year>\d{4})`
`a\|b`	Alternation (a OR b)	`cat\|dog`
`(?=abc)`	Positive lookahead	`\d(?=px)` = digit before px
`(?<=abc)`	Positive lookbehind (ES2018+)	`(?<=$)\d+` = price digits

Common Regex Patterns Library

Email (simple): ^[\w.-]+@[\w.-]+\.\w+$
Email (RFC 5322 strict): see emailregex.com — too long to display
URL: ^https?://[^\s/$.?#].[^\s]*$
IPv4: ^(\d{1,3}\.){3}\d{1,3}$ (basic; doesn't validate octets ≤ 255)
Phone (US): ^$?\d{3}$?[\s.-]?\d{3}[\s.-]?\d{4}$
Date (YYYY-MM-DD): ^\d{4}-\d{2}-\d{2}$
Hex color: ^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$
UUID v4: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
Strong password: (?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&]).{8,}
Slug: ^[a-z0-9]+(?:-[a-z0-9]+)*$
Username (3-20 chars, alphanumeric + underscore): ^\w{3,20}$
Credit card (basic): ^\d{13,19}$ (then Luhn check)
Markdown link: \[([^\]]+)\]$([^)]+)$
HTML tag: <[^>]+> (don't parse HTML with regex for real apps)

Greedy vs Lazy Quantifiers

By default, regex quantifiers (*, +, ?, {n,m}) are greedy — they match as much text as possible. Add a ? after them to make them lazy — match as little as possible. Example:

Greedy: <.*> applied to <a>text</a> matches the ENTIRE string
Lazy: <.*?> matches just <a> first, then </a> separately

Use lazy quantifiers when you want the shortest match. They're critical for parsing structured text like HTML tags, JSON values, or string-delimited tokens.

Catastrophic Backtracking (The Performance Killer)

Some regex patterns can cause exponential runtime on certain inputs — this is called catastrophic backtracking. The engine tries every possible combination of matches, and on certain strings it explodes to seconds, minutes, or hours of CPU. The classic example: (a+)+b applied to aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac (note the trailing c, not b). It will hang for several seconds before failing.

Avoid: nested quantifiers like (a+)+, (a*)*, (a|aa)+. Mitigate: use possessive quantifiers (a++, not in JS), atomic groups ((?>...), not in JS), or rewrite to avoid ambiguity. This is a real security issue: ReDoS (Regular Expression Denial of Service) attacks exploit slow regex in production code. Always test regex with adversarial inputs.

Cross-Language Regex Differences

Feature	JavaScript	Python	PCRE / PHP
Lookbehind	ES2018+ (variable length OK)	Yes (fixed length only)	Yes
Named groups syntax	`(?<name>...)`	`(?P<name>...)`	`(?<name>...)` or `(?P<name>...)`
Atomic groups	No	No	`(?>...)`
Possessive quantifiers	No	No (use atomic group)	`++`, `*+`, `?+`
Recursion	No	No (regex), yes (re2)	Yes `(?R)`
Unicode property classes	`\p{...}` with /u flag	Yes	Yes

Regex vs Alternatives

Parsing HTML/XML: use a real parser (cheerio, BeautifulSoup, xml2js). Regex can't handle nested tags correctly.
Parsing JSON: use the JSON parser, not regex. JSON has recursive structure regex can't express.
Parsing programming languages: use a real parser (AST tools). Regex breaks on edge cases.
Simple string operations (replace, split, contains): regex is overkill; use string methods.
Database queries with patterns: use LIKE / ILIKE with % wildcards, or full-text search.
When to use regex: validation rules, log parsing, simple search-and-replace, extracting fields from structured strings, syntax highlighting tokens.

Frequently Asked Questions

What regex syntax does this tester support?: It uses JavaScript's native RegExp engine, supporting all standard regex syntax including character classes, quantifiers, lookaheads, lookbehinds (ES2018+), named capture groups, and Unicode property escapes.
What regex flags are available?: All JavaScript regex flags: g (global — find all matches), i (case-insensitive), m (multiline — ^ and $ match line boundaries), s (dotAll — . matches newlines), u (unicode), and y (sticky).
How do I test capture groups?: Add parentheses in your pattern to create capture groups. The tool displays all captured values with their group numbers. For named groups, use (?<name>pattern) syntax and the tool shows the group names.
Can I test regex replacement patterns?: Yes. Enter a replacement string using $1, $2 backreferences for captured groups, or $& for the full match. The tool shows the replacement result in real time.
Can I use this as a Ruby regex test tool?: Yes. Most standard regex patterns work the same in Ruby and JavaScript — character classes, quantifiers, anchors, and groups are cross-compatible. This regex check online tool is ideal for testing Ruby regex patterns. Note that Ruby-specific features like \p{Hiragana} or (?<name>) named groups have slightly different syntax.
Will my regex work the same in Python or Java?: Regex syntax varies between languages. This tester uses JavaScript regex. Most basic patterns work cross-language, but features like lookbehinds, named groups, and flags may differ in Python, Java, Ruby, or Go.
Is this regex tester free?: Yes. Completely free, runs locally in your browser, and has no limits on pattern testing or registration requirements.
Is this a Ruby regex tester?: It tests JavaScript regex by default (the regex engine that powers Node.js, web browsers, and most online editors). Ruby regex (Oniguruma engine) is mostly compatible — the same patterns for character classes, quantifiers, anchors, and alternation work in both. The main Ruby-specific extras the JS engine doesn't natively support are named captures with /(?<name>pattern)/ syntax (works in modern JS too), POSIX character classes [:alpha:], and Ruby-only flags like /m for multiline-anything (in Ruby /m means 'dot matches newline', in JS the same flag means 'multiline anchors'). For Ruby-exclusive features, test patterns in irb or rubular.com after prototyping here.
What's the difference between JavaScript, Ruby, PCRE, and Python regex?: All four are descendants of Perl-compatible regex with mostly overlapping syntax. JavaScript regex is the smallest set (no named captures historically, no lookbehind until ES2018, no \K reset). Ruby uses Oniguruma which adds Unicode property classes \p{...}, advanced quantifiers, and named captures. PCRE (used in PHP, nginx, R) is the most feature-complete — recursive patterns, conditionals, backreferences. Python's re module sits between PCRE and JS. For maximum portability, stick to the common subset: basic character classes, quantifiers, anchors, and alternation.
How do I test a regex online?: Paste your pattern in the regex field above and your test string in the input field. Matches are highlighted in real time. You can toggle flags (g for global, i for case-insensitive, m for multiline, s for dotall, u for unicode, y for sticky). For step-through debugging, regex101.com shows match-by-match execution; this tool focuses on quick verification.

Loading your tools...

Use Cases

Build and test form validation patterns (email, phone, URL, password)

Create log parsing regex for extracting timestamps, IPs, and error codes

Design search-and-replace rules for text processing pipelines

Validate data extraction patterns before deploying to production

Debug why a regex pattern is not matching expected input

Pattern

Matches

Example

.

Any single character (except newline)

c.t matches cat, cut, c8t

\d

Any digit 0-9

\d\d matches 42, 99

\w

Word char (a-z, A-Z, 0-9, _)

\w+ matches hello_world

\s

Whitespace (space, tab, newline)

a\sb matches "a b"

[abc]

Character class (a OR b OR c)

[aeiou] matches vowels

[^abc]

Negated class (NOT a, b, or c)

[^0-9] = non-digit

*

0 or more (greedy)

a* matches "", "a", "aaa"

+

1 or more (greedy)

a+ matches "a", "aaa"

?

0 or 1 (optional)

colou?r matches color/colour

{n}

Exactly n

\d{3} matches 3 digits

{n,m}

Between n and m (inclusive)

\d{3,5} = 3-5 digits

^ / $

Start / end of string (or line w/ m flag)

^abc$ exact match

(abc)

Capture group

(\d+)-(\d+) captures both

(?:abc)

Non-capturing group

(?:ab)+ repeated ab

(?<name>abc)

Named capture group

(?<year>\d{4})

a|b

Alternation (a OR b)

cat|dog

(?=abc)

Positive lookahead

\d(?=px) = digit before px

(?<=abc)

Positive lookbehind (ES2018+)

(?<=$)\d+ = price digits

Feature

JavaScript

Python

PCRE / PHP

Lookbehind

ES2018+ (variable length OK)

Yes (fixed length only)

Yes

Named groups syntax

(?<name>...)

(?P<name>...)

(?<name>...) or (?P<name>...)

Atomic groups

(?>...)

Possessive quantifiers

No (use atomic group)

++, *+, ?+

Recursion

No (regex), yes (re2)

Yes (?R)

Unicode property classes

\p{...} with /u flag

Yes

Frequently Asked Questions

What regex syntax does this tester support?

It uses JavaScript's native RegExp engine, supporting all standard regex syntax including character classes, quantifiers, lookaheads, lookbehinds (ES2018+), named capture groups, and Unicode property escapes.

What regex flags are available?

All JavaScript regex flags: g (global — find all matches), i (case-insensitive), m (multiline — ^ and $ match line boundaries), s (dotAll — . matches newlines), u (unicode), and y (sticky).

How do I test capture groups?

Add parentheses in your pattern to create capture groups. The tool displays all captured values with their group numbers. For named groups, use (?<name>pattern) syntax and the tool shows the group names.

Can I test regex replacement patterns?

Yes. Enter a replacement string using $1, $2 backreferences for captured groups, or $& for the full match. The tool shows the replacement result in real time.

Can I use this as a Ruby regex test tool?

Yes. Most standard regex patterns work the same in Ruby and JavaScript — character classes, quantifiers, anchors, and groups are cross-compatible. This regex check online tool is ideal for testing Ruby regex patterns. Note that Ruby-specific features like \p{Hiragana} or (?<name>) named groups have slightly different syntax.

Will my regex work the same in Python or Java?

Regex syntax varies between languages. This tester uses JavaScript regex. Most basic patterns work cross-language, but features like lookbehinds, named groups, and flags may differ in Python, Java, Ruby, or Go.

Is this regex tester free?

Yes. Completely free, runs locally in your browser, and has no limits on pattern testing or registration requirements.

Is this a Ruby regex tester?

It tests JavaScript regex by default (the regex engine that powers Node.js, web browsers, and most online editors). Ruby regex (Oniguruma engine) is mostly compatible — the same patterns for character classes, quantifiers, anchors, and alternation work in both. The main Ruby-specific extras the JS engine doesn't natively support are named captures with /(?<name>pattern)/ syntax (works in modern JS too), POSIX character classes [:alpha:], and Ruby-only flags like /m for multiline-anything (in Ruby /m means 'dot matches newline', in JS the same flag means 'multiline anchors'). For Ruby-exclusive features, test patterns in irb or rubular.com after prototyping here.

What's the difference between JavaScript, Ruby, PCRE, and Python regex?

All four are descendants of Perl-compatible regex with mostly overlapping syntax. JavaScript regex is the smallest set (no named captures historically, no lookbehind until ES2018, no \K reset). Ruby uses Oniguruma which adds Unicode property classes \p{...}, advanced quantifiers, and named captures. PCRE (used in PHP, nginx, R) is the most feature-complete — recursive patterns, conditionals, backreferences. Python's re module sits between PCRE and JS. For maximum portability, stick to the common subset: basic character classes, quantifiers, anchors, and alternation.

How do I test a regex online?

Paste your pattern in the regex field above and your test string in the input field. Matches are highlighted in real time. You can toggle flags (g for global, i for case-insensitive, m for multiline, s for dotall, u for unicode, y for sticky). For step-through debugging, regex101.com shows match-by-match execution; this tool focuses on quick verification.

Regex Check Online — Regular Expression Tester & Debugger

Key Takeaways

What is Regex Tester?

How to Use Regex Tester

Key Features

Use Cases

About Regex Tester

What Are Regular Expressions?

Essential Regex Syntax Reference

Common Regex Patterns Library

Greedy vs Lazy Quantifiers

Catastrophic Backtracking (The Performance Killer)

Cross-Language Regex Differences

Regex vs Alternatives

Frequently Asked Questions

Regex Check Online — Regular Expression Tester & Debugger

Quick Pattern Templates

Key Takeaways

What is Regex Tester?

How to Use Regex Tester

Key Features

Use Cases

About Regex Tester

What Are Regular Expressions?

Essential Regex Syntax Reference

Common Regex Patterns Library

Greedy vs Lazy Quantifiers

Catastrophic Backtracking (The Performance Killer)

Cross-Language Regex Differences

Regex vs Alternatives

Frequently Asked Questions

Quick Pattern Templates

Tools

Finance

AI

Media

Marketing

More

Regex Check Online — Regular Expression Tester & Debugger

Key Takeaways

What is Regex Tester?

How to Use Regex Tester

Key Features

Use Cases

About Regex Tester

What Are Regular Expressions?

Essential Regex Syntax Reference

Common Regex Patterns Library

Greedy vs Lazy Quantifiers

Catastrophic Backtracking (The Performance Killer)

Cross-Language Regex Differences

Regex vs Alternatives

Frequently Asked Questions

Regex Check Online — Regular Expression Tester & Debugger

Quick Pattern Templates

Key Takeaways

What is Regex Tester?

How to Use Regex Tester

Key Features

Use Cases

About Regex Tester

What Are Regular Expressions?

Essential Regex Syntax Reference

Common Regex Patterns Library

Greedy vs Lazy Quantifiers

Catastrophic Backtracking (The Performance Killer)

Cross-Language Regex Differences

Regex vs Alternatives

Frequently Asked Questions

Quick Pattern Templates