Regex Tester

How to test regular expressions online

jsonsql.dev lets you test regex patterns instantly in your browser. No data is sent to any server — your text stays on your machine.

Example

Pattern: (\d{4})-(\d{2})-(\d{2}) with flag g

Test string:

Meeting on 2026-04-07 and follow-up on 2026-05-15.

Result:

Match 1: "2026-04-07" at index 11, length 10
  Group 1: "2026"
  Group 2: "04"
  Group 3: "07"

Match 2: "2026-05-15" at index 39, length 10
  Group 1: "2026"
  Group 2: "05"
  Group 3: "15"

Features

• Live matching as you type — both regex and test string update results instantly
• Flag toggles: global (g), case-insensitive (i), multiline (m), dotAll (s), unicode (u)
• Color-coded match highlighting directly in the test string
• Detailed match info: full text, index position, length for every match
• Capture groups displayed for each match — both numbered and named groups
• Quick-insert common patterns: email, URL, IP address, phone, date, hex color
• Basic pattern explanation showing what the regex does
• Replace mode with support for backreferences ($1, $2, $&)
• Export regex to 8 languages: JavaScript, Python, Java, Go, PHP, C#, Ruby, Rust
• Dark and light theme support
• Works offline — no internet needed after the page loads
• 100% client-side — no data leaves your browser

Regex Tester vs other tools

Regular expression syntax reference

Regular expressions are patterns used to match character combinations in strings. A single regex can replace dozens of lines of string-parsing code.

Character classes

Anchors

Quantifiers

Groups and references

Lookahead and lookbehind

Flags

Common regex patterns

Here are practical regex patterns you can use right away. Click any "Quick patterns" button above to load them into the tester instantly.

Regex flags explained

Flags modify how the regex engine interprets your pattern. Understanding flags is essential for getting the matches you expect.

g (global) — find all matches

Without the g flag, the regex stops after the first match. With g, it finds every match in the string.

Pattern: \d+
Text: "I have 3 cats and 12 dogs"

Without g flag: Match 1: "3"
With g flag:    Match 1: "3", Match 2: "12"

i (case-insensitive) — ignore case

Makes the pattern match regardless of letter case.

Pattern: hello (with i flag)
Text: "Hello HELLO hello"
Matches: "Hello", "HELLO", "hello"

m (multiline) — line-by-line anchors

With the m flag, ^ matches the start of each line and $ matches the end of each line, not just the start/end of the entire string.

Pattern: ^\w+ (with m flag)
Text:
"first line
second line
third line"
Matches: "first", "second", "third"

s (dotAll) — dot matches newlines

By default, . matches any character except newlines. The s flag makes . match newline characters too.

Pattern: start.+end (with s flag)
Text: "start\nmiddle\nend"
Match: "start\nmiddle\nend" (entire text)

u (unicode) — full Unicode support

Enables proper matching of Unicode code points, including emoji and characters outside the Basic Multilingual Plane.

Pattern: \p{Emoji} (with u flag)
Text: "Hello 🌍 World 🎉"
Matches: "🌍", "🎉"

Regex capture groups and backreferences

Capture groups let you extract specific parts of a match. They are one of the most powerful features of regular expressions.

Numbered groups

Parentheses (...) create numbered capture groups, starting at $1.

Pattern: (\w+)@(\w+)\.(\w+)
Text: "user@example.com"
Full match: "user@example.com"
$1: "user"
$2: "example"
$3: "com"

Named groups

Use (?<name>...) to give groups meaningful names instead of numbers.

Pattern: (?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})
Text: "2026-04-07"
$<year>: "2026"
$<month>: "04"
$<day>: "07"

Non-capturing groups

Use (?:...) when you need grouping for quantifiers or alternation but don't need to capture the result.

Pattern: (?:https?|ftp)://(\S+)
Text: "https://example.com"
$1: "example.com" (only the domain is captured)

Backreferences in replace

In replacement strings, use $1, $2 (or $<name> for named groups) to insert captured values. Use $& for the full match.

// Reformatting dates from MM/DD/YYYY to YYYY-MM-DD
Pattern: (\d{2})\/(\d{2})\/(\d{4})
Replace: $3-$1-$2
Input:  "04/07/2026"
Output: "2026-04-07"

Regex in different programming languages

While this tool uses JavaScript's regex engine, regex syntax is similar across most languages. Here's how to use regex in popular languages.

JavaScript

// Literal syntax
const re = /\d{4}-\d{2}-\d{2}/g;

// Constructor syntax
const re2 = new RegExp('\\d{4}-\\d{2}-\\d{2}', 'g');

// Find matches
const matches = str.match(re);        // ["2026-04-07"]
const allMatches = [...str.matchAll(re)]; // iterator with groups

// Replace
const result = str.replace(re, 'DATE');

// Test if pattern matches
const isValid = re.test(str);         // true or false

Python

import re

# Find all matches
matches = re.findall(r'\d{4}-\d{2}-\d{2}', text)

# Find with groups
for m in re.finditer(r'(\d{4})-(\d{2})-(\d{2})', text):
    print(m.group(1), m.group(2), m.group(3))

# Replace
result = re.sub(r'\d{4}', 'YYYY', text)

# Compile for reuse
pattern = re.compile(r'\d{4}-\d{2}-\d{2}')
pattern.findall(text)

Go

import "regexp"

// Compile pattern (panics on invalid regex)
re := regexp.MustCompile(`\d{4}-\d{2}-\d{2}`)

// Find matches
match := re.FindString(text)              // first match
allMatches := re.FindAllString(text, -1)   // all matches

// Replace
result := re.ReplaceAllString(text, "DATE")

// Test
isMatch := re.MatchString(text)

Command line (grep and sed)

# Find lines matching pattern (extended regex)
grep -E '\d{4}-\d{2}-\d{2}' file.txt

# Find and replace in-place with sed
sed -i 's/[0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\}/DATE/g' file.txt

# Count matches
grep -cE '\d{4}-\d{2}-\d{2}' file.txt

# Show only matching parts
grep -oE '\d{4}-\d{2}-\d{2}' file.txt

Related tools

Frequently asked questions