Regex Tester
Test and validate regular expressions
Pattern and test text
Matches update when you pause typing. Your data stays on this device.
Common patterns
Regex tips
Use \b for word boundaries to match whole words only.
? makes quantifiers non-greedy (match as few characters as possible).
Use parentheses () to create capturing groups for extracting parts of matches.
(?:...) creates non-capturing groups for grouping without capturing.
^ and $ match start and end of string (or line with the m flag).
Test your regex thoroughly with various inputs to avoid false positives.
Matches 0
Enter a pattern to see matches.
Highlighted text
Pattern explanation
Pattern components will appear here.
About the Regex Tester
Our regex tester is a free online tool that lets you write, test, and debug regular expressions in real time with instant visual feedback. Regular expressions (regex) are powerful pattern-matching sequences used in virtually every programming language for searching, validating, and manipulating text. This tool makes it easy to experiment with patterns and see results immediately.
The tester provides a complete regex development environment with match highlighting, capturing group inspection, position tracking, and automatic pattern explanation. As you type your regex pattern, the tool instantly highlights all matches in your test string, displays detailed match information including groups and indices, and explains what each component of your pattern does.
For a sign-up form email check, a log parser that pulls timestamps and status codes, or a first lesson in capture groups, start from the built-in library of common regex patterns for emails, phone numbers, URLs, IP addresses, dates, HTML tags, credit cards, hex colors, and more. Load a preset to study how it works or use it as a starting point for your own patterns.
Key Features
- Real-time pattern testing with instant match highlighting as you type
- Visual highlighting of all matches directly in the test string
- Detailed match information including position indices and match text
- Capturing group display showing each group's content separately
- Support for all JavaScript regex flags: global, ignore case, multiline, dotall, unicode, and sticky
- Automatic pattern explanation that breaks down regex components
- Library of 10 common regex patterns with sample test strings
- Copy every match to the clipboard, one per line
- Clear error messages for invalid regex syntax
- Debounced input for smooth performance with complex patterns
How to Use the Regex Tester
- Enter your pattern: Type your regular expression into the pattern input field. The pattern is displayed between forward slashes (/ /) following standard regex notation.
- Set your flags: Click the flag buttons to toggle options like Global (find all matches), Ignore Case, Multiline, Dotall, Unicode, and Sticky.
- Add test text: Paste or type the text you want to test against your regex in the test string area. Alternatively, load a preset pattern to get started quickly.
- Review matches: The Matches panel shows each match with its text content, position index, and any capturing groups. The Highlighted Text panel shows matches visually within your test string.
- Read the explanation: The Pattern Explanation panel breaks down your regex components, helping you understand what each part of your pattern does.
- Copy results: Click "Copy All" to copy all match results to your clipboard for use in documentation or further analysis.
Use Cases
- Form Validation: Build and test input validation patterns for emails, phone numbers, postal codes, URLs, and custom formats before implementing them in your application code.
- Log File Parsing: Develop regex patterns to extract timestamps, error codes, IP addresses, and structured data from server logs and application output.
- Data Extraction: Create patterns that pull specific data points from unstructured text sources like HTML pages, CSV files, and plain-text documents.
- Search & Replace: Test find-and-replace patterns before applying them to your codebase or text editor to avoid unintended changes.
- Data Validation: Verify that data fields like credit card numbers, dates, IP addresses, and hex colors conform to expected formats.
- Learning Regex: Study how common patterns work by loading presets, modifying them, and observing how changes affect matches in real time.
- Code Review: Test regex patterns found in code reviews to understand their behavior and verify they handle edge cases correctly.
- Content Filtering: Build patterns for content moderation, keyword detection, and text classification systems.
Frequently Asked Questions
Which regex flavor does this tool use?
The tester follows JavaScript (ECMAScript) regex syntax, so patterns tested here work directly in JavaScript, TypeScript, and other ECMAScript-compatible environments.
What do the different flags mean?
Global (g) finds all matches instead of stopping at the first. Ignore Case (i) makes matching case-insensitive. Multiline (m) makes ^ and $ match line starts and ends. Dotall (s) makes the dot match newlines. Unicode (u) enables full Unicode support. Sticky (y) matches from the last index position.
Will my regex work in other programming languages?
Most basic regex syntax is shared across languages, but there are differences in advanced features like lookbehinds, named groups, and flags. Patterns tested here are guaranteed to work in JavaScript. For other languages, minor adjustments may be needed.
What are capturing groups?
Capturing groups are parts of a regex pattern enclosed in parentheses (). They capture the matched text so you can reference it separately. This tool displays each group's content in the match details panel.
Tips & Best Practices
- Start simple and build up: Begin with a basic pattern that matches part of what you need, then progressively add complexity until you capture exactly the right data.
- Use word boundaries (\b): Add \b around patterns to match whole words only and avoid partial matches within larger words.
- Prefer non-greedy quantifiers: Use *? and +? instead of * and + when you want to match the shortest possible string rather than the longest.
- Test edge cases: Always test your regex with unexpected inputs including empty strings, special characters, and very long text to ensure robust behavior.
- Use non-capturing groups: When you need grouping for alternation but do not need to capture the result, use (?:...) to improve performance.
- Load presets to learn: Use the built-in common patterns as learning examples. Modify them and observe how changes affect the matches to deepen your understanding.