Email Validation Regex

Validate email addresses with this comprehensive regular expression pattern that covers most common email formats

BeginnerContact
Regular Expression Pattern
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
Pattern Breakdown
^Start of string anchor
[a-zA-Z0-9._%+-]+Local part: letters, numbers, dots, underscores, percent, plus, and hyphens (one or more)
@Literal @ symbol
[a-zA-Z0-9.-]+Domain name: letters, numbers, dots, and hyphens (one or more)
\.Literal dot (escaped)
[a-zA-Z]{2,}Top-level domain: letters only, 2 or more characters
$End of string anchor
Test Your Email
Code Examples

javascript

// Email validation regex
const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;

function validateEmail(email) {
  return emailRegex.test(email);
}

// Usage examples
console.log(validateEmail("user@example.com")); // true
console.log(validateEmail("test.email+tag@domain.co.uk")); // true
console.log(validateEmail("invalid.email")); // false

python

import re

# Email validation pattern
email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'

def validate_email(email):
    return bool(re.match(email_pattern, email))

# Usage examples
print(validate_email("user@example.com"))  # True
print(validate_email("test.email+tag@domain.co.uk"))  # True
print(validate_email("invalid.email"))  # False

java

import java.util.regex.Pattern;

public class EmailValidator {
    private static final String EMAIL_PATTERN = 
        "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$";
    
    private static final Pattern pattern = Pattern.compile(EMAIL_PATTERN);
    
    public static boolean validateEmail(String email) {
        return pattern.matcher(email).matches();
    }
    
    public static void main(String[] args) {
        System.out.println(validateEmail("user@example.com")); // true
        System.out.println(validateEmail("invalid.email")); // false
    }
}
Test Cases
InputExpectedDescription
user@example.com✓ ValidStandard email format
test.email+tag@domain.co.uk✓ ValidEmail with plus sign and subdomain
firstname.lastname@company.org✓ ValidEmail with dots in local part
user123@test-domain.com✓ ValidEmail with numbers and hyphen
invalid.email✗ InvalidMissing @ symbol
@domain.com✗ InvalidMissing local part
user@✗ InvalidMissing domain
user@domain✗ InvalidMissing TLD
user name@domain.com✗ InvalidSpace in local part
Common Use Cases

User Registration Validation

Validate email address format in user registration forms to ensure users enter valid email addresses and avoid issues caused by invalid emails.

// Registration form validation
if (!emailRegex.test(userEmail)) {
  showError("Please enter a valid email address");
}

Pre-send Email Validation

Validate recipient email addresses before sending emails to avoid sending failures due to format errors and improve email delivery rates.

// Email sending validation
const validEmails = recipients.filter(email =>
  emailRegex.test(email)
);

Data Cleaning and Import

Use regular expressions to filter and validate email addresses when importing user data in bulk, ensuring data quality and integrity.

// Data cleaning
const cleanData = rawData.filter(user =>
  emailRegex.test(user.email)
);

API Interface Validation

Validate email address format in request parameters within API interfaces to ensure interface robustness and data validity.

// API parameter validation
if (!emailRegex.test(req.body.email)) {
  return res.status(400).json({error: "Invalid email"});
}
Frequently Asked Questions

Why did my email validation fail?

Common reasons for email validation failure include: email addresses containing special characters, incorrect domain format, missing @ symbol or top-level domain. Please ensure the email format is: username@domain.suffix

Correct format: user@example.com, test.email+tag@domain.co.uk
Incorrect format: user@domain, @domain.com, user.domain.com

Does this regex support internationalized domain names?

The current regex primarily supports ASCII character domains. If you need to support internationalized domain names (IDN), it's recommended to use specialized email validation libraries or more complex regular expressions.

Note: For production environments, it's recommended to combine server-side validation with email confirmation mechanisms to ensure email address validity.

How to handle case sensitivity in email addresses?

The local part of an email address (before @) may be case-sensitive, but the domain part is not case-sensitive. In practice, the entire email address is usually converted to lowercase for processing.

// Normalize email address
const normalizedEmail = email.toLowerCase().trim();

Does passing regex validation mean the email actually exists?

No. Regular expressions can only validate whether the email address format is correct, but cannot verify whether the email actually exists. To verify email authenticity, you need to send confirmation emails or use specialized email verification services.

Related Regex Patterns
📱

Phone Number

🌐

URL Validation

📅

Date Format