# Vérifier une adresse

> Vérifiez une adresse e-mail dans le tableau de bord ou via l’API, choisissez entre le mode rapide et le mode complet, et utilisez la vérification pour intercepter les mauvaises adresses à l’inscription.

Ce guide explique comment contrôler une adresse e-mail, soit manuellement dans le tableau de bord, soit depuis votre code via l’API. Il montre aussi comment utiliser la vérification dans un formulaire d’inscription pour bloquer les fautes de frappe et les adresses jetables avant qu’elles n’arrivent dans votre liste.

## Avant de commencer

- Chaque vérification coûte 5 crédits. Consultez votre solde dans la barre latérale ou dans **Workspace → Billing**.
- Pour l’API, utilisez une clé API **Full Access**. Les clés d’envoi uniquement ne peuvent pas vérifier d’adresses.

## Mode rapide et mode complet

| Mode | Contrôles | Utilisation |
| --- | --- | --- |
| `fast` (par défaut) | Syntaxe, enregistrements MX, âge du domaine, adresses jetables, génériques, de fournisseurs gratuits et d’apparence aléatoire | Formulaires d’inscription et tout ce qu’une personne attend en direct. |
| `full` | Tout ce que fait `fast`, plus une connexion au serveur de messagerie du destinataire pour contrôler la boîte aux lettres : livrable, désactivée, pleine et catch-all | Nettoyage d’adresses avant un envoi important, quand quelques secondes de plus ne comptent pas. |

Les deux modes coûtent le même prix. `full` prend plus de temps parce qu’il dialogue avec le serveur de messagerie du destinataire, qui peut être lent ou refuser de répondre. Certains grands fournisseurs bloquent ces contrôles : `full` ne peut donc pas toujours confirmer une boîte aux lettres. Pour la signification de chaque contrôle, consultez [Résultats de vérification](/fr/docs/email-verification/results/).

## Vérifier une adresse

**Tableau de bord**

  1. **Ouvrez Email Verification.** Accédez à **Email Verification → Emails** et sélectionnez **Verify Email**.

  2. **Saisissez l’adresse.** Saisissez-la dans **Email** et sélectionnez **Verify Email**. Le tableau de bord utilise le mode `fast`.

  3. **Ouvrez le résultat.** L’adresse apparaît dans la liste avec son **Status**, son **Result**, son **Risk**, son **Score**, sa date **Created** et le nombre de jours avant son expiration (**Expiring**). Sélectionnez-la pour voir chaque contrôle individuel, comme **Valid Syntax**, **Disposable**, **Role Account** et **Has MX Records**.

  Pour contrôler de nombreuses adresses d’un coup, [vérifiez plutôt une liste](/fr/docs/email-verification/lists/).

**API**

  Appelez [Vérifier une adresse](/fr/docs/api-reference/email-verifications/verify/) avec l’adresse et, si vous le souhaitez, le mode :

```bash
curl https://api.emailit.com/v2/email-verifications \
  -X POST \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "email": "ada@example.com", "mode": "full" }'
```

  Le résultat est renvoyé dans la réponse :

```json
{
  "id": "ev_6Hq2Lm9Tx4Pz",
  "object": "email_verification",
  "email": "ada@example.com",
  "status": "completed",
  "score": 100,
  "risk": "low",
  "result": "safe",
  "mode": "full",
  "checks": {
    "valid_syntax": true,
    "disposable": false,
    "role_account": false,
    "inbox_full": false,
    "deliverable": true,
    "disabled": false,
    "free_email": false,
    "gibberish": false,
    "catch_all": false,
    "smtp_connect": true,
    "has_mx_records": true,
    "domain_age": 10957
  },
  "address": {
    "mailbox": "ada",
    "domain": "example.com",
    "suffix": null,
    "root": "ada@example.com"
  },
  "did_you_mean": null,
  "mx_records": [
    { "priority": 10, "exchange": "mx1.example.com" }
  ],
  "created_at": "2026-10-01T10:24:11Z",
  "updated_at": "2026-10-01T10:24:11Z"
}
```

  En mode `fast`, les contrôles de boîte aux lettres (`deliverable`, `disabled`, `inbox_full`, `catch_all` et `smtp_connect`) valent `null` car ils n’ont pas été effectués.

  | Statut | Cas |
  | --- | --- |
  | `200` | L’adresse a été vérifiée. Cela inclut les adresses mal formées, qui reviennent avec `result: "invalid"`. |
  | `400` | `email` est absent, ou `mode` ne vaut ni `fast` ni `full`. |
  | `402` | L’espace de travail a moins de 5 crédits. |

  Chaque vérification réussie déclenche aussi l’événement `email_verification.created`. Consultez [Types d’événements](/fr/docs/webhooks/event-types/).

## Vérifier les adresses à l’inscription

Contrôler une adresse au moment où quelqu’un la saisit est le moyen le moins coûteux de garder une liste propre. Une faute de frappe repérée à l’inscription ne devient jamais un rebond.

1. **Appelez l’API depuis votre serveur.** Ne placez jamais votre clé API dans du code exécuté par le navigateur. Envoyez l’adresse depuis le gestionnaire d’inscription de votre serveur, en mode `fast`.

2. **Définissez un timeout et laissez passer en cas d’échec.** Si la vérification est lente ou renvoie une erreur, acceptez l’inscription. Perdre un vrai client coûte plus cher qu’une mauvaise adresse.

3. **Agissez selon le résultat.** Bloquez ce qui est manifestement erroné, suggérez des corrections pour les fautes de frappe et laissez passer tout le reste.

```javascript title="verify-signup.js"
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), 5000);

  try {
    const res = await fetch('https://api.emailit.com/v2/email-verifications', {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${process.env.EMAILIT_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ email, mode: 'fast' }),
      signal: controller.signal,
    });
    if (!res.ok) return { ok: true }; // fail open

    const verification = await res.json();

    if (verification.result === 'invalid') {
      return {
        ok: false,
        message: verification.did_you_mean
          ? `Did you mean ${verification.did_you_mean}?`
          : 'Please check your email address.',
      };
    }
    if (verification.result === 'disposable') {
      return { ok: false, message: 'Please use a permanent email address.' };
    }

    // Accept the address, but offer a correction if one looks likely.
    return { ok: true, suggestion: verification.did_you_mean };
  } catch {
    return { ok: true }; // timeout or network error: fail open
  } finally {
    clearTimeout(timer);
  }
}
```

Quelques conseils :

- **Utilisez `did_you_mean`.** Pour les fautes de frappe courantes dans le domaine, comme `ada@gmial.com`, ce champ contient l’adresse probable, `ada@gmail.com`. Affichez-la comme une suggestion que la personne peut accepter.
- **Ne bloquez pas d’office les adresses génériques.** Les petites entreprises s’inscrivent souvent avec `info@` ou `sales@`. Signalez-les plutôt.
- **Vérifiez chaque adresse une seule fois.** Chaque appel coûte des crédits : vérifiez à l’envoi du formulaire, pas à chaque frappe, et enregistrez le résultat.

## Voir aussi

  - [Résultats de vérification](/fr/docs/email-verification/results/): La signification de chaque résultat, risque et contrôle.
  - [Vérifier une liste](/fr/docs/email-verification/lists/): Contrôlez jusqu’à 10 000 adresses d’un coup.

---
Source: https://emailit.com/fr/docs/email-verification/single/