Mailchimp

Houd uw Mailchimp-lijsten schoon, verbeter afleverbaarheid en verlaag kosten door abonnee-e-mails te verifiëren met EmailVerify.

Waarom Mailchimp-lijsten verifiëren?

Probleem	Impact	Oplossing
Ongeldige e-mails	Hoge bouncepercentages	Verifieer vóór verzending
Wegwerp-e-mails	Lage betrokkenheid	Filter tijdens aanmelding
Verouderde lijsten	Beschadigde reputatie	Periodieke opschoning
Spamvallen	Blacklistingrisico	Identificeer risicovolle adressen

Integratiemethoden

Methode	Gebruiksscenario	Automatisering
API-integratie	Realtime verificatie	Volledig
Zapier	No-code automatisering	Volledig
Export/Import	Bulk-lijstopschoning	Handmatig
Webhook	Nieuwe abonneeverificatie	Volledig

Methode 1: Zapier-integratie (Aanbevolen)

De eenvoudigste manier om Mailchimp-abonnees automatisch te verifiëren.

Nieuwe abonneeverificatie

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

Setup-stappen:

Maak een nieuwe Zap in Zapier
Trigger: Mailchimp - New Subscriber
Action: Webhooks - POST naar https://api.emailverify.ai/v1/verify
Filter: Alleen doorgaan als status = "valid"
Action: Mailchimp - Update Subscriber met tags

Configuratie:

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

Abonnees taggen op kwaliteit

Voeg tags toe op basis van verificatieresultaten:

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: Directe API-integratie

Voor aangepaste applicaties, integreer direct met beide API's.

Node.js-voorbeeld

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-voorbeeld

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: Bulk-lijstopschoning

Voor grote lijsten, exporteer en gebruik EmailVerify's bulkverificatie.

Stap 1: Exporteren uit Mailchimp

Ga naar Audience → All contacts
Klik op Export Audience
Download het CSV-bestand

Stap 2: Verifiëren met EmailVerify

Via het Dashboard:

Log in op EmailVerify
Ga naar Bulk Verification
Upload uw CSV-bestand
Wacht op verwerking
Download resultaten

Via de 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 };
}

Stap 3: Resultaten terug importeren

Maak een CSV voor 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;
}

Importstappen:

Ga naar Audience → Import contacts
Upload de CSV
Map velden: Email Address en Tags
Kies Update existing contacts
Voltooi import

Webhook-integratie

Ontvang notificaties wanneer verificatie voltooid is:

Webhook instellen in EmailVerify

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

Webhook afhandelen

// 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. Verifieer vóór toevoegen

Verifieer e-mails voordat ze aan Mailchimp worden toegevoegd:

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. Reinig lijsten regelmatig

Plan maandelijkse lijstopschoning:

// 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. Segmenteer op e-mailkwaliteit

Maak segmenten voor targeting:

High Quality Segment:

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

4. Gebruik tags effectief

Implementeer een taggingstrategie:

Tag	Betekenis	Actie
`verified`	E-mail is geldig	Opnemen in campagnes
`disposable`	Tijdelijk e-mailadres	Beperkt verzenden
`invalid_email`	E-mail bounced	Uitsluiten van campagnes
`role_based`	info@, support@	Overweeg uitsluiten
`needs_reverify`	Laatst geverifieerd >90 dagen	Opnieuw verifiëren

5. Monitor metrics

Volg deze metrics na implementatie:

Bouncepercentage: Zou significant moeten dalen
Openingspercentage: Zou moeten verbeteren
Afleverbaarheidscore: Zou moeten stijgen
Lijstgroeikwaliteit: Volg geverifieerde vs. niet-geverifieerde aanmeldingen

Kostenbesparingscalculator

Schat uw besparingen van lijstopschoning:

Metriek	Vóór opschoning	Na opschoning
Lijstgrootte	100.000	85.000
Ongeldige e-mails	15%	Minder dan 1%
Bouncepercentage	8%	Minder dan 2%
Maandelijkse ESP-kosten	€250	€212
Jaarlijkse besparing	-	€456

Kleinere, schonere lijsten hebben vaak hogere betrokkenheidspercentages, wat uw afzenderreputatie en afleverbaarheid verbetert.

Probleemoplossing

Hoge bouncepercentages na opschoning

Verifieer dat het opschoningsproces succesvol is voltooid
Controleer op recent toegevoegde niet-geverifieerde abonnees
Verifieer opnieuw e-mails die als geldig worden getoond maar bouncen

Tags worden niet toegepast

Verifieer dat API-rechten tagbeheer bevatten
Controleer abonneestatus (gearchiveerde leden kunnen niet worden getagd)
Zorg dat tagnamen de tekenlimiet niet overschrijden

Rate limiting

Zowel Mailchimp als EmailVerify hebben rate limits:

Service	Limiet
Mailchimp Marketing API	10 verzoeken/seconde
EmailVerify	Gebaseerd op abonnement

Implementeer vertragingen voor bulkoperaties:

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

Gerelateerde bronnen

Zapier-integratie

No-code automatisering setup

ActiveCampaign

Vergelijkbare e-mailplatform-integratie

Bulk Verification API

Verifieer grote lijsten efficiënt

Mailchimp

Zapier-integratie

ActiveCampaign

Bulk Verification API

On this page