How to Extract Emails From Text Using Regex

The Pattern

This is the standard pragmatic email regex used by most extraction code:

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

It breaks down into three parts:

• Local part: [a-zA-Z0-9._%+-]+ — letters, digits, dot, underscore, percent, plus, hyphen, one or more times.
• @ sign: a literal at-sign.
• Domain plus TLD: [a-zA-Z0-9.-]+\.[a-zA-Z]{2,} — letters, digits, dot, hyphen, then a literal dot, then a TLD of at least two letters.

Add \b word boundaries on either side if you're scanning unstructured text and want to avoid partial matches inside larger tokens:

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

This is the same pattern in the common regex patterns library — copy directly from there if you want.

JavaScript

const text = "Contact: jane@example.com or sales@foo.co.uk. Spam: bob@test";
const emails = text.match(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g);
// ['jane@example.com', 'sales@foo.co.uk']
// Note: 'bob@test' is excluded because there's no .TLD

// Deduplicate
const unique = [...new Set(emails)];

// Lowercase for consistent comparison
const normalized = [...new Set(emails.map(e => e.toLowerCase()))];

// matchAll for richer iteration with positions
for (const m of text.matchAll(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g)) {
  console.log(m[0], 'at index', m.index);
}

The g flag is essential — without it, match returns only the first match. See the JavaScript regex guide for more on the matchAll iterator and avoiding lastIndex bugs.

Python

import re

text = "Contact: jane@example.com or sales@foo.co.uk. Spam: bob@test"
emails = re.findall(r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}", text)
# ['jane@example.com', 'sales@foo.co.uk']

# Deduplicate while preserving order (Python 3.7+)
unique = list(dict.fromkeys(emails))

# Lowercase for consistent comparison
normalized = list(dict.fromkeys(e.lower() for e in emails))

# Use finditer for positions and Match objects
for m in re.finditer(r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}", text):
    print(m.group(0), "at index", m.start())

Always use raw strings (r"...") for Python regex patterns. See the Python regex guide for the difference between findall, finditer, and match.

Bash / grep

# Extract emails from a file, one per line
grep -oE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' input.txt

# Deduplicate
grep -oE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' input.txt | sort -u

# Lowercase first, then dedupe
grep -oE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' input.txt \
  | tr '[:upper:]' '[:lower:]' \
  | sort -u

# Count emails per file in a directory
grep -roE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' . -c

The -o flag prints only the matches (not the surrounding line); -E enables extended regex syntax. On macOS, the BSD grep works identically for this pattern. For very large files, ripgrep (rg -oNI) is dramatically faster.

Common Edge Cases

Display names with angle brackets

Given Jane Doe <jane@example.com>, the regex extracts jane@example.com and leaves the brackets and display name behind. That's usually what you want. If you need the full RFC 5322 mailbox (name plus address), reach for a real parser:

# Python
from email.utils import parseaddr
parseaddr('Jane Doe <jane@example.com>')
# ('Jane Doe', 'jane@example.com')

Plus-tags and dots in the local part

Addresses like jane+newsletter@example.com and j.a.n.e@example.com match the pattern correctly. Many forms strip the plus-tag for deduplication purposes — that's an application-level decision, not a regex one.

Internationalized addresses (IDN)

The pattern is ASCII-only. Modern email allows Unicode in both the local part and the domain (RFC 6531). For full IDN support, decode the punycoded domain (xn--*) before matching, or use a Unicode-aware character class — though Unicode emails are still rare in most data sources you'll encounter.

Quoted local parts

RFC 5322 technically allows quoted local parts like "jane doe"@example.com. These are rare in the wild — almost no real address uses them. If you need to handle them, use a dedicated email parser rather than expanding the regex.

Multiple addresses separated by commas or semicolons

The regex doesn't care about separators — it just finds matches. Given jane@a.com, sales@b.com; alice@c.com, the global match returns all three. No need to split first.

Performance Notes

For most extraction work, this pattern runs in microseconds per kilobyte of input. Three things to watch on very large inputs (gigabytes):

• Avoid backtracking-heavy patterns. The pattern above is linear — every character is consumed exactly once. A naive variation like .+@.+ would backtrack catastrophically on long lines without an @ sign.
• Stream rather than slurp. Don't load a 10GB log into memory. Iterate line-by-line in Python (for line in f:) or pipe through grep. The regex engine works on small chunks just as well.
• Compile patterns you reuse. Python's re.compile shaves a small constant per call. JavaScript's new RegExp is similar but RegExp literals are already cached by the engine.