Email Regex Go Validator

The Qodex Email Regex Go Validator helps you test and validate email address patterns using Golang’s regexp package. Whether you’re writing backend validations or working on signup flows, this tool shows instant match results and group captures. Use it with our Email Generator, Username Generator, or Password Generator to simulate real-world test scenarios.

dave@qodex.ai

Possible security issues ▾

This regex appears to be safe.

Explanation ▾

[A-Z]: uppercase letters
[a-z]: lowercase letters
[0-9]: digits
\.: a literal dot
+: one or more of the preceding
*: zero or more of the preceding
?: optional (zero or one)
^: start of string
$: end of string

Match information ▾

Match 1: "dave@qodex.ai" at index 0

Test your APIs today!

Write in plain English — Qodex turns it into secure, ready-to-run tests.

Start for Free

Regular Expression - Documentation

What is Go Email Regex?

In Go (Golang), email regex is used to check whether a given string is a valid email address. This is commonly needed for:

Form field validation during user registration
Backend API input checks
Sanitizing user inputs
Login workflows and account recovery

Go’s regexp package offers efficient, performant regex handling that makes it easy to implement these checks with accuracy and speed.

Email Regex Pattern Example

A common Go-compatible regex for email validation:

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

Matches:

user@example.com
john.doe_92@company.co
test+1@domain.in

Doesn’t Match:

user@.com
user@domain
user@domain..com

Key Features & Benefits

Uses Go’s native regexp engine
Captures groups & highlights matches
Real-time feedback and validation
Ideal for login, signup, or profile forms
Works great with dummy emails from the Email Generator

Useful Metacharacters

^ : Start of string
$ : End of string
. : Any character except newline
+ : One or more
* : Zero or more
? : Optional
[a-zA-Z0-9._%+-] : Character set for valid email characters
@ : Literal “at” sign
\\ : Used to escape characters in Go regex

Core Go Regex Constructs Used

Anchors

^ : Start of string (ensures pattern starts at beginning)
$ : End of string (ensures no trailing characters)

Character Classes

[a-zA-Z0-9._%+-] : Matches standard characters allowed before the '@'
[a-zA-Z0-9.-]: Matches domain name characters
[a-zA-Z]{2,} : Ensures the top-level domain has at least two characters

Sample Email Regex for Go

Example 1 : Basic Email Validation

package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := regexp.MustCompile(`^[a-zA-Z0-9._%%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
    email := "user@example.com"
    fmt.Println("Is valid email:", pattern.MatchString(email))
}

Try variations of this in the Go Regex Tester

Example 2 : Invalid Email Catching

emails := []string{"bademail@", "user@@domain.com", "admin@site..com"}
for _, e := range emails {
    fmt.Println("Valid:", pattern.MatchString(e))
}

Simulate test data with Email Generator

Example 3 : Case Sensitive Matching

pattern := regexp.MustCompile(`(?i)^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}$`)

This enables matching mixed-case email inputs.

How It Works

Paste your Go-compatible email regex pattern.
Enter sample test emails.
Instantly see if your pattern matches and what parts are captured.
Adjust and test against realistic emails using our generators.

Pro Tips for Email Regex in Go

Use regexp.MustCompile for predefined regex to avoid runtime errors.
Always test with edge cases like:
- Missing TLD: name@domain
- Consecutive dots: john..doe@example.com
- Uppercase inputs: TEST@EMAIL.com
Regex only validates structure, not if the domain actually exists.
For stricter validation (e.g., no starting/ending dots), use lookahead/lookbehind where possible—though Go does not support lookbehind.