Turn email signatures into clean CRM data without LLMs or vendors

Every day, businesses waste a hidden data source: email signatures. Roughly 82% of corporate emails include a signature with contact details like names, titles, phone numbers, and LinkedIn profiles—structured data disguised as plain text. Most CRMs ignore this trove, but with a simple agent and regex-based parsing, you can transform it into clean, actionable contact records without expensive tools or AI models.

Why regex outperforms AI for signature extraction

Signatures follow predictable patterns: 3–6 lines of text, often separated from the main email by RFC 3676’s -- delimiter. Unlike unstructured prose, these formats are consistent, making them ideal for regex-based parsing. A well-crafted regex function can capture over 95% of correctly formatted signatures in milliseconds, with no cost per message. Reserve AI or large language models for the rare 5% of ambiguous cases—start with regex and scale only if needed.

Begin by isolating the signature block. Use these common delimiters to detect where the signature starts and the main email ends:

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, ""

Next, extract key fields: phone numbers, LinkedIn profiles (searching for /in/ only), websites, titles, and company names. A critical enhancement is classifying titles into tiers—C-suite, VP, director, manager, or individual contributor—to prioritize high-value leads. For example, spotting a CEO in the signature signals a routing opportunity far more valuable than the raw title text.

How cross-referencing boosts accuracy from 67% to 91%

Single emails rarely contain complete signature data. A reply from a mobile device might lack a title or company name, while a thank-you note may only include a sender’s name. To solve this, aggregate signatures from the last three emails from each sender and merge the most complete version of each 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)

This cross-referencing approach raises field completeness from 67% to 91%. The result? Reliable data that sales teams can trust and filter by instead of a messy column prone to errors.

For even deeper enrichment, query public DNS records with three simple lookups:

• MX records reveal the sender’s mail host.
• SPF include statements identify tools like SendGrid or Salesforce.
• DMARC policies hint at security maturity.

These checks require no email body parsing and deliver free, high-value insights.

Set up a dedicated inbox for your signature agent

To automate the process, deploy an agent with its own mailbox using a service like Nylas. Configure a message.created webhook to trigger signature extraction and CRM updates.

There are two primary deployment patterns for this agent:

Pattern one: Passive enrichment. Use an existing shared inbox, such as support@ or outreach@. Every inbound email becomes a parsing opportunity—extract, cross-reference, and update the CRM in real time.

Pattern two: User-initiated imports. Create a dedicated address like signatureimport@company.com and instruct users to forward any email carrying their desired signature. The handler identifies the forwarder, extracts the HTML signature, and associates it with the user’s CRM record.

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; // Ignore unknown addresses

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

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

The system relies on a mapping table that links user email addresses to CRM grant_id values. Unknown forwarders should be logged and ignored—not guessed—ensuring data integrity.

Common pitfalls and how to avoid them

When processing signatures, several edge cases regularly disrupt workflows:

• Multiple signatures in one email. Forwarded threads often contain signature blocks from multiple recipients. Extract the most recent sender’s signature by checking for Forwarded message boundaries.
• Oversized extractions. A signature block exceeding 20 KB may include unrelated content. Implement a sanity check to log and skip these cases.
• Grant storage limits. Each CRM grant can hold up to 10 signatures. Track usage and update existing entries instead of failing after the eleventh.
• HTML-only formats. The CRM’s Signatures API stores HTML, so plain-text forwards yield no usable data. Ensure your system handles HTML extraction reliably.
• Image-heavy corporate signatures. Many signatures embed company logos or headshots via image tags. These URLs remain functional only as long as the company’s servers are active. For long-term reliability, download images, host them on your CDN, and rewrite URLs before saving.

Implementing a signature extraction agent transforms overlooked email metadata into a powerful CRM asset. With regex parsing, cross-referencing, and a dedicated inbox, you can automate contact enrichment while keeping costs low and accuracy high.