Regex Generator

A regular expression (regex or regexp) is a sequence of characters that defines a search pattern. Developers use regex patterns to validate input, search text, extract data, and perform find-and-replace operations across virtually every programming language and platform. Whether you need to confirm that a user has entered a valid email address, a properly formatted phone number, or a strong password, a well-crafted regex pattern is the most concise and reliable tool for the job.

Regex originated in formal language theory and was popularized by Unix text-processing utilities like grep, sed, and awk in the 1970s. Today, every modern language — JavaScript, Python, Java, PHP, Go, Rust — ships with a built-in regex engine. Because the core syntax is largely standardized (with minor dialect variations), a pattern you learn once transfers across ecosystems.

The regex generator on this page gives you two modes. The Common Patterns selector provides production-ready patterns for the most frequently validated data types: email addresses, URLs, US and international phone numbers, IPv4 and IPv6 addresses, ISO and US date formats, 24-hour time, hex color codes, credit card numbers, Social Security Numbers, ZIP codes, usernames, strong passwords, URL slugs, UUIDs, and HTML tags. Each pattern is displayed alongside its plain-English description and concrete matching examples so you can verify it fits your use case before copying it into your codebase.

The Custom Pattern Builder lets you craft a bespoke regex without memorizing metacharacter syntax. Specify a required prefix, a required suffix, a required substring, minimum and maximum lengths, and the allowed character set. The tool assembles the pattern in real time, escaping any special characters in your literal text so the output is always safe to use directly.

The table below summarises the eighteen built-in patterns available in the Common Patterns selector. Each entry shows the pattern name, the raw regex, and the data it validates. Use this as a quick reference when you need to remember which pattern to reach for.

Copy any of these patterns directly from the generator and paste them into your code. They are ready to use as JavaScript RegExp objects, Python re module strings, or PHP preg_match calls with minimal adjustment for delimiter quoting.

The Custom Pattern Builder assembles a regex pattern from plain-English constraints, making it accessible to developers who are not yet fluent in regex metacharacter syntax. Understanding the assembly logic helps you predict the output and troubleshoot edge cases.

Step 1 — Character Class

The Allowed Characters dropdown maps to one of four character classes:

• Letters only → a-zA-Z — matches any uppercase or lowercase ASCII letter
• Numbers only → 0-9 — matches any decimal digit
• Alphanumeric → a-zA-Z0-9 — matches letters and digits
• Any character → . — matches any character except a newline (unless the dotall flag is set)

Step 2 — Quantifier

When Min Length and/or Max Length are provided, a bounded quantifier {min,max} is appended to the character class. If only Min Length is set, Max Length defaults to empty (unlimited). If neither is set, the quantifier * (zero or more) is used. For example, Min Length 5 and Max Length 12 with alphanumeric characters produces [a-zA-Z0-9]{5,12}.

Step 3 — Must Contain

When a Must Contain substring is provided, the character-class segment is replaced entirely by .*escape(contains).*. This ensures the literal text appears somewhere in the middle of the string. The Length constraints do not apply when Must Contain is active.

Step 4 — Anchors and Literals

The Starts With value is prepended (after escaping) immediately after the ^ anchor. The Ends With value is appended (after escaping) immediately before the $ anchor. Escaping converts any regex metacharacter in those literals — . * + ? ^ $ { } ( ) | [ ] — into its escaped form so it matches literally. For instance, entering v1.0 as a prefix yields v1.0 in the pattern.

The final pattern always wraps the whole expression in ^ and $ anchors, enforcing a full-string match rather than a substring match. Remove those anchors in your own code if you need to find patterns within a longer string.

Once you understand the building blocks of regex syntax, you can read, modify, and extend any pattern. The cheat sheet below covers the metacharacters and quantifiers used throughout the patterns on this page.

Anchors

• ^ — Asserts position at the start of the string (or line in multiline mode)
• $ — Asserts position at the end of the string (or line in multiline mode)
•  — Word boundary — the position between a word character and a non-word character

Character Classes

• \d — Any digit (equivalent to [0-9])
• w — Any word character (equivalent to [a-zA-Z0-9_])
• \s — Any whitespace character (space, tab, newline, etc.)
• [abc] — Matches any of the listed characters
• [^abc] — Matches any character NOT in the list (negated class)
• [a-z] — Matches any character in the specified range

Quantifiers

• * — Zero or more of the preceding element
• + — One or more of the preceding element
• ? — Zero or one of the preceding element (makes it optional)
• {n} — Exactly n repetitions
• {n,} — At least n repetitions
• {n,m} — Between n and m repetitions (inclusive)

Groups and Alternation

• (abc) — Capture group — matches the sequence and captures it for back-references
• (?:abc) — Non-capturing group — groups without creating a back-reference
• (?=abc) — Positive lookahead — asserts what follows without consuming characters
• (?!abc) — Negative lookahead — asserts the following text does NOT match
• a|b — Alternation — matches either a or b

The strong password pattern uses multiple positive lookaheads ((?=.*[a-z]), (?=.*[A-Z]), (?=.*\d), (?=.*[@$!%*?&])) to require each character category without enforcing a fixed order — a common and elegant pattern worth studying.

Copying a pattern from the generator is just the first step. Here is how to integrate it correctly in the three most common environments.

JavaScript / Node.js

Use the RegExp constructor or a regex literal. The regex literal form is more concise, but the constructor is required when the pattern is stored as a string:

• Literal: const emailRe = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}$/;
• Constructor: const emailRe = new RegExp('^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$');
• Test a value: emailRe.test(input) returns true or false

Note that backslashes must be doubled (\d instead of \d) when using the constructor form, because the string itself needs to escape the backslash before the regex engine sees it. The patterns displayed in this generator already use the string-safe double-backslash notation.

Python

Import the re module and use raw strings to avoid double-escaping: pattern = re.compile(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}$'). Then call pattern.match(input) for a full-string match or pattern.search(input)

PHP

A regex pattern is a powerful first line of defence for input validation, but it works best as part of a layered validation strategy rather than the sole gatekeeper.