CRM-Daten aus E-Mail-Signaturen extrahieren – so geht’s automatisch

E-Mail-Signaturen sind ein unterschätzter Datenschatz für Ihr CRM. Rund 82 % aller geschäftlichen Nachrichten enthalten mindestens einen Namen und eine Position – oft ergänzt um Telefonnummern, LinkedIn-Profile oder Unternehmensangaben. Doch statt diese strukturierten Daten zu nutzen, landet der Großteil dieser Informationen ungenutzt in Postfächern. Mit einem schlanken Agenten, einigen Regex-Zeilen und einer einfachen Kreuzreferenzierung lässt sich dieses Potenzial jedoch systematisch erschließen.

Warum Regex die bessere Wahl ist als KI

Für völlig unstrukturierte Texte mag ein Sprachmodell sinnvoll sein. Doch Signaturen folgen klaren Mustern: drei bis sechs Zeilen, oft durch den RFC-3676-Standard (-- ) vom Nachrichtenkörper getrennt. Diese Vorhersehbarkeit macht sie ideal für reguläre Ausdrücke. Ein Regex-Durchlauf erfasst über 95 % aller gut formatierten Signaturen – in Millisekunden und ohne zusätzliche Kosten. Ein Sprachmodell sollte erst als Backup für die verbleibenden 5 % zum Einsatz kommen, nicht als erste Wahl.

Der erste Schritt besteht darin, die Signatur vom eigentlichen Nachrichtentext zu trennen. Dafür werden typische Trennzeichen wie -- , „Sent from my iPhone“ oder „Beste Grüße“ erkannt:

SIG_DELIMITERS = [
    r"\n--\s*\n",  # RFC 3676-Standard
    r"\nSent from my (iPhone|iPad|Android)",
    r"\nBeste(r)?,?\s*\n",
    r"\nMit freundlichen Grüßen,?\s*\n",
]

def split_signature(body: str) -> tuple[str, str]:
    for pat in SIG_DELIMITERS:
        m = re.search(pat, body)
        if m:
            return body[:m.start()], body[m.end():]
    return body, ""

Anschließend werden Felder wie Telefonnummer, LinkedIn-URL (nur /in/ ist relevant, da /pub/ veraltet ist), Website, Titel und Unternehmen extrahiert. Besonders nützlich: Die Klassifizierung von Titeln in Hierarchieebenen (C-Level, VP, Director, Manager, Mitarbeiter). Ein „CEO“ als Signal ist für die Weiterverarbeitung oft wertvoller als der reine Titeltext.

Von 67 % auf 91 %: Die Macht der Kreuzreferenzierung

Eine einzelne E-Mail liefert selten vollständige Daten. Eine Antwort von unterwegs enthält vielleicht nur den Namen, eine Dankesmail nur eine Signaturzeile. Doch im Idealfall sammelt der Agent die letzten drei Nachrichten desselben Absenders und kombiniert die extrahierten Felder. Die „Merge“-Funktion wählt dabei den vollständigsten Wert pro Kategorie aus:

def enrich(sender_email: str, n: int = 3) -> dict:
    messages = list_messages_from(sender_email, limit=n)
    signatures = [split_signature(m["body"])[1] for m in messages]
    fields = [extract(s) for s in signatures]
    return merge_fields(fields)

Der Effekt ist messbar: Die Extraktion aus einer einzigen Nachricht erreicht etwa 67 % Vollständigkeit. Durch die Kombination von drei Nachrichten steigt die Quote auf rund 91 %. Das macht den Unterschied zwischen unbrauchbaren Daten und einer vertrauenswürdigen CRM-Quelle – etwa für Sales-Teams, die nach Hierarchieebenen filtern.

Zusätzliche Erkenntnisse lassen sich kostenlos aus dem Absender-Domain-Namen gewinnen: Der MX-Eintrag verrät den E-Mail-Anbieter, SPF-Einträge zeigen genutzte Tools wie SendGrid oder Salesforce, und DMARC-Einstellungen spiegeln die Sicherheitsrichtlinien wider. All diese Informationen sind ohne Analyse des Nachrichteninhalts verfügbar.

Ein eigener Posteingang für den Agenten

Doch woher stammen die E-Mails? Die Lösung sind zwei bewährte Muster mit derselben Infrastruktur: ein dedizierter Postfach-Account für den Agenten (etwa bei Nylas-hosted Mailboxes, aktuell in Beta) mit einem message.created-Webhook.

Muster 1: Passive Anreicherung. Ein bereits bestehendes Support- oder Outreach-Postfach empfängt geschäftliche E-Mails. Jede eingehende Nachricht wird vom Agenten verarbeitet, die Signatur extrahiert und ins CRM geschrieben.

Muster 2: Nutzerinitiierte Importe. Ein separates Postfach wie signaturimport@firma.de wird eingerichtet. Mitarbeiter können beliebige E-Mails an diese Adresse weiterleiten, deren Signatur dann automatisch übernommen wird. Der Webhook-Handler identifiziert den Absender der Weiterleitung und speichert die Signatur im CRM des jeweiligen Nutzers:

app.post("/webhooks/signature-import", async (req, res) => {
    res.status(200).end();
    const event = req.body;
    if (event.type !== "message.created") return;
    const msg = event.data.object;
    if (msg.grant_id !== IMPORT_GRANT_ID) return;

    const full = await nylas.messages.find({
        identifier: IMPORT_GRANT_ID,
        messageId: msg.id,
    });

    const forwarder = msg.from[0].email;
    const targetGrant = await db.grants.findByEmail(forwarder);
    if (!targetGrant) return; // Unbekannte Adresse ignorieren

    const signatureHtml = await extractSignature(full.data.body);
    if (!signatureHtml) return;

    await saveSignature(targetGrant.grantId, signatureHtml, forwarder);
});

Entscheidend ist hier die Zuordnung: Eine Tabelle muss Nutzer-E-Mail-Adressen mit grant_id verknüpfen. Unbekannte Absender der Weiterleitung werden ignoriert, um falsche Zuordnungen zu vermeiden. Die gespeicherte Signatur wird anschließend über die Signatures API in das CRM übertragen:

const signature = await nylas.signatures.create({
    identifier: targetGrantId,
    requestBody: {
        name: "Importierte Signatur",
        body: signatureHtml,
    },
});

Ein einzelnes Import-Postfach reicht aus, um alle Nutzer zu bedienen – die Zuordnung erfolgt über die Absenderadresse der Weiterleitung. Die so importierte Signatur lässt sich anschließend bei ausgehenden E-Mails nutzen, indem der signature_id-Parameter referenziert wird. Selbst Agentenpostfächer können so mit echten, menschlichen Signaturen arbeiten.

Typische Fallstricke und ihre Lösungen

• Mehrere Signaturen in einer E-Mail. Eine weitergeleitete Nachricht kann Blöcke mehrerer Personen enthalten. Soll nur die Signatur des letzten Absenders übernommen werden, muss der Extraktionsprozess die Grenze zur ersten „Weitergeleitete Nachricht“ erkennen.

• Übergroße Extraktionen. Eine Plausibilitätsprüfung verhindert Fehler: Blöcke über 20 KB sind meist kein reiner Signaturtext und sollten geloggt, aber nicht verarbeitet werden.

• Grenzen pro Grant. Jedes Grant erlaubt maximal 10 Signaturen. Vor dem Speichern muss die aktuelle Anzahl geprüft und bei Bedarf eine bestehende Signatur aktualisiert werden.

• Nur HTML-Signaturen. Die API speichert ausschließlich HTML. Reine Textsignaturen enthalten keine auslesbaren Daten.

• Bildlastige Signaturen. Viele Unternehmenssignaturen enthalten eingebettete Bilder, etwa Logos oder Porträts. Solange die Hosting-Server der Firma verfügbar sind, funktionieren diese URLs. Für mehr Stabilität können die Bilder jedoch auf den eigenen CDN-Server heruntergeladen, dort gehostet und die URLs vor dem Speichern angepasst werden.

Die Automatisierung von Signatur-Extraktion ist kein Hexenwerk – sondern eine Frage der richtigen Hebel. Mit einem Agenten, etwas Regex und einer intelligenten Kreuzreferenzierung lassen sich wertvolle CRM-Daten generieren, ohne auf teure Tools oder komplexe KI-Lösungen angewiesen zu sein. Der nächste Schritt? Die Integration in bestehende Workflows und die kontinuierliche Optimierung der Extraktionslogik für immer präzisere Ergebnisse.