Massendaten: 100.000+ E-Mail-Adressen extrahieren

← Zurück zum E-Mail Extractor

Wann du Hochleistungs-Extraktion brauchst

Bei bestimmten Aufgaben reichen einfache Tools nicht aus. Typische Szenarien für Massendaten-Extraktion:

• CRM-Migrationen – beim Wechsel des CRM-Systems müssen Hunderttausende Kontaktdaten aus Exporten extrahiert werden.
• Datenbankkonsolidierung – zusammenführen von E-Mail-Adressen aus verschiedenen Quellsystemen.
• Archivverarbeitung – Extraktion aus jahrelang gesammelten E-Mail-Archiven oder Dokumentenablagen.
• Compliance-Audits – systematische Erfassung aller personenbezogenen E-Mail-Daten für DSGVO-Compliance.
• E-Mail-Listenbereinigung – Deduplizierung und Bereinigung großer Verteilerlisten.

Unser Tool: Für große Datenmengen gebaut

Der E-Mail Extractor auf extract-emails.com wurde speziell für die Verarbeitung großer Datenmengen optimiert:

• Virtual Scrolling – auch bei 100.000+ Zeilen bleibt die Oberfläche flüssig, da nur die sichtbaren Zeilen gerendert werden.
• Web Workers – die Extraktion läuft in einem separaten Thread und blockiert nicht die Benutzeroberfläche.
• Chunked Processing – große Texte werden in Blöcken verarbeitet, um den Speicherverbrauch zu optimieren.
• Echtzeit-Fortschritt – du siehst jederzeit, wie weit die Verarbeitung fortgeschritten ist.

Python für maximalen Durchsatz

Streaming-Verarbeitung für große Dateien

Zeilenweise Verarbeitung ohne die gesamte Datei in den Speicher zu laden

import re

def emails_aus_grosser_datei(dateipfad):
    pattern = re.compile(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}')
    emails = set()
    zeilen_verarbeitet = 0

    with open(dateipfad, 'r', encoding='utf-8', errors='ignore') as f:
        for zeile in f:
            treffer = pattern.findall(zeile)
            emails.update(treffer)
            zeilen_verarbeitet += 1
            if zeilen_verarbeitet % 100000 == 0:
                print(f"{zeilen_verarbeitet:,} Zeilen verarbeitet, {len(emails):,} E-Mails gefunden")

    print(f"\nFertig: {zeilen_verarbeitet:,} Zeilen, {len(emails):,} eindeutige E-Mails")
    return sorted(emails)

emails = emails_aus_grosser_datei("grosser_export.txt")
for email in emails:
    print(email)

Multiprocessing für mehrere Dateien

import re
import os
from multiprocessing import Pool

def emails_aus_datei(dateipfad):
    pattern = re.compile(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}')
    emails = set()
    try:
        with open(dateipfad, 'r', encoding='utf-8', errors='ignore') as f:
            for zeile in f:
                emails.update(pattern.findall(zeile))
    except Exception as e:
        print(f"Fehler bei {dateipfad}: {e}")
    return emails

if __name__ == '__main__':
    ordner = "./daten"
    dateien = [os.path.join(ordner, f) for f in os.listdir(ordner)
               if f.endswith(('.txt', '.csv', '.html'))]

    with Pool() as pool:
        ergebnisse = pool.map(emails_aus_datei, dateien)

    alle_emails = set()
    for ergebnis in ergebnisse:
        alle_emails.update(ergebnis)

    print(f"Insgesamt {len(alle_emails):,} eindeutige E-Mails aus {len(dateien)} Dateien")
    for email in sorted(alle_emails):
        print(email)

Kommandozeile: Die schnellste Option

grep-Pipeline für Millionen von Zeilen

# Einzelne grosse Datei
grep -oE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' grosser_export.txt | sort -u | wc -l

# Alle Dateien in einem Verzeichnis
find ./daten -type f \( -name "*.txt" -o -name "*.csv" \) -exec grep -ohE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' {} + | sort -u

# Mit GNU Parallel fuer maximale Geschwindigkeit
find ./daten -type f -name "*.txt" | parallel grep -ohE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' {} | sort -u

Speichermanagement

• Streaming statt vollständiges Laden: Lies Dateien zeilenweise statt komplett in den RAM.
• Sets für Deduplizierung: Python-set() ist optimal für bis zu einigen Millionen E-Mails.
• Chunk-Verarbeitung: Teile extrem große Dateien in Blöcke von 1–10 MB.
• Ergebnisse sofort schreiben: Schreibe gefundene E-Mails direkt in eine Ausgabedatei statt alle im RAM zu halten.

Ausgabeformate

• CSV: Ideal für den Import in CRM-Systeme und Outlook.
• JSON Lines: Ein JSON-Objekt pro Zeile – optimal für Streaming-Verarbeitung.
• Direkt in Datenbank: Für sehr große Mengen direkt per INSERT in eine Datenbank schreiben.

Tipps für beste Ergebnisse

• Unser Tool für bis zu 500.000 Zeilen. Für die meisten Anwendungsfälle ist der Browser-basierte Ansatz ausreichend.
• Python für Millionen von Zeilen. Skripte bieten volle Kontrolle über Speicher und Ausgabe.
• Kommandozeile für maximale Geschwindigkeit. grep ist für reine Textsuche deutlich schneller als Python.
• Dateien vorab filtern. Verarbeite nur Dateien, die wahrscheinlich E-Mails enthalten.
• Ergebnisse früh validieren. Teste mit einer kleinen Stichprobe, bevor du Millionen von Zeilen verarbeitest.