Data Anonymisation and Pseudonymisation for Email Datasets

Why Anonymise Email Data

Email datasets frequently need to be shared, analysed or stored in ways that require removing or obscuring personal information:

Anonymisation vs Pseudonymisation

These are different techniques with different legal implications:

GDPR definitions

Anonymisation Techniques for Email Data

Technique comparison

When to use each technique

Implementation

Hashing email addresses

import hashlib
import secrets

def hash_email(email, salt=None):
    """Hash an email address. Use a salt for security."""
    email = email.strip().lower()
    if salt:
        data = (salt + email).encode('utf-8')
    else:
        data = email.encode('utf-8')
    return hashlib.sha256(data).hexdigest()

# Without salt (vulnerable to lookup attacks)
hashed = hash_email('user@example.com')
# Result: a consistent hash; same input always produces same output

# With salt (more secure)
salt = secrets.token_hex(16)  # Generate once; store securely
hashed = hash_email('user@example.com', salt=salt)
# Result: different hash than unsalted; cannot be reversed without salt

Warning about unsalted hashing: Unsalted hashes of email addresses are vulnerable to lookup attacks. An attacker can hash a list of known email addresses and compare them to your hashed dataset. Always use a salt, and keep the salt secret.

Tokenisation

import uuid
import csv

class EmailTokeniser:
    """Replace email addresses with random tokens."""

    def __init__(self):
        self.mapping = {}  # email -> token
        self.reverse_mapping = {}  # token -> email

    def tokenise(self, email):
        """Replace an email with a consistent random token."""
        email = email.strip().lower()
        if email not in self.mapping:
            token = str(uuid.uuid4())
            self.mapping[email] = token
            self.reverse_mapping[token] = email
        return self.mapping[email]

    def detokenise(self, token):
        """Recover the original email from a token."""
        return self.reverse_mapping.get(token)

    def process_csv(self, input_file, output_file, email_column='email'):
        """Tokenise email addresses in a CSV file."""
        with open(input_file, 'r') as inf, \
             open(output_file, 'w', newline='') as outf:
            reader = csv.DictReader(inf)
            writer = csv.DictWriter(outf, fieldnames=reader.fieldnames)
            writer.writeheader()
            for row in reader:
                if email_column in row and row[email_column]:
                    row[email_column] = self.tokenise(
                        row[email_column])
                writer.writerow(row)

    def save_mapping(self, mapping_file):
        """Save the mapping table (store securely)."""
        with open(mapping_file, 'w', newline='') as f:
            writer = csv.writer(f)
            writer.writerow(['token', 'email'])
            for token, email in self.reverse_mapping.items():
                writer.writerow([token, email])

Synthetic email generation

import random
import string

def generate_synthetic_email(domain='example.com'):
    """Generate a realistic but fake email address."""
    first_names = [
        'alex', 'jordan', 'taylor', 'morgan', 'casey',
        'riley', 'avery', 'quinn', 'blake', 'drew'
    ]
    last_names = [
        'smith', 'jones', 'wilson', 'brown', 'taylor',
        'davis', 'miller', 'anderson', 'thomas', 'jackson'
    ]
    separators = ['.', '_', '']

    first = random.choice(first_names)
    last = random.choice(last_names)
    sep = random.choice(separators)
    number = random.randint(1, 999) if random.random() > 0.5 else ''

    return f"{first}{sep}{last}{number}@{domain}"

def replace_emails_with_synthetic(emails, preserve_domains=False):
    """Replace real emails with synthetic ones."""
    synthetic = {}
    for email in emails:
        email_lower = email.strip().lower()
        if email_lower not in synthetic:
            if preserve_domains:
                domain = email_lower.split('@')[1]
            else:
                domain = 'example.com'
            synthetic[email_lower] = generate_synthetic_email(domain)
    return synthetic

Domain-only generalisation

def generalise_to_domain(email):
    """Remove the local part; keep only the domain."""
    parts = email.strip().lower().split('@')
    if len(parts) == 2:
        return f"[redacted]@{parts[1]}"
    return "[invalid]"

# "john.smith@acmecorp.com" becomes "[redacted]@acmecorp.com"

Re-Identification Risks

Even anonymised data can sometimes be re-identified:

Assessing re-identification risk

Workflow for Anonymising Email Datasets

Step-by-step process

Using Email Extractor in the workflow

Before anonymising, you may need to extract email addresses from unstructured data:

1. Upload source files (CSV, XLSX, PDF, TXT, etc.) to Email Extractor to extract all email addresses.
2. The tool's automatic deduplication (case-insensitive) produces a clean starting list.
3. Download as CSV, noting which source each address came from.
4. Apply the chosen anonymisation technique to the extracted list.
5. Use the anonymised version for analysis, sharing or testing.

Note that Email Extractor processes data client-side in the browser, meaning the extracted email addresses are not sent to a server. This is relevant for compliance: the extraction step itself does not create an additional data processing activity involving a third party.

Compliance Considerations

Pseudonymisation under GDPR

Testing with Anonymised Data

Creating test datasets

Related Guides

• Data Pipeline Email Processing
• Data Governance Frameworks for Email
• GDPR Email Marketing Checklist
• Privacy Guide
• Data Quality Scoring Email Lists