Mailchimp

Mantenga sus listas de Mailchimp limpias, mejore la entregabilidad y reduzca costos verificando los correos electrónicos de sus suscriptores con EmailVerify.

¿Por qué verificar listas de Mailchimp?

Problema	Impacto	Solución
Correos inválidos	Alta tasa de rebote	Verificar antes de enviar
Correos desechables	Bajo engagement	Filtrar durante el registro
Listas obsoletas	Reputación dañada	Limpieza periódica
Trampas de spam	Riesgo de lista negra	Identificar direcciones riesgosas

Métodos de integración

Método	Caso de uso	Automatización
Integración API	Verificación en tiempo real	Completa
Zapier	Automatización sin código	Completa
Exportar/Importar	Limpieza masiva de listas	Manual
Webhook	Verificación de nuevos suscriptores	Completa

Método 1: Integración con Zapier (Recomendado)

La forma más fácil de verificar suscriptores de Mailchimp automáticamente.

Verificación de nuevos suscriptores

Trigger: Mailchimp → Nuevo suscriptor
    ↓
Action: EmailVerify → Verificar correo
    ↓
Filter: Basado en resultado de verificación
    ↓
Action: Mailchimp → Actualizar suscriptor / Dar de baja

Pasos de configuración:

Cree un nuevo Zap en Zapier
Trigger: Mailchimp - Nuevo suscriptor
Action: Webhooks - POST a https://api.emailverify.ai/v1/verify
Filter: Solo continuar si status = "valid"
Action: Mailchimp - Actualizar suscriptor con etiquetas

Configuración:

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

Etiquetar suscriptores por calidad

Agregue etiquetas basadas en los resultados de verificación:

Si status = "valid" Y disposable = false
  → Agregar etiqueta: "verified"

Si disposable = true
  → Agregar etiqueta: "disposable"
  → Actualizar: Permisos de marketing = false

Si status = "invalid"
  → Dar de baja al miembro
  → Agregar etiqueta: "invalid_email"

Método 2: Integración directa con API

Para aplicaciones personalizadas, integre directamente con ambas APIs.

Ejemplo en Node.js

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

// Inicializar clientes
mailchimp.setConfig({
  apiKey: process.env.MAILCHIMP_API_KEY,
  server: 'us1', // El prefijo de su servidor
});

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

// Verificar un suscriptor
async function verifySubscriber(listId, email) {
  // Obtener resultado de verificación
  const result = await emailVerify.verify(email);

  // Obtener hash del suscriptor (MD5 del email en minúsculas)
  const subscriberHash = crypto
    .createHash('md5')
    .update(email.toLowerCase())
    .digest('hex');

  // Actualizar suscriptor basado en el resultado
  if (result.status === 'invalid') {
    // Dar de baja correos inválidos
    await mailchimp.lists.updateListMember(listId, subscriberHash, {
      status: 'unsubscribed',
    });

    // Agregar etiqueta
    await mailchimp.lists.updateListMemberTags(listId, subscriberHash, {
      tags: [{ name: 'invalid_email', status: 'active' }],
    });
  } else if (result.status === 'valid') {
    // Etiquetar como verificado
    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;
}

Ejemplo en Python

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

# Inicializar clientes
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):
    # Verificar correo
    result = bv_client.verify(email)

    # Obtener hash del suscriptor
    subscriber_hash = hashlib.md5(email.lower().encode()).hexdigest()

    if result.status == "invalid":
        # Dar de baja correos inválidos
        mailchimp_client.lists.update_list_member(
            list_id,
            subscriber_hash,
            {"status": "unsubscribed"}
        )

        # Agregar etiqueta
        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


# Verificación masiva de toda la lista
def clean_list(list_id: str):
    # Obtener todos los suscriptores
    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

Método 3: Limpieza masiva de listas

Para listas grandes, exporte y use la verificación masiva de EmailVerify.

Paso 1: Exportar desde Mailchimp

Vaya a Audience → All contacts
Haga clic en Export Audience
Descargue el archivo CSV

Paso 2: Verificar con EmailVerify

Usando el panel:

Inicie sesión en EmailVerify
Vaya a Verificación en Lote
Cargue su archivo CSV
Espere el procesamiento
Descargue los resultados

Usando la API:

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

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

async function cleanMailchimpExport(csvPath) {
  // Leer CSV y extraer correos
  const csv = fs.readFileSync(csvPath, 'utf-8');
  const lines = csv.split('\n');
  const emails = lines
    .slice(1) // Saltar encabezado
    .map((line) => line.split(',')[0]) // Primera columna es el correo
    .filter((email) => email);

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

  // Esperar finalización (polling o usar webhook)
  let status;
  do {
    await new Promise((r) => setTimeout(r, 10000)); // Esperar 10s
    status = await client.getBulkJobStatus(job.job_id);
    console.log(`Progreso: ${status.progress_percent}%`);
  } while (status.status !== 'completed');

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

  // Separar por estado
  const valid = results.results.filter((r) => r.status === 'valid');
  const invalid = results.results.filter((r) => r.status === 'invalid');

  console.log(`Válidos: ${valid.length}, Inválidos: ${invalid.length}`);

  return { valid, invalid };
}

Paso 3: Importar resultados de vuelta

Crear un CSV para importar a Mailchimp:

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

Pasos de importación:

Vaya a Audience → Import contacts
Cargue el CSV
Mapee los campos: Email Address y Tags
Elija Update existing contacts
Complete la importación

Integración con Webhook

Reciba notificaciones cuando se complete la verificación:

Configurar Webhook en EmailVerify

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

Manejar Webhook

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

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

    // Actualizar suscriptor en Mailchimp
    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 }
  );
}

Mejores prácticas

1. Verificar antes de agregar

Verifique correos antes de agregarlos a Mailchimp:

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

  if (verification.status === 'invalid') {
    throw new Error('Dirección de correo inválida');
  }

  if (verification.result.disposable) {
    throw new Error('No se permiten correos desechables');
  }

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

2. Limpiar listas regularmente

Programe limpieza mensual de listas:

// Ejemplo de cron job (mensual)
const cron = require('node-cron');

cron.schedule('0 0 1 * *', async () => {
  console.log('Iniciando limpieza mensual de listas...');

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

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

  console.log('Limpieza de listas completada');
});

3. Segmentar por calidad de correo

Crear segmentos para targeting:

Segmento de alta calidad:

{
  "name": "Suscriptores de alta calidad",
  "conditions": {
    "match": "all",
    "conditions": [
      {
        "field": "tag",
        "op": "contains",
        "value": "verified"
      },
      {
        "field": "tag",
        "op": "notcontain",
        "value": "disposable"
      }
    ]
  }
}

4. Usar etiquetas efectivamente

Implemente una estrategia de etiquetado:

Etiqueta	Significado	Acción
`verified`	Correo es válido	Incluir en campañas
`disposable`	Correo temporal	Limitar envíos
`invalid_email`	Correo rebotó	Excluir de campañas
`role_based`	info@, support@	Considerar excluir
`needs_reverify`	Última verificación >90 días	Re-verificar

5. Monitorear métricas

Rastree estas métricas después de implementar:

Tasa de rebote: Debería disminuir significativamente
Tasa de apertura: Debería mejorar
Puntuación de entregabilidad: Debería aumentar
Calidad de crecimiento de lista: Rastrear registros verificados vs no verificados

Calculadora de ahorro de costos

Estime sus ahorros por limpieza de listas:

Métrica	Antes de limpiar	Después de limpiar
Tamaño de lista	100,000	85,000
Correos inválidos	15%	Menos del 1%
Tasa de rebote	8%	Menos del 2%
Costo mensual ESP	$250	$212
Ahorro anual	-	$456

Las listas más pequeñas y limpias suelen tener tasas de engagement más altas, mejorando su reputación de remitente y entregabilidad.

Solución de problemas

Altas tasas de rebote después de la limpieza

Verifique que el proceso de limpieza se completó exitosamente
Busque suscriptores agregados recientemente sin verificar
Re-verifique correos que se muestran como válidos pero están rebotando

Las etiquetas no se aplican

Verifique que los permisos de API incluyen gestión de etiquetas
Revise el estado del suscriptor (los miembros archivados no pueden ser etiquetados)
Asegúrese de que los nombres de etiquetas no excedan los límites de caracteres

Límites de tasa

Tanto Mailchimp como EmailVerify tienen límites de tasa:

Servicio	Límite
Mailchimp Marketing API	10 solicitudes/segundo
EmailVerify	Según el plan

Implemente retrasos para operaciones masivas:

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

Recursos relacionados

Integración con Zapier

Configuración de automatización sin código

ActiveCampaign

Integración similar de plataforma de correo

API de verificación en lote

Verifique listas grandes eficientemente

Mailchimp

Integración con Zapier

ActiveCampaign

API de verificación en lote

On this page