Mailchimp

Halten Sie Ihre Mailchimp-Listen sauber, verbessern Sie die Lieferbarkeit und reduzieren Sie Kosten, indem Sie Abonnenten-E-Mails mit EmailVerify verifizieren.

Warum Mailchimp-Listen verifizieren?

Problem	Auswirkungen	Lösung
Ungültige E-Mails	Hohe Absprungquoten	Verifizierung vor dem Versand
Wegwerfmails	Niedrige Engagement-Rate	Filtern bei der Anmeldung
Abgelaufene Listen	Beschädigter Ruf	Regelmäßige Bereinigung
Spam-Fallen	Blacklisting-Risiko	Riskante Adressen identifizieren

Integrationsmethoden

Methode	Anwendungsfall	Automatisierung
API-Integration	Echtzeit-Verifikation	Vollständig
Zapier	No-Code-Automatisierung	Vollständig
Export/Import	Massen-Listenbereinigung	Manuell
Webhook	Verifikation neuer Abonnenten	Vollständig

Methode 1: Zapier-Integration (empfohlen)

Der einfachste Weg, Mailchimp-Abonnenten automatisch zu verifizieren.

Verifizierung neuer Abonnenten

Trigger: Mailchimp → New Subscriber
    ↓
Action: EmailVerify → Verify Email
    ↓
Filter: Based on verification result
    ↓
Action: Mailchimp → Update subscriber / Unsubscribe

Einrichtungsschritte:

Erstellen Sie einen neuen Zap in Zapier
Auslöser: Mailchimp - Neuer Abonnent
Aktion: Webhooks - POST zu https://api.emailverify.ai/v1/verify
Filter: Nur fortfahren, wenn Status = "valid"
Aktion: Mailchimp - Abonnent mit Tags aktualisieren

Konfiguration:

Webhook-Einstellungen:
  URL: https://api.emailverify.ai/v1/verify
  Methode: POST
  Header:
    Authorization: Bearer YOUR_API_KEY
    Content-Type: application/json
  Body: {"email": "{{email}}"}

Abonnenten nach Qualität taggen

Fügen Sie Tags basierend auf Verifikationsergebnissen hinzu:

If status = "valid" AND disposable = false
  → Add tag: "verified"

If disposable = true
  → Add tag: "disposable"
  → Update: Marketing permissions = false

If status = "invalid"
  → Unsubscribe member
  → Add tag: "invalid_email"

Methode 2: Direkte API-Integration

Für benutzerdefinierte Anwendungen integrieren Sie direkt mit beiden APIs.

Node.js-Beispiel

const mailchimp = require('@mailchimp/mailchimp_marketing');
const { EmailVerify } = require('@emailverify/node');

// Initialize clients
mailchimp.setConfig({
  apiKey: process.env.MAILCHIMP_API_KEY,
  server: 'us1', // Your server prefix
});

const emailVerify = new EmailVerify({
  apiKey: process.env.EMAILVERIFY_API_KEY,
});

// Verify a subscriber
async function verifySubscriber(listId, email) {
  // Get verification result
  const result = await emailVerify.verify(email);

  // Get subscriber hash (MD5 of lowercase email)
  const subscriberHash = crypto
    .createHash('md5')
    .update(email.toLowerCase())
    .digest('hex');

  // Update subscriber based on result
  if (result.status === 'invalid') {
    // Unsubscribe invalid emails
    await mailchimp.lists.updateListMember(listId, subscriberHash, {
      status: 'unsubscribed',
    });

    // Add tag
    await mailchimp.lists.updateListMemberTags(listId, subscriberHash, {
      tags: [{ name: 'invalid_email', status: 'active' }],
    });
  } else if (result.status === 'valid') {
    // Tag as verified
    const tags = [{ name: 'verified', status: 'active' }];

    if (result.result.disposable) {
      tags.push({ name: 'disposable', status: 'active' });
    }

    await mailchimp.lists.updateListMemberTags(listId, subscriberHash, { tags });
  }

  return result;
}

Python-Beispiel

import mailchimp_marketing as mailchimp
from emailverify import Client as EmailVerify
import hashlib
import os

# Initialize clients
mailchimp_client = mailchimp.Client()
mailchimp_client.set_config({
    "api_key": os.environ["MAILCHIMP_API_KEY"],
    "server": "us1"
})

bv_client = EmailVerify(api_key=os.environ["EMAILVERIFY_API_KEY"])

def verify_subscriber(list_id: str, email: str):
    # Verify email
    result = bv_client.verify(email)

    # Get subscriber hash
    subscriber_hash = hashlib.md5(email.lower().encode()).hexdigest()

    if result.status == "invalid":
        # Unsubscribe invalid emails
        mailchimp_client.lists.update_list_member(
            list_id,
            subscriber_hash,
            {"status": "unsubscribed"}
        )

        # Add tag
        mailchimp_client.lists.update_list_member_tags(
            list_id,
            subscriber_hash,
            {"tags": [{"name": "invalid_email", "status": "active"}]}
        )

    elif result.status == "valid":
        tags = [{"name": "verified", "status": "active"}]

        if result.result.disposable:
            tags.append({"name": "disposable", "status": "active"})

        mailchimp_client.lists.update_list_member_tags(
            list_id,
            subscriber_hash,
            {"tags": tags}
        )

    return result


# Bulk verify entire list
def clean_list(list_id: str):
    # Get all subscribers
    members = mailchimp_client.lists.get_list_members_info(
        list_id,
        count=1000,
        status="subscribed"
    )

    results = {"valid": 0, "invalid": 0, "unknown": 0}

    for member in members["members"]:
        result = verify_subscriber(list_id, member["email_address"])
        results[result.status] = results.get(result.status, 0) + 1

    return results

Methode 3: Massen-Listenbereinigung

Für große Listen exportieren und verwenden Sie EmailVerifys Massenverifizierung.

Schritt 1: Aus Mailchimp exportieren

Gehen Sie zu Publikum → Alle Kontakte
Klicken Sie auf Publikum exportieren
Laden Sie die CSV-Datei herunter

Schritt 2: Mit EmailVerify verifizieren

Mit dem Dashboard:

Melden Sie sich bei EmailVerify an
Gehen Sie zu Massenverifizierung
Laden Sie Ihre CSV-Datei hoch
Warten Sie auf die Verarbeitung
Laden Sie die Ergebnisse herunter

Mit der API:

const fs = require('fs');
const { EmailVerify } = require('@emailverify/node');

const client = new EmailVerify({
  apiKey: process.env.EMAILVERIFY_API_KEY,
});

async function cleanMailchimpExport(csvPath) {
  // Read CSV and extract emails
  const csv = fs.readFileSync(csvPath, 'utf-8');
  const lines = csv.split('\n');
  const emails = lines
    .slice(1) // Skip header
    .map((line) => line.split(',')[0]) // First column is email
    .filter((email) => email);

  // Submit bulk job
  const job = await client.verifyBulk(emails);
  console.log(`Job ID: ${job.job_id}`);

  // Wait for completion (poll or use webhook)
  let status;
  do {
    await new Promise((r) => setTimeout(r, 10000)); // Wait 10s
    status = await client.getBulkJobStatus(job.job_id);
    console.log(`Progress: ${status.progress_percent}%`);
  } while (status.status !== 'completed');

  // Get results
  const results = await client.getBulkJobResults(job.job_id);

  // Separate by status
  const valid = results.results.filter((r) => r.status === 'valid');
  const invalid = results.results.filter((r) => r.status === 'invalid');

  console.log(`Valid: ${valid.length}, Invalid: ${invalid.length}`);

  return { valid, invalid };
}

Schritt 3: Ergebnisse zurückimportieren

Erstellen Sie eine CSV für den Mailchimp-Import:

function createMailchimpImportCSV(verificationResults) {
  const header = 'Email Address,Tags\n';

  const validRows = verificationResults.valid
    .map((r) => {
      const tags = ['verified'];
      if (r.result.disposable) tags.push('disposable');
      return `${r.email},"${tags.join(',')}"`;
    })
    .join('\n');

  const invalidRows = verificationResults.invalid
    .map((r) => `${r.email},"invalid_email,unsubscribe"`)
    .join('\n');

  return header + validRows + '\n' + invalidRows;
}

Importschritte:

Gehen Sie zu Publikum → Kontakte importieren
Laden Sie die CSV hoch
Zuordnungsfelder: E-Mail-Adresse und Tags
Wählen Sie Bestehende Kontakte aktualisieren
Import abschließen

Webhook-Integration

Erhalten Sie Benachrichtigungen, wenn die Verifikation abgeschlossen ist:

Webhook in EmailVerify einrichten

// Create webhook
const webhook = await client.webhooks.create({
  url: 'https://your-server.com/api/emailverify-webhook',
  events: ['verification.completed'],
  secret: 'your-webhook-secret',
});

Webhook verarbeiten

// Express.js endpoint
app.post('/api/emailverify-webhook', express.json(), async (req, res) => {
  const { event, data } = req.body;

  if (event === 'verification.completed') {
    const { email, status, result } = data;

    // Update Mailchimp subscriber
    await updateMailchimpSubscriber(email, status, result);
  }

  res.status(200).send('OK');
});

async function updateMailchimpSubscriber(email, status, result) {
  const subscriberHash = crypto
    .createHash('md5')
    .update(email.toLowerCase())
    .digest('hex');

  const tags = [];

  if (status === 'valid') {
    tags.push({ name: 'verified', status: 'active' });
  } else if (status === 'invalid') {
    tags.push({ name: 'invalid_email', status: 'active' });
  }

  if (result.disposable) {
    tags.push({ name: 'disposable', status: 'active' });
  }

  await mailchimp.lists.updateListMemberTags(
    process.env.MAILCHIMP_LIST_ID,
    subscriberHash,
    { tags }
  );
}

Best Practices

1. Verifizieren vor dem Hinzufügen

Verifizieren Sie E-Mails vor dem Hinzufügen zu Mailchimp:

async function addSubscriber(listId, email, firstName, lastName) {
  // Verify first
  const verification = await emailVerify.verify(email);

  if (verification.status === 'invalid') {
    throw new Error('Invalid email address');
  }

  if (verification.result.disposable) {
    throw new Error('Disposable emails not allowed');
  }

  // Add to Mailchimp
  await mailchimp.lists.addListMember(listId, {
    email_address: email,
    status: 'subscribed',
    merge_fields: {
      FNAME: firstName,
      LNAME: lastName,
    },
    tags: ['verified'],
  });
}

2. Listen regelmäßig bereinigen

Planen Sie eine monatliche Listenbereinigung:

// Cron job example (monthly)
const cron = require('node-cron');

cron.schedule('0 0 1 * *', async () => {
  console.log('Starting monthly list cleaning...');

  const lists = await mailchimp.lists.getAllLists();

  for (const list of lists.lists) {
    await cleanList(list.id);
  }

  console.log('List cleaning complete');
});

3. Nach E-Mail-Qualität segmentieren

Erstellen Sie Segmente zum Ansprechen:

Segment mit hoher Qualität:

{
  "name": "High Quality Subscribers",
  "conditions": {
    "match": "all",
    "conditions": [
      {
        "field": "tag",
        "op": "contains",
        "value": "verified"
      },
      {
        "field": "tag",
        "op": "notcontain",
        "value": "disposable"
      }
    ]
  }
}

4. Tags effektiv nutzen

Implementieren Sie eine Tagging-Strategie:

Tag	Bedeutung	Aktion
`verified`	E-Mail ist gültig	In Kampagnen einbeziehen
`disposable`	Temporäre E-Mail	Versand einschränken
`invalid_email`	E-Mail abgesprungen	Aus Kampagnen ausschließen
`role_based`	info@, support@	Ausschluss erwägen
`needs_reverify`	Zuletzt vor >90 Tagen verifiziert	Erneut verifizieren

5. Metriken überwachen

Verfolgen Sie diese Metriken nach der Implementierung:

Bounce rate: Should decrease significantly
Open rate: Should improve
Deliverability score: Should increase
List growth quality: Track verified vs unverified signups

Kalkulator für Kosteneinsparungen

Schätzen Sie Ihre Einsparungen durch Listenbereinigung:

Metrik	Vor der Bereinigung	Nach der Bereinigung
Listengröße	100.000	85.000
Ungültige E-Mails	15%	Weniger als 1%
Absprungquote	8%	Weniger als 2%
Monatliche ESP-Kosten	250 €	212 €
Jährliche Einsparungen	-	456 €

Kleinere, saubere Listen haben oft höhere Engagement-Raten und verbessern Ihren Absender-Ruf und die Lieferbarkeit.

Fehlerbehebung

Hohe Absprungquoten nach der Bereinigung

Überprüfen Sie, ob der Bereinigungsprozess erfolgreich abgeschlossen ist
Prüfen Sie auf kürzlich hinzugefügte unverifikationierte Abonnenten
Verifizieren Sie E-Mails, die gültig angezeigt werden, aber abspringen

Tags werden nicht angewendet

Überprüfen Sie, ob API-Berechtigungen die Tag-Verwaltung umfassen
Überprüfen Sie den Abonnentenstatus (archivierte Mitglieder können nicht getaggt werden)
Stellen Sie sicher, dass Tag-Namen die Zeichenlimits nicht überschreiten

Rate Limiting

Sowohl Mailchimp als auch EmailVerify haben Ratenlimits:

Service	Limit
Mailchimp Marketing API	10 Anfragen/Sekunde
EmailVerify	Basierend auf Plan

Implementieren Sie Verzögerungen für Massenoperationen:

async function processWithDelay(items, processFn, delayMs = 100) {
  for (const item of items) {
    await processFn(item);
    await new Promise((r) => setTimeout(r, delayMs));
  }
}