Comment extraire les adresses e-mail d’un texte sans doublons ?

Pour extraire les adresses e-mail d’un texte sans doublons, il faut combiner une expression régulière, un nettoyage des résultats et une règle claire de comparaison. Cette méthode fonctionne pour un texte copié, une page web, un export CSV ou un document contenant plusieurs occurrences des mêmes adresses.
✓ Vérifié le 4 octobre 2026 · 4 min de lecture

La méthode en 4 étapes

Une extraction fiable suit généralement ce processus :

  1. Repérer les chaînes qui ressemblent à des adresses e-mail.
  2. Nettoyer les caractères ajoutés par le texte, comme un point ou une parenthèse finale.
  3. Normaliser les valeurs utilisées pour comparer les adresses.
  4. Dédupliquer les résultats avec un Set en JavaScript ou un set en Python.

Une expression régulière pratique pour les formats courants est :

[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+.[A-Za-z]{2,}

Elle détecte notamment contact@exemple.com et prenom.nom+test@entreprise.fr. Elle ne valide toutefois pas toutes les adresses autorisées par les standards et ne vérifie pas qu’une boîte aux lettres existe.

Gérer les doublons correctement

Doublons strictement identiques

Si le texte contient deux fois contact@exemple.com, une seule occurrence doit être conservée. Un ensemble de valeurs uniques permet de vérifier rapidement si une adresse a déjà été rencontrée.

Différences de casse

Le domaine étant insensible à la casse, vous pouvez le convertir en minuscules pour la comparaison :

Contact@Exemple.com
Contact@exemple.com

La partie locale, située avant @, peut théoriquement être sensible à la casse. Il est donc préférable de conserver sa valeur originale et de ne normaliser automatiquement que le domaine, sauf si votre projet définit une règle plus stricte.

Exemple JavaScript

Le drapeau g permet de récupérer toutes les correspondances. Le Set conserve les clés déjà rencontrées tout en respectant l’ordre d’apparition.

const texte = `
Contact : Contact@Exemple.com.
Autre adresse : support@exemple.com
Contact@Exemple.com
`;

const motif = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+.[A-Za-z]{2,}/g;
const trouvees = texte.match(motif) ?? [];

const vues = new Set();
const uniques = [];

for (const adresse of trouvees) {
  const nettoyee = adresse
    .trim()
    .replace(/[.,;:!?)}]]+$/, "");

  const [partieLocale, domaine] = nettoyee.split("@");
  const cle = `${partieLocale}@${domaine.toLowerCase()}`;

  if (!vues.has(cle)) {
    vues.add(cle);
    uniques.push(nettoyee);
  }
}

console.log(uniques);

Résultat :

["Contact@Exemple.com", "support@exemple.com"]

Le tableau conserve la première version rencontrée, tandis que la clé normalisée sert uniquement à détecter les doublons.

Exemple Python

import re

texte = """
Contact : Contact@Exemple.com.
Autre adresse : support@exemple.com
Contact@Exemple.com
"""

motif = r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+.[A-Za-z]{2,}"
trouvees = re.findall(motif, texte)

vues = set()
uniques = []

for adresse in trouvees:
    nettoyee = adresse.strip().rstrip(".,;:!?)]}")
    partie_locale, domaine = nettoyee.rsplit("@", 1)
    cle = f"{partie_locale}@{domaine.lower()}"

    if cle not in vues:
        vues.add(cle)
        uniques.append(nettoyee)

print(uniques)

re.findall() renvoie les correspondances dans l’ordre de lecture. Le set sert ensuite à suivre les clés déjà utilisées.

Nettoyer les adresses extraites

Dans une phrase, une adresse peut être suivie d’un point, d’une virgule ou d’une parenthèse :

Écrivez à contact@exemple.com.

L’expression régulière peut récupérer l’adresse sans la ponctuation dans la plupart des cas, mais un nettoyage complémentaire reste utile lorsque les adresses sont entourées de caractères particuliers. Conservez idéalement deux valeurs :

  • l’adresse originale nettoyée, destinée à l’affichage ou à l’export ;
  • la clé normalisée, destinée à la comparaison.

Limites et précautions

  • Extraction et validation sont différentes : une correspondance syntaxique ne garantit pas que l’adresse existe.
  • Ne modifiez pas les règles propres aux fournisseurs : supprimer les points ou interpréter automatiquement un signe + peut changer l’adresse.
  • Testez les cas réels : sous-domaines, adresses avec +, chevrons, URL et ponctuation.
  • Pensez aux adresses internationales : une expression limitée aux caractères ASCII peut ne pas détecter toutes les adresses compatibles avec les extensions SMTP internationales.
  • Maîtrisez la taille des textes : pour des contenus fournis par des utilisateurs, évitez les expressions régulières inutilement complexes et limitez les traitements coûteux.

Pour un besoin important, utilisez ensuite une bibliothèque de validation maintenue. Cette étape peut vérifier la structure plus précisément, mais elle ne prouve pas que la boîte aux lettres est active.

À retenir

  • Utilisez une expression régulière simple pour repérer les formats courants.
  • Retirez la ponctuation extérieure avant de comparer les résultats.
  • Normalisez le domaine en minuscules et conservez la partie locale avec prudence.
  • Utilisez un Set JavaScript ou un set Python pour supprimer les doublons.
  • Conservez l’adresse originale et une clé normalisée dans deux variables distinctes.
  • Traitez séparément l’extraction, la validation et la vérification de l’existence de l’adresse.

Questions fréquentes

Quelle expression régulière utiliser pour extraire des adresses e-mail ?
Pour les textes courants, utilisez [A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+.[A-Za-z]{2,}. Elle couvre les formats habituels, mais ne représente pas toute la syntaxe définie par les standards.
Comment supprimer les doublons d’adresses e-mail en JavaScript ?
Stockez une clé de comparaison dans un Set. Vous pouvez conserver la partie locale telle quelle et convertir uniquement le domaine en minuscules, puis ajouter l’adresse originale à un tableau lorsqu’une clé n’existe pas encore.
Faut-il convertir toute l’adresse en minuscules ?
Pas systématiquement. Le domaine est insensible à la casse, mais la partie locale peut théoriquement être sensible à la casse. Définissez votre règle métier avant de normaliser toute l’adresse.
Une adresse extraite est-elle forcément valide ?
Non. L’expression régulière identifie une chaîne qui ressemble à une adresse. Elle ne confirme ni la conformité complète aux standards ni l’existence de la boîte aux lettres.
Les adresses e-mail internationales sont-elles détectées ?
Pas toujours. Une expression limitée aux caractères ASCII peut manquer certaines adresses internationalisées. Si ce cas est important, utilisez une bibliothèque ou une validation adaptée.