EmailVerify LogoEmailVerify
Guias de IntegraçãoMarketing & CRM

ActiveCampaign

Email checker for ActiveCampaign. Verify contacts in your email marketing automation.

Integre o EmailVerify com o ActiveCampaign para verificar endereços de e-mail, limpar suas listas de contatos e melhorar a entrega de e-mails.

Métodos de Integração

MétodoMelhor ParaComplexidade
Automação por WebhookVerificação em tempo realBaixa
Integração de APIFluxos de trabalho personalizadosMédia
Importação em LoteLimpeza de listaBaixa

Método 1: Automação por Webhook

Crie uma automação que verifique e-mails quando contatos são adicionados.

Criar Ação de Webhook

  1. Vá para Automações → Nova Automação
  2. Escolha um gatilho (por exemplo, "Inscreve-se em uma lista")
  3. Adicione ação → Condições e Fluxo de Trabalho → Webhook
  4. Configure o webhook:
URL: https://api.emailverify.ai/v1/verify
Method: POST
Headers:
  Authorization: Bearer YOUR_API_KEY
  Content-Type: application/json
Body:
{
  "email": "%EMAIL%",
  "webhook_url": "https://yoursite.com/api/activecampaign/callback"
}

Criar Manipulador de Callback

Processe os resultados de verificação do EmailVerify.

// pages/api/activecampaign/callback.js
import crypto from 'crypto';

export default async function handler(req, res) {
  if (req.method !== 'POST') {
    return res.status(405).json({ error: 'Method not allowed' });
  }

  const { email, status, result } = req.body;

  // Atualize o contato no ActiveCampaign com base no resultado
  const acApiUrl = process.env.ACTIVECAMPAIGN_API_URL;
  const acApiKey = process.env.ACTIVECAMPAIGN_API_KEY;

  try {
    // Encontre o contato por e-mail
    const searchResponse = await fetch(
      `${acApiUrl}/api/3/contacts?email=${encodeURIComponent(email)}`,
      {
        headers: {
          'Api-Token': acApiKey,
        },
      }
    );

    const searchData = await searchResponse.json();
    const contact = searchData.contacts[0];

    if (!contact) {
      return res.status(404).json({ error: 'Contato não encontrado' });
    }

    // Atualize o contato com status de verificação
    const fieldUpdates = {
      contact: {
        fieldValues: [
          {
            field: process.env.AC_FIELD_EMAIL_STATUS,
            value: status,
          },
          {
            field: process.env.AC_FIELD_EMAIL_SCORE,
            value: result.score?.toString() || '',
          },
        ],
      },
    };

    await fetch(`${acApiUrl}/api/3/contacts/${contact.id}`, {
      method: 'PUT',
      headers: {
        'Api-Token': acApiKey,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(fieldUpdates),
    });

    // Adicione a tag com base no status
    const tagName = status === 'valid' ? 'Email Verificado' : 'Email Inválido';
    await addTagToContact(contact.id, tagName, acApiUrl, acApiKey);

    res.status(200).json({ success: true });
  } catch (error) {
    console.error('Erro ao atualizar ActiveCampaign:', error);
    res.status(500).json({ error: 'Falha na atualização' });
  }
}

async function addTagToContact(contactId, tagName, apiUrl, apiKey) {
  // Primeiro, encontre ou crie a tag
  const tagResponse = await fetch(
    `${apiUrl}/api/3/tags?search=${encodeURIComponent(tagName)}`,
    {
      headers: { 'Api-Token': apiKey },
    }
  );

  const tagData = await tagResponse.json();
  let tagId = tagData.tags[0]?.id;

  if (!tagId) {
    // Crie a tag se não existir
    const createResponse = await fetch(`${apiUrl}/api/3/tags`, {
      method: 'POST',
      headers: {
        'Api-Token': apiKey,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        tag: { tag: tagName, tagType: 'contact' },
      }),
    });
    const createData = await createResponse.json();
    tagId = createData.tag.id;
  }

  // Adicione a tag ao contato
  await fetch(`${apiUrl}/api/3/contactTags`, {
    method: 'POST',
    headers: {
      'Api-Token': apiKey,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      contactTag: { contact: contactId, tag: tagId },
    }),
  });
}

Método 2: Integração de API

Crie integrações personalizadas usando ambas as APIs.

Serviço ActiveCampaign

// services/activecampaign.js
import EmailVerify from '@emailverify/sdk';

class ActiveCampaignService {
  constructor() {
    this.apiUrl = process.env.ACTIVECAMPAIGN_API_URL;
    this.apiKey = process.env.ACTIVECAMPAIGN_API_KEY;
    this.bv = new EmailVerify(process.env.EMAILVERIFY_API_KEY);
  }

  async verifyContact(contactId) {
    // Obtenha os detalhes do contato
    const contact = await this.getContact(contactId);

    if (!contact?.email) {
      throw new Error('Contato não tem e-mail');
    }

    // Verifique o e-mail
    const result = await this.bv.verify({ email: contact.email });

    // Atualize o contato com os resultados
    await this.updateContactFields(contactId, {
      email_status: result.status,
      email_score: result.score,
      email_disposable: result.is_disposable ? 'Sim' : 'Não',
      email_verified_at: new Date().toISOString(),
    });

    // Aplique automação com base no resultado
    if (result.status === 'invalid') {
      await this.addToAutomation(contactId, 'Limpeza de E-mail Inválido');
    }

    return result;
  }

  async getContact(contactId) {
    const response = await fetch(
      `${this.apiUrl}/api/3/contacts/${contactId}`,
      {
        headers: { 'Api-Token': this.apiKey },
      }
    );
    const data = await response.json();
    return data.contact;
  }

  async updateContactFields(contactId, fields) {
    const fieldValues = await this.mapToFieldValues(fields);

    await fetch(`${this.apiUrl}/api/3/contacts/${contactId}`, {
      method: 'PUT',
      headers: {
        'Api-Token': this.apiKey,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        contact: { fieldValues },
      }),
    });
  }

  async mapToFieldValues(fields) {
    // Obtenha IDs de campos personalizados
    const customFields = await this.getCustomFields();

    return Object.entries(fields).map(([key, value]) => ({
      field: customFields[key],
      value: String(value),
    }));
  }

  async getCustomFields() {
    const response = await fetch(`${this.apiUrl}/api/3/fields`, {
      headers: { 'Api-Token': this.apiKey },
    });
    const data = await response.json();

    return data.fields.reduce((acc, field) => {
      acc[field.perstag.toLowerCase()] = field.id;
      return acc;
    }, {});
  }

  async addToAutomation(contactId, automationName) {
    // Encontre a automação por nome
    const response = await fetch(
      `${this.apiUrl}/api/3/automations?search=${encodeURIComponent(automationName)}`,
      {
        headers: { 'Api-Token': this.apiKey },
      }
    );
    const data = await response.json();
    const automation = data.automations[0];

    if (automation) {
      await fetch(`${this.apiUrl}/api/3/contactAutomations`, {
        method: 'POST',
        headers: {
          'Api-Token': this.apiKey,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          contactAutomation: {
            contact: contactId,
            automation: automation.id,
          },
        }),
      });
    }
  }

  async verifyList(listId) {
    // Obtenha todos os contatos na lista
    const contacts = await this.getListContacts(listId);
    const emails = contacts.map(c => c.email);

    // Verificação em lote
    const job = await this.bv.verifyBulk(emails);

    // Aguarde a conclusão
    let status;
    do {
      await new Promise(resolve => setTimeout(resolve, 5000));
      status = await this.bv.getBulkJobStatus(job.job_id);
    } while (status.status !== 'completed');

    // Obtenha resultados e atualize contatos
    const results = await this.bv.getBulkJobResults(job.job_id);

    for (const result of results.results) {
      const contact = contacts.find(c => c.email === result.email);
      if (contact) {
        await this.updateContactFields(contact.id, {
          email_status: result.status,
          email_score: result.score,
        });
      }
    }

    return {
      total: results.results.length,
      valid: results.results.filter(r => r.status === 'valid').length,
      invalid: results.results.filter(r => r.status === 'invalid').length,
    };
  }

  async getListContacts(listId) {
    const contacts = [];
    let offset = 0;
    const limit = 100;

    while (true) {
      const response = await fetch(
        `${this.apiUrl}/api/3/contacts?listid=${listId}&limit=${limit}&offset=${offset}`,
        {
          headers: { 'Api-Token': this.apiKey },
        }
      );
      const data = await response.json();

      if (data.contacts.length === 0) break;

      contacts.push(...data.contacts);
      offset += limit;
    }

    return contacts;
  }
}

export default new ActiveCampaignService();

Exemplo de Uso

import activeCampaign from './services/activecampaign';

// Verifique um contato único
const result = await activeCampaign.verifyContact('12345');
console.log(`Status do e-mail: ${result.status}`);

// Verifique a lista inteira
const listResults = await activeCampaign.verifyList('1');
console.log(`${listResults.total} contatos verificados`);
console.log(`Válidos: ${listResults.valid}, Inválidos: ${listResults.invalid}`);

Método 3: Integração de Formulário

Verifique e-mails em formulários do ActiveCampaign antes do envio.

Manipulador de Formulário Personalizado

<!-- Formulário do ActiveCampaign com EmailVerify -->
<form id="ac-form" action="https://yoursite.activehosted.com/proc.php" method="POST">
  <input type="hidden" name="u" value="1" />
  <input type="hidden" name="f" value="1" />
  <input type="hidden" name="s" />
  <input type="hidden" name="c" value="0" />
  <input type="hidden" name="m" value="0" />
  <input type="hidden" name="act" value="sub" />
  <input type="hidden" name="v" value="2" />

  <div class="form-group">
    <label for="email">Endereço de E-mail</label>
    <input type="email" id="email" name="email" required />
    <span id="email-status"></span>
  </div>

  <div class="form-group">
    <label for="fullname">Nome Completo</label>
    <input type="text" id="fullname" name="fullname" />
  </div>

  <button type="submit" id="submit-btn">Inscrever-se</button>
</form>

<script>
const form = document.getElementById('ac-form');
const emailInput = document.getElementById('email');
const emailStatus = document.getElementById('email-status');
const submitBtn = document.getElementById('submit-btn');

let emailValid = false;

emailInput.addEventListener('blur', async function() {
  const email = this.value;
  if (!email) return;

  emailStatus.textContent = 'Verificando...';
  emailStatus.className = 'verifying';
  submitBtn.disabled = true;

  try {
    const response = await fetch('/api/verify-email', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ email }),
    });

    const result = await response.json();

    if (result.status === 'valid') {
      emailStatus.textContent = '✓ E-mail válido';
      emailStatus.className = 'valid';
      emailValid = true;
    } else {
      emailStatus.textContent = '✗ Digite um endereço de e-mail válido';
      emailStatus.className = 'invalid';
      emailValid = false;
    }
  } catch (error) {
    // Permitir envio em caso de erro de API
    emailStatus.textContent = '';
    emailValid = true;
  }

  submitBtn.disabled = false;
});

form.addEventListener('submit', function(e) {
  if (!emailValid) {
    e.preventDefault();
    emailStatus.textContent = 'Digite um endereço de e-mail válido';
    emailStatus.className = 'invalid';
  }
});
</script>

<style>
.form-group {
  margin-bottom: 1rem;
}

#email-status {
  display: block;
  margin-top: 0.25rem;
  font-size: 0.875rem;
}

#email-status.verifying { color: #666; }
#email-status.valid { color: #28a745; }
#email-status.invalid { color: #dc3545; }

button:disabled {
  opacity: 0.5;
  cursor: not-allowed;
}
</style>

Fluxos de Trabalho de Automação

Verificação na Inscrição

Gatilho: Contato se inscreve na lista
  ↓
Ação: Webhook para EmailVerify
  ↓
Aguarde: Até resposta do webhook
  ↓
Se/Senão: Verifique campo email_status
  ├─ Se "válido": Continue para e-mail de boas-vindas
  └─ Se "inválido": Adicionar à lista "E-mails Inválidos", Fim

Limpeza Periódica de Lista

Gatilho: Executar uma vez por mês
  ↓
Ação: Webhook para iniciar verificação em lote
  ↓
Aguarde: 24 horas (para conclusão do trabalho em lote)
  ↓
Objetivo: Verificação em lote concluída
  ↓
Ação: Processar resultados via callback do webhook

Campanha de Reengajamento

Gatilho: Contato não abriu e-mail há 90 dias
  ↓
Ação: Verificar endereço de e-mail
  ↓
Se/Senão: Status do e-mail
  ├─ Se "válido": Enviar e-mail de reengajamento
  └─ Se "inválido": Cancelar inscrição do contato

Configuração de Campos Personalizados

Crie esses campos personalizados no ActiveCampaign:

Nome do CampoTipoTag de Personalização
Status do E-mailTexto%EMAIL_STATUS%
Pontuação de E-mailNúmero%EMAIL_SCORE%
E-mail DescartávelLista suspensa (Sim/Não)%EMAIL_DISPOSABLE%
E-mail Verificado emData%EMAIL_VERIFIED_AT%

Criar Campos via API

async function createCustomFields(apiUrl, apiKey) {
  const fields = [
    { title: 'Email Status', type: 'text', perstag: 'EMAIL_STATUS' },
    { title: 'Email Score', type: 'text', perstag: 'EMAIL_SCORE' },
    { title: 'Email Disposable', type: 'dropdown', perstag: 'EMAIL_DISPOSABLE', options: ['Yes', 'No'] },
    { title: 'Email Verified At', type: 'date', perstag: 'EMAIL_VERIFIED_AT' },
  ];

  for (const field of fields) {
    await fetch(`${apiUrl}/api/3/fields`, {
      method: 'POST',
      headers: {
        'Api-Token': apiKey,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ field }),
    });
  }
}

Segmentação

Crie segmentos com base no status de verificação de e-mail.

Segmento de E-mails Válidos

Condições:
- Campo de contato "Status do E-mail" é "válido"
- Campo de contato "Pontuação de E-mail" é maior que 0,7

Segmento de E-mails Inválidos

Condições:
- Campo de contato "Status do E-mail" é "inválido"
OU
- Campo de contato "Status do E-mail" é "desconhecido"

Segmento de E-mails de Alto Risco

Condições:
- Campo de contato "E-mail Descartável" é "Sim"
OU
- Campo de contato "Pontuação de E-mail" é menor que 0,5

Melhores Práticas

1. Verificar Antes de Campanhas

Sempre verifique sua lista antes de campanhas importantes:

async function preCampaignVerification(listId, campaignId) {
  const service = new ActiveCampaignService();

  // Verifique a lista
  const results = await service.verifyList(listId);

  // Proceda apenas se a taxa de inválidos for aceitável
  const invalidRate = results.invalid / results.total;

  if (invalidRate > 0.05) { // Mais de 5% inválidos
    console.warn(`Taxa alta de inválidos: ${(invalidRate * 100).toFixed(1)}%`);
    console.warn('Considere limpar a lista antes de enviar');
    return false;
  }

  return true;
}

2. Lidar com Limites de Taxa

async function verifyWithRateLimit(contacts) {
  const batchSize = 100;
  const delayMs = 1000;

  for (let i = 0; i < contacts.length; i += batchSize) {
    const batch = contacts.slice(i, i + batchSize);

    await Promise.all(
      batch.map(contact => verifyContact(contact.id))
    );

    if (i + batchSize < contacts.length) {
      await new Promise(resolve => setTimeout(resolve, delayMs));
    }
  }
}

3. Tratamento de Erros

async function safeVerify(email) {
  try {
    const result = await bv.verify({ email });
    return result;
  } catch (error) {
    console.error(`Verificação falhou para ${email}:`, error);

    // Retorne status desconhecido para permitir processamento adicional
    return {
      email,
      status: 'unknown',
      error: error.message,
    };
  }
}

Recursos Relacionados

Integração HubSpot

Verificação de e-mail de CRM

Integração Mailchimp

Plataforma de marketing por e-mail

Referência de API

Documentação completa da API

HubSpot

Email checker for HubSpot. Verify contacts and clean email lists in HubSpot CRM.

Mailchimp

Email checker for Mailchimp. Clean your email list before sending campaigns.

On this page

Métodos de IntegraçãoMétodo 1: Automação por WebhookCriar Ação de WebhookCriar Manipulador de CallbackMétodo 2: Integração de APIServiço ActiveCampaignExemplo de UsoMétodo 3: Integração de FormulárioManipulador de Formulário PersonalizadoFluxos de Trabalho de AutomaçãoVerificação na InscriçãoLimpeza Periódica de ListaCampanha de ReengajamentoConfiguração de Campos PersonalizadosCriar Campos via APISegmentaçãoSegmento de E-mails VálidosSegmento de E-mails InválidosSegmento de E-mails de Alto RiscoMelhores Práticas1. Verificar Antes de Campanhas2. Lidar com Limites de Taxa3. Tratamento de ErrosRecursos Relacionados