E-Mail-Adressen aus HTML-Quellcode extrahieren

← Zurück zum E-Mail Extractor

Worum es hier geht: E-Mails aus HTML-Quelltext filtern – Markup, das dir bereits vorliegt (gespeicherte Seiten, mailto:-Links, Code-Schnipsel, CMS-Exporte). Willst du Adressen von live erreichbaren Seiten per Adresseingabe sammeln, lies unseren Guide E-Mails von Webseiten und URLs extrahieren.

Wo sich E-Mail-Adressen in HTML verstecken

HTML-Quellcode enthält weit mehr E-Mail-Adressen als auf der gerenderten Seite sichtbar sind:

• Sichtbarer Textinhalt – E-Mail-Adressen in Absätzen, Listen oder Tabellenzellen.
• Mailto-Links – klickbare E-Mail-Links wie <a href="mailto:info@beispiel.de">Kontakt</a>. Der angezeigte Text kann „Kontakt“ lauten, während die Adresse nur im href-Attribut steckt.
• Data-Attribute – manche Websites speichern E-Mails in data-*-Attributen für JavaScript.
• JavaScript-Variablen – E-Mail-Adressen in <script>-Blöcken als String-Variablen oder JSON-Daten.
• HTML-Kommentare – Entwickler hinterlassen manchmal auskommentierten Code mit E-Mail-Adressen.
• Meta-Tags – <meta name="author"> oder Open-Graph-Tags können E-Mail-Adressen enthalten.
• Formularfelder – Standardwerte oder Platzhalter in Eingabefeldern.

Methode 1: HTML in unser Tool einfügen

1. Seitenquelltext anzeigen mit Strg+U (Windows/Linux) oder Cmd+Option+U (macOS).
2. Alles auswählen mit Strg+A und kopieren mit Strg+C.
3. Auf extract-emails.com/de den HTML-Quelltext einfügen.
4. Das Tool durchsucht den gesamten Inhalt – Tags, Attribute, Kommentare und Skripte – nach E-Mail-Adressen.

Unser Tool verarbeitet den Rohtext, daher findet es E-Mails in Kommentaren, Skripten und Attributen, die ein Browser nicht darstellen würde.

Methode 2: Quelltext durchsuchen

1. Seitenquelltext öffnen mit Strg+U.
2. Mit Strg+F nach @ suchen – jedes @-Zeichen wird hervorgehoben.
3. Zusätzlich nach mailto: suchen, um E-Mail-Links zu finden.

Diese Methode ist schnell, aber bei großen HTML-Dateien fehleranfällig.

Methode 3: Python mit BeautifulSoup

E-Mails aus Textinhalt und mailto-Links extrahieren

import re
from bs4 import BeautifulSoup

def emails_aus_html_extrahieren(html_inhalt):
    soup = BeautifulSoup(html_inhalt, "html.parser")
    pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
    emails = set()

    # 1. Aus sichtbarem Text
    text = soup.get_text()
    emails.update(re.findall(pattern, text))

    # 2. Aus mailto:-Links
    for link in soup.find_all("a", href=True):
        if link["href"].startswith("mailto:"):
            email = link["href"].replace("mailto:", "").split("?")[0]
            emails.add(email)

    # 3. Aus dem rohen HTML (Skripte, Kommentare, Attribute)
    emails.update(re.findall(pattern, html_inhalt))

    return sorted(emails)

# Beispiel: aus einer Datei
with open("seite.html", "r", encoding="utf-8") as f:
    html = f.read()

emails = emails_aus_html_extrahieren(html)
for email in emails:
    print(email)

Methode 4: Kommandozeile mit grep

Einzeiler für das Terminal

curl -s "https://beispiel.de/kontakt" | grep -oE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' | sort -u

Für lokale HTML-Dateien:

grep -oE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' seite.html | sort -u

Alle HTML-Dateien in einem Verzeichnis:

grep -roE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' *.html | sort -u

Verschleierte E-Mails behandeln

JavaScript-Kodierung

Manche Websites bauen E-Mail-Adressen dynamisch in JavaScript zusammen:

var benutzer = "info";
var domain = "beispiel.de";
document.write(benutzer + "@" + domain);

Standard-Regex findet diese nicht. Du müsstest das JavaScript ausführen oder die Skript-Blöcke manuell inspizieren.

HTML-Entity-Kodierung

E-Mails als HTML-Entities kodiert: info@.... Unser Tool verarbeitet den dekodierten Text und findet diese automatisch.

Text-Ersetzungsmuster

Adressen in der Form „name [at] domain [dot] de“ erfordern zusätzliche Regex-Muster:

import re

def verschleierte_emails_finden(text):
    pattern = r'[a-zA-Z0-9._%+-]+\s*[\[\(]at[\]\)]\s*[a-zA-Z0-9.-]+\s*[\[\(]dot[\]\)]\s*[a-zA-Z]{2,}'
    treffer = re.findall(pattern, text, re.IGNORECASE)
    emails = []
    for t in treffer:
        email = re.sub(r'\s*[\[\(]at[\]\)]\s*', '@', t, flags=re.IGNORECASE)
        email = re.sub(r'\s*[\[\(]dot[\]\)]\s*', '.', email, flags=re.IGNORECASE)
        emails.append(email)
    return emails

Tipps für beste Ergebnisse

• Immer den rohen HTML-Quelltext verwenden. Die gerenderte Seite zeigt nur einen Bruchteil der vorhandenen E-Mails.
• Inline-Skripte prüfen. JavaScript-Blöcke enthalten oft E-Mails in Konfigurationsobjekten oder Arrays.
• HTML-Kommentare inspizieren. Entwickler hinterlassen Kontaktdaten in auskommentierten Bereichen.
• Alle Attribute prüfen. Neben href auch value, placeholder, data-email und content.
• Kodierung beachten. HTML-Entities, URL-Kodierung (%40 für @) und JavaScript-Escape-Sequenzen können E-Mails verbergen.

FAQ

Wo verstecken sich E-Mail-Adressen im HTML-Quelltext?

Nicht nur im sichtbaren Text: auch in mailto:-Links, HTML-Attributen, Kommentaren und Meta-Tags. Deshalb findet die Extraktion aus dem Quelltext oft mehr Adressen als das bloße Kopieren der gerenderten Seite.

Wie extrahiere ich E-Mails aus einer gespeicherten HTML-Datei?

Die .html-Datei einfach per Drag & Drop in den Extractor ziehen oder den Quelltext (Strg+U, dann Strg+A/C) in das Eingabefeld kopieren. Das Tool scannt Markup samt Attributen und liefert eine deduplizierte Liste.

Was ist mit verschleierten Adressen wie „name [at] domain punkt de"?

Einfache Verschleierungen lassen sich per Suchen-und-Ersetzen zurückbauen, bevor du extrahierst. JavaScript-generierte Adressen tauchen erst im gerenderten DOM auf — dort hilft: Seite im Browser öffnen, alles markieren, kopieren, einfügen.