Guides · Encoding

Regex Tester Online: The Complete Guide

Learn how to write and test regular expressions, understand common regex syntax, use flags, and build practical patterns for validation and parsing.

Last updated: May 4, 2026

What is a regex tester online?

A regex tester online lets you write a regular expression pattern, paste test input, and instantly see which parts of the text match — with visual highlighting, match groups, and flag controls. Instead of running code in an IDE or terminal to test a regex, you iterate directly in the browser: modify the pattern, see the result, refine, repeat.

Regular expressions (regex or regexp) are sequences of characters that define a search pattern. They are used in almost every programming language for string validation, search and replace, parsing, and text extraction. A regex tester makes the development and debugging of patterns dramatically faster.

Regex syntax quick reference

.Any character except newline
\dAny digit (0–9)
\wWord character (letters, digits, underscore)
\sWhitespace (space, tab, newline)
\D \W \SNegation of \d, \w, \s
^Start of string (or line in multiline mode)
$End of string (or line in multiline mode)
*Zero or more (greedy)
+One or more (greedy)
?Zero or one (makes quantifiers lazy when after * + {})
{n}Exactly n repetitions
{n,m}Between n and m repetitions
[abc]Character class: a, b, or c
[^abc]Negated class: anything except a, b, or c
a|bAlternation: a or b
(abc)Capturing group
(?:abc)Non-capturing group
(?=abc)Positive lookahead: followed by abc
(?!abc)Negative lookahead: not followed by abc

Regex flags

g (global)

Find all matches, not just the first. Essential when you want to count or replace all occurrences.

i (case-insensitive)

Match regardless of uppercase or lowercase. /hello/i matches "Hello", "HELLO", "hello".

m (multiline)

Makes ^ and $ match the start and end of each line, not just the entire string.

s (dotAll)

Makes . match newlines as well. Without this flag, . skips \n.

u (unicode)

Enables full Unicode matching, including surrogate pairs and Unicode property escapes.

Practical regex patterns

Email address validation (simple)

/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/

Matches most common email formats. Note: the only RFC 5321-compliant email validator is a full parser. This pattern handles 99% of real-world inputs but is not specification-perfect.

UUID v4

/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i

IPv4 address

/^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$/

ISO 8601 date

/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2}))?$/

Slug (URL-safe string)

/^[a-z0-9]+(?:-[a-z0-9]+)*$/

Hex color code

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

Common regex mistakes

Forgetting to escape special characters

The characters . * + ? ^ $ { } [ ] | ( ) / are special in regex. To match them literally, escape with a backslash: \. matches a literal dot, \( matches a literal parenthesis.

Greedy vs lazy quantifiers

.* is greedy — it matches as much as possible. .*? is lazy — it matches as little as possible. In HTML parsing, <.*> matches everything from the first < to the last > on the line. Use <.*?> to match each tag individually.

Missing anchors

/\d+/ matches any sequence of digits inside a larger string, including abc123def. To validate that the entire string is digits, anchor it: /^\d+$/.

Catastrophic backtracking

Patterns like /(a+)+$/ can cause exponential backtracking on no-match inputs, hanging applications — a vulnerability called ReDoS. Avoid nested quantifiers on overlapping patterns. Use possessive quantifiers or atomic groups where available.

Frequently asked questions

Are regex patterns the same in all languages?

The core syntax is similar across languages (PCRE-based: JavaScript, Python, PHP, Go) but there are differences. Python uses re module syntax; JavaScript uses /pattern/flags literals; Go uses RE2 (no backreferences). Always test in the target language.

What is the difference between match and search?

In Python: re.match() only matches at the start of the string. re.search() scans the entire string for the pattern. re.fullmatch() requires the pattern to match the entire string. Most other languages use a single match method with ^ and $ anchors.

Should I use regex for HTML or JSON parsing?

No. Use a proper HTML parser (DOMParser, Beautiful Soup) for HTML and JSON.parse()for JSON. Regex cannot reliably handle nested structures. The JSON Formatter parses and formats JSON correctly where regex would fail.

What are named capture groups?

Named capture groups let you refer to matches by name instead of index: /(?<year>\d{4})-(?<month>\d{2})/. Access with match.groups.year in JavaScript. Much more readable than match[1].

What is lookahead and lookbehind?

Lookahead ((?=...)) asserts that what follows matches without consuming characters. Lookbehind ((?<=...)) asserts what precedes. Example: /\d+(?= USD)/matches numbers followed by " USD" without including the currency in the match.

Try the tools

Related guides