Xavier Fok

Posted on Mar 8

Multi-Account Email Management: Setting Up Unique Identities at Scale

#proxy #automation #email #tutorial

Every account needs a unique email address. At scale, managing hundreds or thousands of email addresses becomes its own infrastructure challenge. Here is how to handle it.

Why Email Management Matters

Platforms link accounts through shared email patterns:

Same email domain across accounts
Sequential email addresses (user1, user2, user3)
Email addresses created at the same time from the same IP
Similar naming patterns

One sloppy email setup can link all your accounts together.

Email Strategies by Scale

Small Scale (1-20 accounts)

Gmail with dots trick:
Gmail ignores dots in email addresses. These all deliver to the same inbox:

Gmail with plus addressing:

Warning: Many platforms have caught on to these tricks and treat them as the same address.

Medium Scale (20-100 accounts)

Multiple email providers:
Create accounts across different providers:

Gmail
Outlook/Hotmail
Yahoo
ProtonMail
Zoho Mail
iCloud

Use different providers for different account groups to reduce linkability.

Catch-all domain:
Register a domain and set up catch-all email:

# Any address @yourdomain.com goes to one inbox
sales@yourdomain.com
support@yourdomain.com
randomname@yourdomain.com

But be careful — platforms can see all your emails share the same domain.

Large Scale (100-1000+ accounts)

Multiple domains with catch-all:
Register 10-20 different domains across different registrars:

account1@freshtools.io
account2@dataworks.co
account3@smartops.net

Each domain hosts 50-100 email addresses.

Email provider APIs:
Use provider APIs to programmatically create and manage mailboxes.

Email Infrastructure Setup

Option 1: Multiple Catch-All Domains

Domain 1 (registrar A) → DNS → Email host A
Domain 2 (registrar B) → DNS → Email host B
Domain 3 (registrar C) → DNS → Email host A

Distribute across registrars and hosts to reduce linkability.

Option 2: Self-Hosted Email

Run your own mail server for maximum control:

# Basic mail server components
- Postfix (SMTP)
- Dovecot (IMAP)
- Multiple domains configured
- SPF, DKIM, DMARC records

Pros: Full control, unlimited addresses
Cons: Complex maintenance, deliverability challenges

Option 3: Email API Services

Services that provide programmatic email management:

Create mailboxes via API
Read incoming emails programmatically
Perfect for verification code retrieval

class EmailManager:
    def __init__(self, api_key):
        self.api_key = api_key

    def create_inbox(self, prefix=None):
        # Create a new random email address
        response = requests.post(
            "https://api.emailservice.com/inboxes",
            headers={"Authorization": f"Bearer {self.api_key}"},
            json={"prefix": prefix}
        )
        return response.json()["email_address"]

    def get_verification_code(self, email, timeout=120):
        # Wait for and extract verification code
        start = time.time()
        while time.time() - start < timeout:
            messages = self.get_messages(email)
            for msg in messages:
                code = self.extract_code(msg["body"])
                if code:
                    return code
            time.sleep(5)
        return None

    def extract_code(self, body):
        # Extract 4-8 digit verification codes
        import re
        match = re.search(r"\\b(\\d{4,8})\\b", body)
        return match.group(1) if match else None

Verification Code Handling

Automating email verification at scale:

def register_account(platform, proxy, email_manager):
    # Create unique email
    email = email_manager.create_inbox()

    # Register on platform through proxy
    register(platform, email, proxy)

    # Wait for verification email
    code = email_manager.get_verification_code(email, timeout=120)

    if code:
        verify(platform, code, proxy)
        return {"email": email, "status": "verified"}
    else:
        return {"email": email, "status": "verification_timeout"}

Best Practices

Never reuse emails across platforms — One email per account per platform
Vary email naming patterns — Mix firstname.lastname, random words, and initials
Use aged domains — New domains get flagged. Register domains months before using them
Set up proper DNS — SPF, DKIM, and DMARC records improve email deliverability
Monitor inboxes — Platforms send security alerts to email. Missing them means missing account issues
Organize by account — Map every email to its corresponding account in your database
Backup recovery emails — Store recovery email addresses separately for account recovery

Email Security

Never access email accounts through the same proxy as the platform account
Use separate, clean IPs for email management
Enable 2FA on email accounts when possible
Regularly check for unauthorized access

For email management and multi-account infrastructure guides, visit DataResearchTools.

DEV Community