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

Bei der Durchführung von E-Mail-Marketingkampagnen 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 ist.
Dieses Tool liegt im API-Format vor und wird online bereitgestellt, sodass 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 und ein weit verbreitetes Tool für viele E-Mail-Clients und E-Mail-Filtertools ist, 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 mit einem Wert von 5 oder höher ein hohes Risiko, als Spam gekennzeichnet zu werden.

Da es sich bei Apache SpamAssassin um eine Spam-Erkennungssoftware handelt, kann es auch verwendet werden, um festzustellen, ob Ihre E-Mail als Spam gekennzeichnet würde.

Die Bewertung von SpamAssassin ist transparent und gut dokumentiert. Sie können damit sicher genau identifizieren, welche Aspekte Ihrer E-Mail hohe Spam-Bewertungen verursachen, und Ihr Schreiben 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.

Auf Debian- oder Ubuntu-Systemen installieren Sie SpamAssassin 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 an das Befehlszeilentool von SpamAssassin weiterleiten. Die Ausgabe enthält eine kommentierte Version der E-Mail mit Spam-Scores und erklärt, welche Regeln ausgelöst werden.

Eine typische Verwendung könnte so aussehen:

spamassassin -t  results.txt

results.txt enthält dann die verarbeitete E-Mail mit den Headern und Bewertungen 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

Wickeln Sie SpamAssassin als API ein

SpamAssassin erreicht sein maximales Potenzial nur, wenn es als API gekapselt ist, da diese Form es flexibler macht und die Integration in verschiedene Arbeitsabläufe ermöglicht.

Stellen Sie sich Folgendes vor: Bevor Sie in Ihrer E-Mail auf „Senden“ klicken, wird der Inhalt zunächst an die SpamAssassin-API gesendet. Nur wenn festgestellt wird, dass die E-Mail nicht den Spam-Kriterien entspricht, kann der Vorgang fortgesetzt werden.

Lassen Sie uns eine einfache API erstellen, die diese E-Mail-Felder akzeptiert: Betreff, html_body und text_body. Die Felder werden an SpamAssassin übergeben und das Validierungsergebnis zurückgegeben.

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="__SPAM_ASSASSIN_BOUNDARY__"

--__SPAM_ASSASSIN_BOUNDARY__
Content-Type: text/plain; charset="utf-8"

{email.text_body}

--__SPAM_ASSASSIN_BOUNDARY__
Content-Type: text/html; charset="utf-8"

{email.html_body}

--__SPAM_ASSASSIN_BOUNDARY__--"""

    # Run SpamAssassin and capture the output directly
    output = subprocess.run(["spamassassin", "-t"],
                            input=message.encode('utf-8'),
                            capture_output=True)

    output_str = output.stdout.decode('utf-8', errors='replace')
    details = extract_analysis_details(output_str)
    return {"result": details}

Im obigen Code haben wir eine Hilfsfunktion, extract_analysis_details, definiert, um nur die Bewertungsgründe aus dem vollständigen Ergebnisbericht zu extrahieren. Sie können diese Funktion noch weiter verbessern, indem Sie beispielsweise bestimmte Regeln aus dem Ergebnis herausfiltern.

Die Antwort enthält die Analysedetails der SpamAssassin-Ergebnisse.

Nehmen wir diese Eingabe als Beispiel:

Betreff

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

html_body

spamassassin -t  results.txt

text_body

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

Die Antwort wäre so:

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="__SPAM_ASSASSIN_BOUNDARY__"

--__SPAM_ASSASSIN_BOUNDARY__
Content-Type: text/plain; charset="utf-8"

{email.text_body}

--__SPAM_ASSASSIN_BOUNDARY__
Content-Type: text/html; charset="utf-8"

{email.html_body}

--__SPAM_ASSASSIN_BOUNDARY__--"""

    # Run SpamAssassin and capture the output directly
    output = subprocess.run(["spamassassin", "-t"],
                            input=message.encode('utf-8'),
                            capture_output=True)

    output_str = output.stdout.decode('utf-8', errors='replace')
    details = extract_analysis_details(output_str)
    return {"result": details}

Sehen Sie? „Lieber Gewinner“ wird erkannt, da es häufig in Spam-E-Mails verwendet wird.

Bereitstellen der API online

Für die Ausführung von SpamAssassin ist eine Linux-Umgebung mit installierter Software erforderlich. Normalerweise benötigen Sie für die Bereitstellung möglicherweise eine EC2-Instanz oder ein DigitalOcean-Droplet, was kostspielig und mühsam sein kann, insbesondere wenn Ihr Nutzungsvolumen gering ist.

Serverlose Plattformen lassen die Installation von Systempaketen wie SpamAssassin einfach nicht zu.

Leapcell kann diesen Job perfekt bewältigen.

Mit Leapcell können Sie beliebige Systempakete wie SpamAssassin bereitstellen, während der Dienst serverlos bleibt – Sie zahlen nur für Aufrufe, was normalerweise günstiger ist.

Die Bereitstellung der API auf Leapcell ist sehr einfach. Sie müssen keine Umgebung einrichten. Stellen Sie einfach ein Python-Image bereit und füllen Sie das Feld „Build Command“ ordnungsgemäß aus.

Nach der Bereitstellung verfügen Sie über eine API zur Spam-Validierung. Immer wenn die API aufgerufen wird, führt sie SpamAssassin aus, bewertet die E-Mail und gibt die Bewertung zurück.

Lesen Sie auf unserem Blog

Das obige ist der detaillierte Inhalt vonWird Ihre Marketing-E-Mail im Spam landen? Wir haben ein Tool entwickelt, um das herauszufinden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!