Generate regular expressions from examples or descriptions. Build patterns for emails, URLs, phone numbers, dates and custom formats.
Use this free online Regex Generator directly in your browser. No signup required, no data leaves your device. Part of Utilier — a collection of 133+ developer utilities.
What is Regex Pattern Generator?
A regex (regular expression) pattern generator helps you build regex from examples or natural language descriptions rather than memorizing syntax. You provide sample text that should match (e.g., 'user@example.com'), and the tool generates a pattern (e.g., ^[\w.-]+@[\w.-]+\.) with an explanation of each part.
Common pattern templates: Provides pre-built patterns for emails, URLs, phone numbers, dates, IP addresses, credit cards, and other common formats. Select a template and customize it.
Example-driven generation: Paste multiple examples of text that should match, and the tool infers a pattern that captures the common structure (letters, digits, delimiters).
Pattern explanation: Each generated regex is broken down token by token: ^ (start), [\w.-]+ (one or more word characters, dots, or hyphens), etc.
Validation hints: Warns you about patterns that are too greedy (.* matches everything), too specific (only matches one exact string), or missing anchors (^ and $).
Escape handling: Automatically escapes special regex characters (. becomes \., + becomes \+, etc.) in literal parts of the pattern.
Why use regex generator?
Regex syntax is cryptic. Writing a pattern from memory is slow and error-prone, and testing every edge case takes multiple iterations. Generating a pattern from examples or templates gets you 80% of the way immediately.
Avoid syntax errors: Missing backslashes, unescaped dots, unbalanced brackets — regex syntax errors are common and hard to debug. Generated patterns are syntactically correct from the start.
Learn regex by example: See how examples map to patterns. If you input 'abc123', the generated pattern might be [a-z]{3}\d{3}, and the explanation shows why.
Save time on common formats: Email, URL, phone, IP address, date — these patterns are well-known but easy to get wrong. Templates give you production-ready patterns instantly.
Build complex patterns incrementally: Start with a simple pattern, test it, then add optional groups, lookaheads, or alternations as needed. Much easier than writing the full pattern upfront.
Runs locally: Nothing is uploaded. Your examples and generated patterns stay in the browser.
When to use regex generator
Use when you need a regex pattern but do not want to write it from scratch.
Building form validation patterns for emails, phone numbers, postal codes, or usernames.
Extracting structured data from logs, text files, or API responses (timestamps, IPs, error codes).
Learning regex syntax by seeing how examples translate to patterns.
Prototyping a pattern quickly before refining it with more specific constraints.
Generating search-and-replace patterns for editors or scripts.
Validating user input in real-time (password strength, URL format, etc.).
Debugging why a hand-written regex does not match expected input — compare with a generated pattern.
How to use regex generator
Provide examples or select a template, then refine the generated pattern.
Choose a template or enter examples: Select a common format (Email, URL, Phone, Date, IP) from the dropdown, or paste your own examples in the text area (one per line).
Generate the pattern: Press Generate Regex. The tool analyzes the examples and produces a regex pattern that matches them, with character classes ([a-z], \d), quantifiers (+, {3}), and anchors (^, $).
Read the explanation: Each part of the regex is explained: ^ (start of string), [\w.-]+ (one or more word chars, dots, or hyphens), @ (literal @), etc.
Test the pattern: Use the built-in tester (or the Regex Tester tool) to verify the pattern matches your examples and does not match unwanted strings.
Refine if needed: Add optional groups (?:...)?, lookaheads (?=...), or alternations (a|b) manually. The generated pattern is a starting point.
Copy the regex: Use the Copy button to get the pattern, ready for JavaScript, Python, PHP, or any regex engine.
Key features
Template library: Pre-built patterns for email, URL, phone (US/international), IP (v4/v6), date (ISO, US, EU), credit card, hex color, and more.
Example-based inference: Paste multiple examples and the tool infers the common structure: character types (letters, digits), delimiters, and repetitions.
Pattern explanation: Every generated regex is broken down token by token with plain-English descriptions.
Validation warnings: Flags overly greedy patterns (.*), patterns without anchors (matches anywhere), and overly specific patterns (only matches one string).
Escape automation: Literal dots, plus signs, parentheses, and other special characters are auto-escaped (. becomes \.).
Built-in tester: Test the generated pattern against sample inputs instantly to verify it works before copying.
Common use cases
Form validation: Generate patterns for email, password strength, phone, postal code, username validation.
Log parsing: Extract timestamps, IP addresses, error codes, or URLs from log files or API responses.
Data extraction: Pull structured data (dates, IDs, version numbers) from unstructured text or HTML.
Learning regex: See how examples map to patterns, understand character classes and quantifiers.
Search and replace: Build patterns for find-and-replace in editors, scripts, or build tools.
Input sanitization: Validate and sanitize user input before storing or processing.
Examples
Patterns generated from common inputs.
Email validation pattern
user@example.com, admin@company.co.uk
^[\w.-]+@[\w.-]+\.[a-z]{2,}$
Matches one or more word characters/dots/hyphens, then @, then domain, then dot, then 2+ letter TLD. Not RFC 5322 compliant (that is 6000 characters), but catches 99% of real emails.
US phone number
(555) 123-4567, 555-123-4567, 5551234567
^\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$
Matches optional parens around area code, optional separators (dash, dot, space), and 7-digit number. Covers common US formats.
ISO date (YYYY-MM-DD)
2024-03-15, 2025-12-31
^\d{4}-\d{2}-\d{2}$
Matches four digits, hyphen, two digits, hyphen, two digits. Does not validate date ranges (e.g., 2024-99-99 would match) — for strict validation, parse with a date library.
Hex color code
#1a2b3c, #FFF, #000000
^#[0-9a-fA-F]{3}([0-9a-fA-F]{3})?$
Matches # followed by exactly 3 or 6 hex digits. Covers both shorthand (#FFF) and full (#FFFFFF) formats.
Extract digits from text
Order 12345 shipped
\d+
Without anchors (^ $), this matches one or more digits anywhere in the string. Use with .match() or .findall() to extract all numbers.
Technical reference
The regex syntax and patterns this tool generates:
Syntax standard
ECMAScript (JavaScript) regex syntax, compatible with most regex engines (Python, PHP, etc.)
Special chars (. + * ? ^ $ [ ] { } ( ) | \) must be escaped with backslash to match literally
Email pattern
^[\w.-]+@[\w.-]+\.\w{2,}$ — basic validation, not RFC 5322 compliant (that is 6000+ characters)
URL pattern
^https?://[^\s]+$ — matches http/https URLs
Phone (US)
^\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$ — (555) 123-4567, 555-123-4567, etc.
Common mistakes to avoid
Using generated email regex for production without understanding its limits
Why it happens: The pattern ^[\w.-]+@[\w.-]+\.\w{2,}$ catches most emails but is not RFC 5322 compliant. Valid emails like 'user+tag@example.com' (+ is allowed) or 'user@localhost' (no TLD) will be rejected. Conversely, invalid emails like 'user@domain..com' (double dot) will pass. For critical validation (user registration, payment processing), relying on a simple regex can lock out legitimate users or accept malformed addresses.
How to avoid it: Use the regex for basic client-side validation to catch obvious typos, then verify the email on the server by sending a confirmation link. Do not rely solely on regex for RFC compliance. For stricter validation, use a library (email-validator in Python, validator.js in JavaScript) or send a test email.
Forgetting anchors (^ and $) for validation patterns
Why it happens: A pattern like \d{3} matches three digits anywhere in the string, so 'abc12345' matches (the '123' part). For input validation, you want the entire string to match the pattern, not just contain it. Without ^ (start) and $ (end), a password pattern like [a-z]{6} would accept 'abc123xyz' even though you wanted exactly 6 lowercase letters.
How to avoid it: Always add ^ at the start and $ at the end for validation patterns: ^\d{3}$ matches exactly three digits and nothing else. For search-and-extract use cases (finding patterns inside longer text), omit the anchors.
Using .* (greedy wildcard) without understanding the consequences
Why it happens: .* matches any character (except newline) zero or more times, and it is greedy — it matches as much as possible. In the pattern <tag>.*</tag>, if the input is '<tag>foo</tag> <tag>bar</tag>', the .* matches 'foo</tag> <tag>bar' (everything between the first < and last >), not just 'foo'. This is almost never what you want.
How to avoid it: Use .*? (non-greedy) to match as little as possible: <tag>.*?</tag> matches '<tag>foo</tag>' and stops. Or use a more specific pattern: <tag>[^<]+</tag> (match anything except <).
Not escaping special characters in literal text
Why it happens: Regex has many special characters: . + * ? ^ $ [ ] { } ( ) | \. If you want to match them literally, you must escape them with a backslash. For example, to match 'example.com', the pattern example.com is wrong — the dot matches any character, so 'exampleXcom' would also match. The correct pattern is example\.com.
How to avoid it: Escape all special characters when matching literal text: \. \+ \* \? \^ \$ \[ \] \{ \} \( \) \| \\. The generator does this automatically for literal parts, but if you edit the pattern manually, be careful.
Testing regex with only positive examples (matches) and no negative examples (non-matches)
Why it happens: A pattern like .* matches everything, including inputs you want to reject. If you only test with valid emails, the pattern ^.*$ will pass all tests, but it also matches 'not an email', '12345', and '!!!'. You discover the problem only when invalid data gets through in production.
How to avoid it: Test with both positive and negative examples. For an email pattern, test 'user@example.com' (should match) and also 'userexample.com' (no @), '@example.com' (no user), 'user@' (no domain). A good pattern rejects all invalid cases.
Frequently asked questions
How do I generate a regex for a custom format?
Paste 3–5 examples of the format you want to match (one per line) in the input area. The tool analyzes the structure and generates a pattern with character classes (\d for digits, [a-z] for letters) and quantifiers ({3}, +). Review the generated pattern and refine it manually if needed. For very complex formats, start with a template and modify it.
Why is the email regex so short? Is it correct?
The generated email pattern (^[\w.-]+@[\w.-]+\.\w{2,}$) is intentionally simple. The full RFC 5322 email spec is 6000+ characters of regex and allows quoted strings, IP addresses, and other rare formats. The simple pattern catches 99% of real emails and is readable. For production, use it for basic validation, then verify by sending a confirmation email.
What is the difference between greedy and non-greedy quantifiers?
Greedy quantifiers (*, +, {n,m}) match as much as possible. Non-greedy (*?, +?, {n,m}?) match as little as possible. In '<tag>foo</tag><tag>bar</tag>', the pattern <tag>.*</tag> matches the entire string (greedy), while <tag>.*?</tag> matches '<tag>foo</tag>' and stops (non-greedy). Use non-greedy when you want the shortest match.
Should I use regex for HTML or XML parsing?
No. Regex cannot parse nested structures (tags inside tags), handle attributes correctly, or deal with edge cases (comments, CDATA, self-closing tags). Use a real parser (DOMParser in JavaScript, BeautifulSoup in Python, simplexml in PHP). Regex is fine for extracting simple patterns from HTML (e.g., all href="..." values), but not for structural parsing.
Can the generated regex be used in Python, PHP, or other languages?
Mostly yes. The tool generates ECMAScript (JavaScript) regex syntax, which is very similar to Python, PHP, Perl, and other flavors. Watch out for minor differences: Python uses \A and \Z instead of ^ and $ in multiline mode, and named groups differ ((?P<name>...) in Python vs (?<name>...) in JavaScript). Test in the target language before deploying.
How do I match Unicode characters (emoji, accented letters)?
JavaScript regex does not support \p{L} (all letters) without the 'u' flag. For Unicode support, use the pattern with the /u flag: /pattern/u, or manually specify ranges: [a-zA-ZÀ-ÿ] for accented Latin letters. For emoji, match \p{Emoji} with the /u flag in modern JavaScript (ES2018+).
Why do I need ^ and $ in validation patterns?
^ matches the start of the string, $ matches the end. Without them, the pattern matches anywhere inside the input. For example, \d{3} matches '123abc' (the '123' part). For input validation, you want the entire string to match: ^\d{3}$ matches '123' and rejects '123abc'. Always use anchors for validation.