EmailVerify LogoEmailVerify
Guides d'IntégrationMarketing & CRM

ActiveCampaign

Email checker for ActiveCampaign with automations and webhooks.

Intégrez EmailVerify avec ActiveCampaign pour vérifier les adresses e-mail, nettoyer vos listes de contacts et améliorer la délivrabilité des e-mails.

Méthodes d'intégration

MéthodeIdéal pourComplexité
Automation par WebhookVérification en temps réelFaible
Intégration APIFlux de travail personnalisésMoyenne
Import en masseNettoyage de listesFaible

Méthode 1 : Automation par Webhook

Créez une automation qui vérifie les e-mails lorsque des contacts sont ajoutés.

Créer une action Webhook

  1. Accédez à Automations → New Automation
  2. Choisissez un déclencheur (par exemple, "Subscribes to a list")
  3. Ajoutez une action → Conditions and Workflow → Webhook
  4. Configurez le 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"
}

Créer un gestionnaire de callback

Traitez les résultats de vérification de 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;

  // Mettre à jour le contact dans ActiveCampaign selon le résultat
  const acApiUrl = process.env.ACTIVECAMPAIGN_API_URL;
  const acApiKey = process.env.ACTIVECAMPAIGN_API_KEY;

  try {
    // Rechercher le contact par 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: 'Contact not found' });
    }

    // Mettre à jour le contact avec le statut de vérification
    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),
    });

    // Ajouter un tag selon le statut
    const tagName = status === 'valid' ? 'Email Verified' : 'Email Invalid';
    await addTagToContact(contact.id, tagName, acApiUrl, acApiKey);

    res.status(200).json({ success: true });
  } catch (error) {
    console.error('ActiveCampaign update error:', error);
    res.status(500).json({ error: 'Update failed' });
  }
}

async function addTagToContact(contactId, tagName, apiUrl, apiKey) {
  // D'abord, trouver ou créer le 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) {
    // Créer le tag s'il n'existe pas
    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;
  }

  // Ajouter le tag au contact
  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éthode 2 : Intégration API

Créez des intégrations personnalisées en utilisant les deux API.

Service 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) {
    // Obtenir les détails du contact
    const contact = await this.getContact(contactId);

    if (!contact?.email) {
      throw new Error('Contact has no email');
    }

    // Vérifier l'e-mail
    const result = await this.bv.verify({ email: contact.email });

    // Mettre à jour le contact avec les résultats
    await this.updateContactFields(contactId, {
      email_status: result.status,
      email_score: result.score,
      email_disposable: result.is_disposable ? 'Yes' : 'No',
      email_verified_at: new Date().toISOString(),
    });

    // Appliquer une automation selon le résultat
    if (result.status === 'invalid') {
      await this.addToAutomation(contactId, 'Invalid Email Cleanup');
    }

    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) {
    // Obtenir les ID des champs personnalisés
    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) {
    // Trouver l'automation par nom
    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) {
    // Obtenir tous les contacts de la liste
    const contacts = await this.getListContacts(listId);
    const emails = contacts.map(c => c.email);

    // Vérification en masse
    const job = await this.bv.verifyBulk(emails);

    // Attendre la fin
    let status;
    do {
      await new Promise(resolve => setTimeout(resolve, 5000));
      status = await this.bv.getBulkJobStatus(job.job_id);
    } while (status.status !== 'completed');

    // Obtenir les résultats et mettre à jour les contacts
    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();

Exemple d'utilisation

import activeCampaign from './services/activecampaign';

// Vérifier un seul contact
const result = await activeCampaign.verifyContact('12345');
console.log(`Email status: ${result.status}`);

// Vérifier une liste entière
const listResults = await activeCampaign.verifyList('1');
console.log(`Verified ${listResults.total} contacts`);
console.log(`Valid: ${listResults.valid}, Invalid: ${listResults.invalid}`);

Méthode 3 : Intégration de formulaire

Vérifiez les e-mails sur les formulaires ActiveCampaign avant la soumission.

Gestionnaire de formulaire personnalisé

<!-- Formulaire ActiveCampaign avec 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">Adresse e-mail</label>
    <input type="email" id="email" name="email" required />
    <span id="email-status"></span>
  </div>

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

  <button type="submit" id="submit-btn">S'abonner</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 = 'Vérification...';
  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 valide';
      emailStatus.className = 'valid';
      emailValid = true;
    } else {
      emailStatus.textContent = '✗ Veuillez saisir un e-mail valide';
      emailStatus.className = 'invalid';
      emailValid = false;
    }
  } catch (error) {
    // Autoriser la soumission en cas d'erreur API
    emailStatus.textContent = '';
    emailValid = true;
  }

  submitBtn.disabled = false;
});

form.addEventListener('submit', function(e) {
  if (!emailValid) {
    e.preventDefault();
    emailStatus.textContent = 'Veuillez saisir une adresse e-mail valide';
    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>

Workflows d'automation

Vérification lors de l'abonnement

Déclencheur : Le contact s'abonne à une liste
  ↓
Action : Webhook vers EmailVerify
  ↓
Attente : Jusqu'à la réponse du webhook
  ↓
Si/Sinon : Vérifier le champ email_status
  ├─ Si "valid" : Continuer vers l'e-mail de bienvenue
  └─ Si "invalid" : Ajouter à la liste "Invalid Emails", Fin

Nettoyage périodique de liste

Déclencheur : Exécuter une fois par mois
  ↓
Action : Webhook pour lancer la vérification en masse
  ↓
Attente : 24 heures (pour la finalisation du travail en masse)
  ↓
Objectif : Vérification en masse terminée
  ↓
Action : Traiter les résultats via callback webhook

Campagne de réengagement

Déclencheur : Le contact n'a pas ouvert d'e-mail depuis 90 jours
  ↓
Action : Vérifier l'adresse e-mail
  ↓
Si/Sinon : Statut de l'e-mail
  ├─ Si "valid" : Envoyer un e-mail de réengagement
  └─ Si "invalid" : Désabonner le contact

Configuration des champs personnalisés

Créez ces champs personnalisés dans ActiveCampaign :

Nom du champTypeTag de personnalisation
Email StatusText%EMAIL_STATUS%
Email ScoreNumber%EMAIL_SCORE%
Email DisposableDropdown (Yes/No)%EMAIL_DISPOSABLE%
Email Verified AtDate%EMAIL_VERIFIED_AT%

Créer des champs via l'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 }),
    });
  }
}

Segmentation

Créez des segments basés sur le statut de vérification de l'e-mail.

Segment E-mails valides

Conditions :
- Champ de contact "Email Status" est "valid"
- Champ de contact "Email Score" est supérieur à 0.7

Segment E-mails invalides

Conditions :
- Champ de contact "Email Status" est "invalid"
OU
- Champ de contact "Email Status" est "unknown"

Segment E-mails à haut risque

Conditions :
- Champ de contact "Email Disposable" est "Yes"
OU
- Champ de contact "Email Score" est inférieur à 0.5

Bonnes pratiques

1. Vérifier avant les campagnes

Vérifiez toujours votre liste avant les campagnes majeures :

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

  // Vérifier la liste
  const results = await service.verifyList(listId);

  // Ne procéder que si le taux d'invalides est acceptable
  const invalidRate = results.invalid / results.total;

  if (invalidRate > 0.05) { // Plus de 5% d'invalides
    console.warn(`Taux d'invalides élevé : ${(invalidRate * 100).toFixed(1)}%`);
    console.warn('Envisagez de nettoyer la liste avant l\'envoi');
    return false;
  }

  return true;
}

2. Gérer les limites de débit

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. Gestion des erreurs

async function safeVerify(email) {
  try {
    const result = await bv.verify({ email });
    return result;
  } catch (error) {
    console.error(`Verification failed for ${email}:`, error);

    // Retourner un statut inconnu pour permettre un traitement ultérieur
    return {
      email,
      status: 'unknown',
      error: error.message,
    };
  }
}

Ressources connexes

Intégration HubSpot

Vérification d'e-mails CRM

Intégration Mailchimp

Plateforme d'e-mail marketing

Référence API

Documentation complète de l'API

HubSpot

Email checker for HubSpot. Verify leads, contacts, and form submissions.

Mailchimp

Email checker for Mailchimp. Clean your email lists for better deliverability.

On this page

Méthodes d'intégrationMéthode 1 : Automation par WebhookCréer une action WebhookCréer un gestionnaire de callbackMéthode 2 : Intégration APIService ActiveCampaignExemple d'utilisationMéthode 3 : Intégration de formulaireGestionnaire de formulaire personnaliséWorkflows d'automationVérification lors de l'abonnementNettoyage périodique de listeCampagne de réengagementConfiguration des champs personnalisésCréer des champs via l'APISegmentationSegment E-mails validesSegment E-mails invalidesSegment E-mails à haut risqueBonnes pratiques1. Vérifier avant les campagnes2. Gérer les limites de débit3. Gestion des erreursRessources connexes