How I automate my email monitoring with GPT-4o

I read hundreds of emails a day. Not really — GPT-4o mini reads them. I just receive a 10-line digest every morning on WhatsApp.

Erwan's inbox, , receives a daily stream of newsletters, sector alerts, prospect replies, SaaS tool follow-ups, and various service notifications. All mixed together, with no apparent priority.hello@thenocodeguy.com, , receives a daily stream of newsletters, sector alerts, prospect replies, SaaS tool follow-ups, and various service notifications. All mixed together, with no apparent priority.

The classic problem: either you spend 30 minutes a day reading everything (massive cognitive overhead), or you skip it and miss something important.

My solution: an automatic pipeline that reads, sorts, summarizes, and delivers the useful signal — without anyone touching the inbox.

The architecture at a glance

Four steps, zero human clicks:

1. 1Fetch : Microsoft Graph API retrieves unread emails from the last 24h
2. 2Filter : A Python script classifies: newsletters, leads, alerts, spam
3. 3Summary : GPT-4o mini generates a summary + relevance score for each email
4. 4Digest : A structured WhatsApp message is delivered every morning at 7:30

Step 1 — Microsoft Graph API

The inbox is hosted on Microsoft 365. Graph API allows access to emails via OAuth2, without going through IMAP. It's faster, more stable, and the token doesn't expire (application credentials, no refresh token).

The script starts with a call to retrieve emails from the last 24 hours:

import httpx

def get_token(tenant_id, client_id, client_secret):
    url = f"https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token"
    data = {
        "grant_type": "client_credentials",
        "client_id": client_id,
        "client_secret": client_secret,
        "scope": "https://graph.microsoft.com/.default",
    }
    r = httpx.post(url, data=data)
    return r.json()["access_token"]

def fetch_recent_emails(token, user_email, hours=24):
    since = (datetime.utcnow() - timedelta(hours=hours)).isoformat() + "Z"
    url = (
        f"https://graph.microsoft.com/v1.0/users/{user_email}/messages"
        f"?$filter=receivedDateTime ge {since}"
        f"&$select=subject,from,receivedDateTime,bodyPreview,isRead"
        f"&$top=50&$orderby=receivedDateTime desc"
    )
    headers = {"Authorization": f"Bearer {token}"}
    r = httpx.get(url, headers=headers)
    return r.json().get("value", [])

Simple. No complicated email library, no MIME parsing. Graph API directly returns clean JSON with the sender, subject, and a body preview.

Step 2 — Filtering and classification

Before calling GPT, we filter. Sending 50 emails to an LLM is expensive and slow. Initial classification is done by deterministic rules:

SPAM_PATTERNS = ["unsubscribe", "se désabonner", "no-reply@", "noreply@"]
PRIORITY_SENDERS = ["@client.com", "erwan@", "hello@thenocodeguy.com"]
NEWSLETTER_KEYWORDS = ["newsletter", "digest", "weekly", "hebdo", "recap"]

def classify_email(email: dict) -> str:
    subject = email["subject"].lower()
    sender = email["from"]["emailAddress"]["address"].lower()
    preview = email["bodyPreview"].lower()
    
    if any(p in sender for p in SPAM_PATTERNS):
        return "spam"
    if any(s in sender for s in PRIORITY_SENDERS):
        return "priority"
    if any(k in subject or k in preview for k in NEWSLETTER_KEYWORDS):
        return "newsletter"
    return "other"

def filter_for_llm(emails):
    return [e for e in emails 
            if classify_email(e) in ("priority", "newsletter")]

Result: we often go from 40-50 emails down to 10-15 that genuinely deserve a summary. Token savings, and better digest quality.

Step 3 — GPT-4o mini summarizes and scores

For each filtered email, GPT-4o mini generates two things: a 1-2 sentence summary, and a relevance score from 1 to 5. The prompt is short and structured to force a JSON response:

SYSTEM_PROMPT = """Tu es un assistant de veille email pour un consultant en automatisation IA.
Pour chaque email, génère un JSON avec:
- summary: résumé actionnable en 1-2 phrases max (français)
- score: pertinence de 1 (bruit) à 5 (action requise)
- action: null ou "répondre" | "lire" | "archiver"
"""

def summarize_email(email: dict, client) -> dict:
    content = f"""
Expéditeur: {email['from']['emailAddress']['address']}
Sujet: {email['subject']}
Preview: {email['bodyPreview'][:500]}
"""
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": content},
        ],
        response_format={"type": "json_object"},
        max_tokens=150,
    )
    return json.loads(response.choices[0].message.content)

The response_format: json_object is essential — it avoids fragile markdown parsing. GPT returns clean JSON, directly parsable.

{
  "summary": "Client Kelly demande un devis pour automatisation CRM. Deadline vendredi.",
  "score": 5,
  "action": "répondre"
}

Step 4 — The WhatsApp digest

Summaries are sorted by descending score, formatted into a readable WhatsApp message, and sent via the OpenClaw gateway. The whole thing runs as a Windmill job scheduled at 7:30 every morning.

def format_digest(summaries: list[dict]) -> str:
    sorted_items = sorted(summaries, key=lambda x: x["score"], reverse=True)
    
    lines = ["📧 *Digest Email — ce matin*\n"]
    
    for item in sorted_items:
        score_emoji = "🔴" if item["score"] >= 4 else "🟡" if item["score"] >= 2 else "⚪"
        action = f" → _{item['action']}_" if item["action"] else ""
        lines.append(f"{score_emoji} {item['subject']}")
        lines.append(f"   {item['summary']}{action}\n")
    
    lines.append(f"_{len(sorted_items)} emails analysés_")
    return "\n".join(lines)

The message looks like this in WhatsApp:

Windmill orchestration

The full script runs on Windmill as a scheduled Python job. A few implementation details that matter:

What it changes in practice

Before this pipeline, Erwan would open his inbox in the morning and spend 15-20 minutes sorting, reading, deciding. It's a daily cognitive cost that seems small — but multiplied by 250 working days, it represents between 60 and 80 hours per year.

Today, the workflow comes down to: read the WhatsApp digest in 2 minutes, reply to the 1-2 emails flagged "action required". The rest is handled automatically.

What I would extend next

The current pipeline is intentionally simple. The natural extensions:

• Automatic replies to leads : Detection of quote requests → GPT-4o-generated draft reply → sent after quick approval (1 tap in WhatsApp).
• Follow-up thread : Track conversation threads: if a lead hasn't replied in 3 days, automatically generate a follow-up.
• Insight extraction : Identify patterns over 30 days: which topics recur? Which clients write the most? Data for commercial strategy.

Each of these extensions is an additional Windmill script. Not an architecture overhaul. That's the real value of a well-designed pipeline from the start: extensibility is trivial.

The key takeaway

We talk a lot about "email automation" as an abstract concept. In practice, it's a 200-line Python pipeline that runs at 7:30 every morning and saves an hour per week — forever.

The effort-to-value ratio is enormous. Initial setup: 4-5 hours. Recurring gain: 1h/week minimum. Positive ROI after 1 month.

The best workflows are the ones you forget are running.