Import Email Signatures Into Your CRM With an Agent

Email signatures are the most valuable dataset your CRM is throwing away. Roughly 82% of business email carries a signature with at least a name and title — and usually a phone number, a LinkedIn URL, a company name, sometimes a whole org-chart hint. That's structured data masquerading as prose, delivered free with every message, and most platforms scroll right past it.

You don't need a data vendor or even an LLM to harvest it. A few hundred lines of regex, a cross-referencing trick, and a dedicated inbox for the agent doing the work gets you to production-usable accuracy. Here's the build.

Regex beats the LLM here (really)

For genuinely unstructured prose, a model wins. Signatures aren't unstructured — they're predictably structured: 3–6 lines, often separated from the body by the RFC 3676 -- delimiter, drawing from a small set of field types. A regex pass catches over 95% of well-formed signatures, runs in microseconds, and costs nothing per message. Keep the LLM as a fallback for the weird 5%, and skip it entirely in version one.

Find the boundary first:

import re



SIG_DELIMITERS = [

    r"\n--\s*\n",                # RFC 3676 standard

    r"\nSent from my (iPhone|iPad|Android)",

    r"\nBest,?\s*\n",

    r"\nRegards,?\s*\n",

    r"\nCheers,?\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, ""

Then pull fields — phone, LinkedIn (/in/ only; the /pub/ URL shape was retired years ago), website, plus title and company against a keyword vocabulary. The detail that makes this sales-relevant: classify titles into tiers (C-suite, VP, Director, Manager, IC). "CEO" as a routing signal is worth far more than the raw title string.

The trick that takes you from 67% to 91%

One email rarely gives you a complete picture. The "Sent from my iPhone" reply has nothing. The quick thank-you has just a name. The mid-thread message has the full block.

So don't extract from one message — pull the last three from the same sender, extract from each, and merge, taking the most complete value per field:

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)

The lift is the headline number: single-message extraction nets about 67% field completeness; three-message cross-referencing hits about 91%. That's the difference between a column nobody trusts and one your sales team filters on.

Bonus intelligence that costs three DNS queries: the sender's domain reveals their mail host via MX records, their tooling via SPF includes (SendGrid, Salesforce...), and their security maturity via DMARC. Free enrichment, no email body required.

Give the agent its own inbox

Where does the mail come from? Two patterns, same infrastructure — a dedicated covers the forward-to-import flow end to end, and the signature enrichment recipe covers the regex vocabulary and the cross-referencing math.

Next step: grab the last 50 messages from your own inbox, run the boundary-splitter above over them, and count the hit rate. If it's anywhere near that 82% figure, you've got a CRM enrichment pipeline hiding in mail you already receive.