Wird Ihre Marketing-E-Mail im Spam landen? Wir haben ein Tool entwickelt, um das herauszufinden

Wenn Sie E-Mail-Marketingkampagnen durchführen, besteht eine der größten Herausforderungen darin, sicherzustellen, dass Ihre Nachrichten den Posteingang und nicht den Spam-Ordner erreichen.

In diesem Beitrag erstellen wir ein Tool, das überprüfen kann, ob Ihre E-Mail als Spam markiert wird und warum sie so markiert wird. Dieses Tool wird in Form einer API vorliegen und online bereitgestellt, so dass es in Ihren Workflow integriert werden kann.

Das Geheimnis hinter der Spam-Validierung

Apache SpamAssassin ist eine Open-Source-Spam-Erkennungsplattform, die von der Apache Software Foundation verwaltet wird. Es ist ein weit verbreitetes Tool für viele E-Mail-Clients und E-Mail-Filtertools, um Nachrichten als Spam zu klassifizieren.

Es verwendet eine Vielzahl von Regeln, Bayes'sche Filterung und Netzwerktests, um einer bestimmten E-Mail einen Spam-„Score“ zuzuweisen. Im Allgemeinen besteht bei einer E-Mail, die 5 oder mehr Punkte erzielt, ein hohes Risiko, als Spam markiert zu werden.

Da Apache SpamAssassin eine Spam-Erkennungssoftware ist, kann es auch verwendet werden, um festzustellen, ob Ihre E-Mail als Spam gekennzeichnet wird.

Die Bewertung von SpamAssassin ist transparent und gut dokumentiert. Sie können sie getrost verwenden, um genau zu identifizieren, welche Aspekte Ihrer E-Mail hohe Spam-Werte verursachen, und Ihre Texte verbessern.

So validieren Sie Ihre E-Mail mit SpamAssassin

SpamAssassin ist für die Ausführung auf Linux-Systemen konzipiert. Sie benötigen ein Linux-Betriebssystem oder erstellen einen Docker-Container, um es zu installieren und auszuführen.

Installieren Sie SpamAssassin unter Debian- oder Ubuntu-Systemen mit:

apt-get update && apt-get install -y spamassassin
sa-update

Der Befehl sa-update stellt sicher, dass die Regeln von SpamAssassin auf dem neuesten Stand sind.

Nach der Installation können Sie eine E-Mail-Nachricht in das Befehlszeilentool von SpamAssassin pipen. Die Ausgabe enthält eine kommentierte Version der E-Mail mit Spam-Scores und erläutert, welche Regeln ausgelöst werden.

Eine typische Verwendung könnte wie folgt aussehen:

spamassassin -t < input_email.txt > results.txt

results.txt enthält dann die verarbeitete E-Mail mit den Headern und Scores von SpamAssassin, wie unten:

X-Spam-Checker-Version: SpamAssassin 4.0.0 (2022-12-13) on 254.254.254.254
X-Spam-Level: 
X-Spam-Status: No, score=0.2 required=5.0 tests=HTML_MESSAGE,
    MIME_HTML_ONLY,MISSING_MID,NO_RECEIVED,
    NO_RELAYS autolearn=no autolearn_force=no version=4.0.0

// ...

Content analysis details:   (0.2 points, 5.0 required)

 pts rule name              description
----	---------------------- --------------------------------------------------
 0.1 MISSING_MID            Missing Message-Id: header
-0.0 NO_RECEIVED            Informational: message has no Received headers
-0.0 NO_RELAYS              Informational: message was not relayed via SMTP
 0.0 HTML_MESSAGE           BODY: HTML included in message
 0.1 MIME_HTML_ONLY         BODY: Message only has text/html MIME parts

SpamAssassin als API verpacken

SpamAssassin entfaltet sein maximales Potenzial erst, wenn es als API verkapselt ist, da diese Form es flexibler macht und die Integration in verschiedene Workflows ermöglicht.

Stellen Sie sich Folgendes vor: Bevor Sie in Ihrer E-Mail auf „Senden“ klicken, wird der Inhalt zuerst an die SpamAssassin-API gesendet. Nur wenn diese feststellt, dass die E-Mail nicht den Spam-Kriterien entspricht, darf sie fortgesetzt werden.

Erstellen wir eine einfache API, die diese E-Mail-Felder akzeptiert: subject, html_body und text_body. Sie übergibt die Felder an SpamAssassin und gibt das Validierungsergebnis zurück.

API-Beispiel

from fastapi import FastAPI
from datetime import datetime, timezone
from email.utils import format_datetime
from pydantic import BaseModel
import subprocess

def extract_analysis_details(text):
    lines = text.splitlines()

    start_index = None
    for i, line in enumerate(lines):
        if line.strip().startswith("pts rule"):
            start_index = i
            break

    if start_index is None:
        print("No content analysis details found.")
        return []

    data_lines = lines[start_index+2:]
    parsed_lines = []
    for line in data_lines:
        if line.strip() == "":
            break
        parsed_lines.append(line)

    results = []
    current_entry = None

    split_line = lines[start_index+1]
    pts_split, rule_split, *rest = split_line.strip().split(" ")

    pts_start = 0
    pts_end = pts_start + len(pts_split)

    rule_start = pts_end + 1
    rule_end = rule_start + len(rule_split)

    desc_start = rule_end + 1

    for line in parsed_lines:
        pts_str = line[pts_start:pts_end].strip()
        rule_name_str = line[rule_start:rule_end].strip()
        description_str = line[desc_start:].strip()

        if pts_str == "" and rule_name_str == "" and description_str:
            if current_entry:
                current_entry["description"] += " " + description_str
        else:
            current_entry = {
                "pts": pts_str,
                "rule_name": rule_name_str,
                "description": description_str
            }
            results.append(current_entry)

    return results

app = FastAPI()

class Email(BaseModel):
    subject: str
    html_body: str
    text_body: str

@app.post("/spam_check")
def spam_check(email: Email):
    # assemble the full email
    message = f"""From: example@example.com
To: recipient@example.com
Subject: {email.subject}
Date: {format_datetime(datetime.now(timezone.utc))}
MIME-Version: 1.0
Content-Type: multipart/alternative; boundary=\