Comment extraire toutes les URL d’un texte et supprimer les doublons ?

Pour extraire les URL d’un texte de manière fiable, il faut repérer les liens, supprimer la ponctuation parasite, vérifier leur structure, puis dédoublonner les résultats. Voici une méthode Python complète et adaptable aux textes bruts, au HTML et au Markdown.
✓ Vérifié le 5 octobre 2026 · 5 min de lecture

La méthode en 4 étapes

Le traitement le plus fiable suit cette séquence :

  1. Repérer les chaînes commençant par http:// ou https://.
  2. Retirer les caractères ajoutés par le texte, comme un point ou une parenthèse fermante.
  3. Valider les URL avec un parseur dédié.
  4. Supprimer les doublons en conservant l’ordre d’apparition.

Une URL peut contenir un schéma, un domaine, un chemin, des paramètres de requête et un fragment. Cette structure est décrite par la RFC 3986.

Extraire les URL avec une expression régulière

Pour un texte courant, une expression régulière permet de repérer rapidement les URL absolues :

import re

texte = """
Consultez https://example.com/article.
La documentation est disponible sur https://docs.example.com/page?q=1.
"""

candidats = re.findall(r'https?://[^\s<>"\']+', texte)
print(candidats)

Le résultat peut contenir la ponctuation placée après le lien :

[
    "https://example.com/article.",
    "https://docs.example.com/page?q=1."
]

Nettoyer la ponctuation finale

Retirez les signes qui ne font généralement pas partie de l’URL :

URLS_PONCTUATION = ".,;:!?)]}"

urls_nettoyees = [
    url.rstrip(URLS_PONCTUATION)
    for url in candidats
]

print(urls_nettoyees)

Ce nettoyage est pratique, mais il ne remplace pas une validation complète. Certaines URL peuvent notamment contenir des parenthèses légitimes.

Valider les URL extraites

En Python, urllib.parse.urlsplit() sépare les composants d’une URL. Le module analyse la chaîne, mais ne garantit pas à lui seul que le site existe ou qu’il est accessible.

from urllib.parse import urlsplit

def est_url_http_valide(url):
    try:
        resultat = urlsplit(url)
        return (
            resultat.scheme in {"http", "https"}
            and bool(resultat.netloc)
        )
    except ValueError:
        return False

urls_valides = [
    url for url in urls_nettoyees
    if est_url_http_valide(url)
]

Cette vérification limite les résultats aux URL HTTP et HTTPS et exige la présence d’un domaine ou d’une autorité.

Supprimer les doublons en conservant l’ordre

La méthode recommandée en Python

Pour supprimer les répétitions exactes sans modifier l’ordre d’apparition, utilisez dict.fromkeys() :

urls = [
    "https://example.com",
    "https://example.com",
    "https://example.com/page"
]

urls_uniques = list(dict.fromkeys(urls))
print(urls_uniques)

Résultat :

[
    "https://example.com",
    "https://example.com/page"
]

Pourquoi éviter un simple set ?

Cette instruction supprime également les doublons :

urls_uniques = list(set(urls_valides))

En revanche, elle ne doit pas être utilisée si l’ordre de présentation est important. En JavaScript, un objet Set conserve l’ordre d’insertion et stocke une seule occurrence de chaque valeur. Voir la documentation MDN de Set.

Script Python complet

Voici une fonction prête à utiliser pour extraire les URL d’un texte, les valider et les dédoublonner :

import re
from urllib.parse import urlsplit

URLS_PONCTUATION = ".,;:!?)]}"

def extraire_urls(texte):
    candidats = re.findall(
        r'https?://[^\s<>"\']+',
        texte
    )

    urls_valides = []

    for candidat in candidats:
        url = candidat.rstrip(URLS_PONCTUATION)

        try:
            composants = urlsplit(url)

            if (
                composants.scheme in {"http", "https"}
                and composants.netloc
            ):
                urls_valides.append(url)

        except ValueError:
            continue

    return list(dict.fromkeys(urls_valides))

texte = """
Voir https://example.com,
puis https://example.com/page.
Le lien https://example.com est répété.
"""

for url in extraire_urls(texte):
    print(url)

Sortie :

https://example.com
https://example.com/page

Gérer les liens relatifs

Une chaîne comme /docs/guide n’est pas une URL absolue. Il faut une URL de base pour la compléter avec urljoin() :

from urllib.parse import urljoin

base = "https://example.com/section/"
lien_relatif = "../docs/guide"

url_complete = urljoin(base, lien_relatif)
print(url_complete)

Résultat :

https://example.com/docs/guide

En JavaScript, le constructeur URL permet également de résoudre une URL relative avec une base.

Cas du HTML et du Markdown

HTML

Si le contenu est du HTML, recherchez de préférence les attributs href des balises de lien :

<a href="https://example.com/page">Voir la page</a>

L’URL peut être absente du texte visible, mais présente dans l’attribut href. Un parseur HTML est donc plus adapté qu’une expression régulière généraliste.

Markdown

Pour un lien Markdown, il faut traiter la structure suivante :

[Voir la page](https://example.com/page)

Une expression régulière peut convenir aux cas simples, mais un parseur Markdown sera plus fiable pour gérer toutes les variantes.

Faut-il normaliser les URL avant de les dédoublonner ?

Par défaut, privilégiez la déduplication exacte. Les URL suivantes doivent alors être considérées comme différentes :

https://example.com/page
https://example.com/page?utm_source=newsletter

La seconde contient un paramètre qui peut avoir une fonction réelle pour le serveur ou l’application.

Une déduplication normalisée peut toutefois être pertinente si vous définissez clairement vos règles, par exemple :

  • mettre le schéma et le domaine en minuscules ;
  • supprimer les fragments comme #section si seule la page compte ;
  • retirer certains paramètres de suivi connus ;
  • résoudre les URL relatives avec une URL de base.

Le standard URL WHATWG décrit les règles modernes d’analyse et de normalisation utilisées par les navigateurs. N’appliquez pas de normalisation automatique sans avoir défini l’objectif métier.

À retenir

  • Une expression régulière repère rapidement les URL, mais ne les valide pas complètement.
  • Nettoyez la ponctuation avant la validation.
  • Utilisez urlsplit() pour vérifier la présence d’un schéma HTTP(S) et d’un domaine.
  • Utilisez list(dict.fromkeys(urls)) pour supprimer les doublons tout en conservant l’ordre.
  • Adaptez la méthode au format : texte brut, HTML, Markdown ou liens relatifs.

À retenir

  • Repérez les URL avec une expression régulière.
  • Supprimez les signes de ponctuation parasites.
  • Validez les résultats avec urlsplit().
  • Dédoublonnez avec dict.fromkeys() pour préserver l’ordre.
  • Ne normalisez les URL que si vos règles sont explicites.

Questions fréquentes

Quelle expression régulière utiliser pour extraire les URL d’un texte ?
Pour les URL HTTP et HTTPS courantes, utilisez r'https?://[^s"']+'. Elle sert à repérer les candidats, mais doit être complétée par un nettoyage et une validation.
Comment supprimer les doublons sans changer l’ordre des URL ?
En Python, utilisez list(dict.fromkeys(urls)). Cette méthode conserve la première occurrence de chaque URL et respecte l’ordre d’apparition.
Une expression régulière suffit-elle pour valider une URL ?
Non. Elle peut détecter une chaîne ressemblant à une URL sans garantir qu’elle est correctement formée. Utilisez ensuite urlsplit() et vérifiez le schéma ainsi que le domaine.
Faut-il supprimer les paramètres UTM pour dédoublonner les URL ?
Pas systématiquement. Les paramètres peuvent être utiles à l’application ou au serveur. Commencez par une déduplication exacte et ne retirez les paramètres de suivi que si votre objectif le justifie.
Comment extraire les URL présentes dans un fichier HTML ?
Recherchez les attributs href avec un parseur HTML. Une URL peut être présente dans le code source sans apparaître dans le texte visible.