I have used temporary email services more times than I care to admit. You know the drill: you need to download something, a site demands an email before showing its content, and you do not want to hand over your real address. TempMail and similar services solve this, but what if you need to generate a batch of random email addresses programmatically? Python makes this trivial. Let me show you two approaches that cover most use cases.
Before jumping into the code, it helps to understand the anatomy of an email address. Every email has a local part (the name before the @) and a domain part (everything after @). The local part follows strict rules: it cannot start with a number, and it cannot contain special characters like spaces, dots (in most contexts), or dollar signs. The domain has its own rules, and combining both correctly is what makes email validation tricky. Generating valid random emails is actually easier than validating existing ones.
TLDR
- Use
random.choice()to pick characters when building the local part of an email - Pick domain names from a curated list of real providers for emails that work at signup forms
- Generate the domain completely at random when you need maximum anonymity and the email does not need to be real
- Validate that the first character is never numeric, or prepend a letter to stay within spec
Random Emails With Fixed Domain Names
The simplest approach is to pick a random local part and combine it with a known domain. Think Gmail, Yahoo, Hotmail. These domains are real, and most signup forms accept them without friction. You get a random address that passes most basic validation checks. This is the right choice when you need something that looks believable but does not map back to a real person.
Here is the code I use for this:
import random
def generate_email_fixed_domain():
valid_chars = 'abcdefghijklmnopqrstuvwxyz1234567890'
length = random.randint(4, 15)
login = ''.join(random.choice(valid_chars) for _ in range(length))
if login[0].isnumeric():
login = random.choice('abcdefghijklmnopqrstuvwxyz') + login
servers = ['@gmail', '@yahoo', '@hotmail', '@outlook', '@protonmail']
tlds = ['.com', '.net', '.org', '.io', '.co']
email = login + random.choice(servers) + random.choice(tlds)
return email
for _ in range(5):
print(generate_email_fixed_domain())
The function builds the local part by selecting random characters. I set the length between 4 and 15 characters, which avoids addresses that look suspicious (too short or too long). The numeric check at the start is important: RFC 5321 specifies that the local part cannot begin with a digit, so I prepend a letter if that happens. Then I pick a server and a TLD from hardcoded lists and stitch everything together.
Typical output looks like:
Random Emails With Fully Random Domain Names
Sometimes you need complete anonymity. The address does not have to exist, and you definitely do not want it traced back to Gmail or Yahoo. In that case, generate the domain part too. The domain will look bizarre and clearly non-functional, which is the point when you are dealing with throwaway registrations.
import random
import string
def generate_email_random_domain():
valid_chars = string.ascii_lowercase + string.digits
domain_chars = string.ascii_lowercase
local_len = random.randint(4, 15)
server_len = random.randint(3, 9)
tld_len = random.randint(2, 3)
local = ''.join(random.choice(valid_chars) for _ in range(local_len))
if local[0].isdigit():
local = random.choice(string.ascii_lowercase) + local
server = ''.join(random.choice(domain_chars) for _ in range(server_len))
tld = ''.join(random.choice(domain_chars) for _ in range(tld_len))
return f"{local}@{server}.{tld}"
for _ in range(5):
print(generate_email_random_domain())
I switched to string module constants here for readability. The domain characters exclude digits because real domains do not allow numbers in their name components. The TLD length of 2-3 characters covers most country codes and standard extensions. The output is predictably strange:
FAQ
Q: Can these emails actually receive messages?
No. These are randomly generated strings that look like email addresses. They do not correspond to real mailboxes unless you use real domain names in the fixed-domain approach. For actual receive-capable temporary emails, use a service API like TempMail or Guerrilla Mail.
Q: Why does the local part sometimes start with a letter even when I did not specify it?
Because RFC 5321 prohibits the local part from starting with a digit. The code checks for this and prepends a letter if needed. This ensures the generated address conforms to the email specification.
Q: Can I add special characters like dots or plus signs to the local part?
You can, but I would not recommend it for generated addresses. Dots are technically valid in some contexts but get stripped by most mail systems. Plus signs work for routing (like [email protected]) but many signup forms block them. For random generation, stick to alphanumeric characters.
Q: What about uppercase letters?
Email local parts are case-insensitive, but I keep everything lowercase because it looks cleaner and avoids edge cases. Some mail servers handle uppercase differently, so lowercase is the safer choice.
Q: How many emails can I generate at once?
Theoretically unlimited. There are 36^4 (over 1.6 million) possible 4-character combinations using letters and digits alone, so collision risk is negligible for any reasonable batch size. For bulk generation, consider using random.choices() with a k parameter instead of a loop for better performance.
Summary
I reach for the fixed-domain approach when I need something that looks legitimate, like testing a signup flow that validates the domain. I use the random-domain approach when I want an address that cannot be traced back to any real provider. Both take less than 20 lines of Python and do not require any external libraries beyond the standard library. That simplicity is what keeps me coming back to this approach instead of building some elaborate wrapper around third-party APIs.
