Mailchimp

Mantenha suas listas do Mailchimp limpas, melhore a entregabilidade e reduza custos verificando e-mails de assinantes com EmailVerify.

Por que Verificar Listas do Mailchimp?

Problema	Impacto	Solução
E-mails inválidos	Altas taxas de devolução	Verificar antes de enviar
E-mails descartáveis	Baixo engajamento	Filtrar durante inscrição
Listas desatualizadas	Reputação danificada	Limpeza periódica
Armadilhas de spam	Risco de lista negra	Identificar endereços de risco

Métodos de Integração

Método	Caso de Uso	Automação
Integração de API	Verificação em tempo real	Completa
Zapier	Automação sem código	Completa
Exportar/Importar	Limpeza em massa de lista	Manual
Webhook	Verificação de novo assinante	Completa

Método 1: Integração Zapier (Recomendado)

A maneira mais fácil de verificar assinantes do Mailchimp automaticamente.

Verificação de Novo Assinante

Gatilho: Mailchimp → Novo Assinante
    ↓
Ação: EmailVerify → Verificar E-mail
    ↓
Filtro: Com base no resultado da verificação
    ↓
Ação: Mailchimp → Atualizar assinante / Cancelar inscrição

Etapas de Configuração:

Crie um novo Zap no Zapier
Gatilho: Mailchimp - Novo Assinante
Ação: Webhooks - POST para https://api.emailverify.ai/v1/verify
Filtro: Continuar apenas se status = "válido"
Ação: Mailchimp - Atualizar Assinante com tags

Configuração:

Configurações de Webhook:
  URL: https://api.emailverify.ai/v1/verify
  Método: POST
  Cabeçalhos:
    Authorization: Bearer SUA_CHAVE_API
    Content-Type: application/json
  Corpo: {"email": "{{email}}"}

Marcar Assinantes por Qualidade

Adicione tags com base nos resultados da verificação:

Se status = "válido" E descartável = falso
  → Adicionar tag: "verificado"

Se descartável = verdadeiro
  → Adicionar tag: "descartável"
  → Atualizar: Permissões de marketing = falso

Se status = "inválido"
  → Cancelar inscrição do membro
  → Adicionar tag: "email_inválido"

Método 2: Integração Direta de API

Para aplicações personalizadas, integre diretamente com ambas as APIs.

Exemplo 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', // Seu prefixo de servidor
});

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

// Verificar um assinante
async function verifySubscriber(listId, email) {
  // Obter resultado da verificação
  const result = await emailVerify.verify(email);

  // Obter hash do assinante (MD5 do e-mail em minúsculas)
  const subscriberHash = crypto
    .createHash('md5')
    .update(email.toLowerCase())
    .digest('hex');

  // Atualizar assinante com base no resultado
  if (result.status === 'invalid') {
    // Cancelar inscrição de e-mails inválidos
    await mailchimp.lists.updateListMember(listId, subscriberHash, {
      status: 'unsubscribed',
    });

    // Adicionar tag
    await mailchimp.lists.updateListMemberTags(listId, subscriberHash, {
      tags: [{ name: 'email_inválido', status: 'active' }],
    });
  } else if (result.status === 'valid') {
    // Marcar como verificado
    const tags = [{ name: 'verificado', status: 'active' }];

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

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

  return result;
}

Exemplo 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 e-mail
    result = bv_client.verify(email)

    # Obter hash do assinante
    subscriber_hash = hashlib.md5(email.lower().encode()).hexdigest()

    if result.status == "invalid":
        # Cancelar inscrição de e-mails inválidos
        mailchimp_client.lists.update_list_member(
            list_id,
            subscriber_hash,
            {"status": "unsubscribed"}
        )

        # Adicionar tag
        mailchimp_client.lists.update_list_member_tags(
            list_id,
            subscriber_hash,
            {"tags": [{"name": "email_inválido", "status": "active"}]}
        )

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

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

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

    return result


# Verificar em massa toda a lista
def clean_list(list_id: str):
    # Obter todos os assinantes
    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: Limpeza em Massa de Lista

Para listas grandes, exporte e use a verificação em massa do EmailVerify.

Passo 1: Exportar do Mailchimp

Vá para Audiência → Todos os contatos
Clique em Exportar Audiência
Baixe o arquivo CSV

Passo 2: Verificar com EmailVerify

Usando o Dashboard:

Faça login em EmailVerify
Vá para Verificação em Massa
Faça upload do seu arquivo CSV
Aguarde o processamento
Baixe os resultados

Usando a API:

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

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

async function cleanMailchimpExport(csvPath) {
  // Ler CSV e extrair e-mails
  const csv = fs.readFileSync(csvPath, 'utf-8');
  const lines = csv.split('\n');
  const emails = lines
    .slice(1) // Pular cabeçalho
    .map((line) => line.split(',')[0]) // Primeira coluna é e-mail
    .filter((email) => email);

  // Enviar tarefa em massa
  const job = await client.verifyBulk(emails);
  console.log(`ID da Tarefa: ${job.job_id}`);

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

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

  // Separar por status
  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 };
}

Passo 3: Importar Resultados de Volta

Crie um CSV para importação no Mailchimp:

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

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

  const invalidRows = verificationResults.invalid
    .map((r) => `${r.email},"email_inválido,cancelar_inscrição"`)
    .join('\n');

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

Etapas de Importação:

Vá para Audiência → Importar contatos
Faça upload do CSV
Mapeie campos: Email Address e Tags
Escolha Atualizar contatos existentes
Conclua a importação

Integração de Webhook

Receba notificações quando a verificação for concluída:

Configurar Webhook no EmailVerify

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

Manipular Webhook

// Endpoint 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;

    // Atualizar assinante do 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: 'verificado', status: 'active' });
  } else if (status === 'invalid') {
    tags.push({ name: 'email_inválido', status: 'active' });
  }

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

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

Melhores Práticas

1. Verificar Antes de Adicionar

Verifique e-mails antes de adicionar ao Mailchimp:

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

  if (verification.status === 'invalid') {
    throw new Error('Endereço de e-mail inválido');
  }

  if (verification.result.disposable) {
    throw new Error('E-mails descartáveis não são permitidos');
  }

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

2. Limpar Listas Regularmente

Agende limpeza mensal de lista:

// Exemplo de tarefa cron (mensal)
const cron = require('node-cron');

cron.schedule('0 0 1 * *', async () => {
  console.log('Iniciando limpeza mensal de lista...');

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

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

  console.log('Limpeza de lista concluída');
});

3. Segmentar por Qualidade de E-mail

Crie segmentos para direcionamento:

Segmento de Alta Qualidade:

{
  "name": "Assinantes de Alta Qualidade",
  "conditions": {
    "match": "all",
    "conditions": [
      {
        "field": "tag",
        "op": "contains",
        "value": "verificado"
      },
      {
        "field": "tag",
        "op": "notcontain",
        "value": "descartável"
      }
    ]
  }
}

4. Usar Tags Efetivamente

Implemente uma estratégia de marcação:

Tag	Significado	Ação
`verificado`	E-mail é válido	Incluir em campanhas
`descartável`	E-mail temporário	Limitar envio
`email_inválido`	E-mail devolvido	Excluir de campanhas
`baseado_em_função`	info@, support@	Considerar excluir
`precisa_reverificar`	Última verificação > 90 dias	Re-verificar

5. Monitorar Métricas

Rastreie essas métricas após implementação:

Taxa de devolução: Deve diminuir significativamente
Taxa de abertura: Deve melhorar
Pontuação de entregabilidade: Deve aumentar
Qualidade do crescimento da lista: Rastreie inscrições verificadas vs não verificadas

Calculadora de Economia de Custos

Estime sua economia com a limpeza de lista:

Métrica	Antes da Limpeza	Depois da Limpeza
Tamanho da Lista	100.000	85.000
E-mails Inválidos	15%	Menos de 1%
Taxa de Devolução	8%	Menos de 2%
Custo Mensal de ESP	$250	$212
Economia Anual	-	$456

Listas menores e limpas geralmente têm maiores taxas de engajamento, melhorando sua reputação como remetente e entregabilidade.

Solução de Problemas

Altas Taxas de Devolução Após Limpeza

Verifique se o processo de limpeza foi concluído com êxito
Procure por assinantes não verificados adicionados recentemente
Re-verifique e-mails que aparecem como válidos mas estão sendo devolvidos

Tags Não Sendo Aplicadas

Verifique se as permissões de API incluem gerenciamento de tags
Verifique o status do assinante (membros arquivados não podem ser marcados)
Garanta que os nomes das tags não excedam limites de caracteres

Limitação de Taxa

Tanto o Mailchimp quanto o EmailVerify têm limites de taxa:

Serviço	Limite
API de Marketing do Mailchimp	10 requisições/segundo
EmailVerify	Baseado no plano

Implemente atrasos para operações em massa:

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

Recursos Relacionados

Integração Zapier

Configuração de automação sem código

ActiveCampaign

Integração de plataforma de e-mail semelhante

API de Verificação em Massa

Verifique listas grandes com eficiência

Mailchimp

Integração Zapier

ActiveCampaign

API de Verificação em Massa

On this page