Alimenter les RAG/LLM avec Trafilatura

Mise à jour : 23/07/2025

Trafilatura est un outil open-source en Python conçu pour extraire automatiquement le contenu textuel des pages web. Contrairement aux scrapers traditionnels, il privilégie la qualité du contenu, en supprimant les menus, publicités et autres éléments inutiles. Que vous souhaitiez transformer des pages HTML en Markdown, JSON ou texte brut, Trafilatura vous offre une solution rapide, fiable et respectueuse des bonnes pratiques web.

Présentation de Trafilatura

Développé par Adrien Barbaresi, chercheur en linguistique computationnelle, Trafilatura s’inscrit dans une démarche académique : offrir un outil robuste et reproductible pour l’analyse de textes issus du web. Il est publié sous licence MIT, et donc librement réutilisable dans vos projets, personnels comme professionnels.

L’objectif principal n’est pas de scraper massivement des pages pour stocker des données, mais de fournir un texte propre, exploitable, notamment pour :

des pipelines SEO
des corpus pour l’analyse linguistique
des bases d’entraînement pour modèles NLP
des workflows RAG/LLM pour indexer du contenu

Trafilatura repose sur une logique de filtrage de structure HTML (avec XPath et règles contextuelles), combinée à un modèle d’évaluation du contenu.

Pourquoi choisir Trafilatura ?

Voici quelques points qui distinguent Trafilatura d’autres outils comme newspaper3k, Boilerpipe ou jusText :

Il prend en charge les langues non anglaises (dont le français)
Il gère les flux RSS et les sitemaps nativement
Il permet d’extraire les métadonnées : titre, auteur, date, catégorie
Il peut exporter le texte en Markdown, JSON structuré, XML, etc.
Il est conçu pour fonctionner sans base de données
Performance optimisée : plus rapide que BeautifulSoup, plus précis que newspaper3k

Enfin, sa documentation complète et son intégration simple en Python ou via une interface en ligne de commande en font un outil idéal pour les administrateurs système, développeurs ou data scientists qui cherchent à automatiser l’extraction de texte web de qualité.

Installation et configuration

Trafilatura peut être utilisé aussi bien en ligne de commande qu’en tant que module Python. Son installation est simple et rapide, que ce soit sur un environnement local ou dans un conteneur.

Installation via pip

Il est recommandé d’utiliser un environnement virtuel pour éviter les conflits de dépendances :

python -m venv venv
source venv/bin/activate
pip install trafilatura lxml_html_clean

Modules complémentaires

Pour améliorer les performances, certains modules optionnels peuvent être ajoutés :

pip install trafilatura[all] lxml_html_clean

Utilisation en ligne de commande

Une fois installé, Trafilatura peut être utilisé directement depuis le terminal :

trafilatura --version
Trafilatura 2.0.0 - Python 3.10.12

Exemple simple pour extraire le texte d’une page web :

trafilatura -u "https://exemple.com/article"

Le texte est affiché dans la console ou peut être redirigé dans un fichier :

trafilatura -u "https://exemple.com/article" > article.txt

Configuration par défaut

Par défaut, Trafilatura utilise un mode équilibré entre vitesse et précision. Les options peuvent être modifiées à la volée dans le script Python ou avec des arguments CLI :

--json : export en JSON
--metadata : inclure les métadonnées
--no-fallback : désactiver les méthodes de secours pour extraction rapide
--parallel : activer le traitement parallèle pour les URLs multiples
keep-dirs : conserver la structure des répertoires lors de l’export

Crawling et exploration de sites

Pour crawler un site :

trafilatura --crawl "https://example.org" > links.txt

Pour utiliser les sitemaps si disponibles :

trafilatura --explore "https://example.org"

Ces commandes récupèrent jusqu’à 30 pages par défaut.

Pour traiter une liste de sites :

trafilatura --crawl -i liste_urls.txt

Configuration de Trafilatura

Trafilatura peut être entièrement configuré grâce à ses fichiers de configuration. Deux types de réglages sont possibles :

via un fichier de configuration utilisateur
via le fichier Python settings.py du package

Personnalisation avec `settings.cfg`

Ce fichier permet d’ajuster le comportement de l’extraction, des téléchargements, de la déduplication ou de la gestion des métadonnées.

[DEFAULT]
# Téléchargement
DOWNLOAD_TIMEOUT = 30
SLEEP_TIME = 5
MAX_REDIRECTS = 2
USER_AGENTS = Mozilla/5.0 (compatible; TrafilaturaBot/1.0)

# Extraction
MIN_EXTRACTED_SIZE = 250
MIN_OUTPUT_SIZE = 1
EXTRACTION_TIMEOUT = 30
FAVOR_PRECISION = False
FAVOR_RECALL = True

# Déduplication
MIN_DUPLCHECK_SIZE = 100
MAX_REPETITIONS = 2

# Métadonnées
EXTENSIVE_DATE_SEARCH = True
AUTHOR_BLACKLIST = admin,webmaster,editor

# Navigation
EXTERNAL_URLS = False
MAX_FILE_SIZE = 20000000
MIN_FILE_SIZE = 10

Développer des scripts Python avec Trafilatura

Utiliser Trafilatura en Python, c’est simple et puissant. Que vous vouliez juste extraire le texte d’un article ou automatiser l’archivage de dizaines de pages web, l’outil vous offre une API claire et personnalisable.

Premier script : extraire une page web

Commençons par le plus simple : récupérer le contenu d’un seul article de blog ou d’actualité.

from trafilatura import fetch_url, extract

url = "https://example.com/articles"
downloaded = fetch_url(url)
result = extract(downloaded)
print(result)

Ce qui se passe ici :

fetch_url() télécharge la page HTML complète
extract() analyse le HTML et extrait uniquement le contenu principal
Le résultat est du texte brut, nettoyé des menus et publicités

Choisir le format de sortie

Par défaut, Trafilatura retourne du texte simple. Mais selon votre projet, vous pourriez préférer d’autres formats plus structurés.

# Texte avec métadonnées au format JSON
result_json = extract(downloaded, output_format="json", with_metadata=True)

# Texte formaté en Markdown (idéal pour les blogs)
result_md = extract(downloaded, output_format="markdown")

# Structure XML complète (pour l'analyse avancée)
result_xml = extract(downloaded, output_format="xml")

Formats disponibles :

JSON : Parfait si vous voulez stocker les données ou les analyser
Markdown : Idéal pour republier le contenu ou l’intégrer dans un CMS
XML : Utile pour conserver la structure complète du document
CSV : Pratique pour importer dans Excel ou Google Sheets

Ajouter ou exclure des éléments HTML

Vous pouvez demander à garder ou supprimer certains éléments :

include_comments=True → pour garder les commentaires
include_tables=False → ignorer les tableaux HTML
include_links=True → conserver les liens cliquables
include_images=True → garder les balises <img>

Exemple :

extract(downloaded, include_links=True, include_tables=False)

Configuration avancée

Trafilatura permet de personnaliser l’extraction via un fichier de configuration :

from trafilatura.settings import use_config
newconfig = use_config("mon_fichier.cfg")
extract(downloaded, config=newconfig)

Optimiser l’extraction

Vous pouvez désactiver les options de secours pour accélérer l’extraction (moins précis, mais plus rapide) :

extract(downloaded, no_fallback=True)

Ou tout combiner pour un script rapide :

extract(downloaded, include_comments=False, include_tables=False, no_fallback=True)

Améliorer la qualité du texte

Deux options permettent d’ajuster l’équilibre entre précision (texte propre) et rappel (texte complet) :

favor_precision=True → mieux filtrer le bruit
favor_recall=True → capturer plus d’éléments

Et pour exclure des zones précises :

extract(downloaded, prune_xpath="//div[@class='ads']")

Extraction simplifiée ou brute

Trafilatura propose plusieurs fonctions d’extraction adaptées à vos besoins :

html2txt() → récupère tout le texte, même approximatif
baseline() → bon compromis entre vitesse et qualité
bare_extraction() → retourne le texte et les métadonnées séparément

Exemple :

from trafilatura import baseline
postbody, text, length = baseline(downloaded)

Traiter du HTML que vous avez déjà

Parfois, vous avez déjà récupéré du HTML par d’autres moyens (API, base de données, etc.). Trafilatura peut traiter directement ce contenu.

# Si vous avez du HTML sous forme de texte
html_content = "<html><body><h1>Titre</h1><p>Contenu...</p></body></html>"
result = extract(html_content)

# Si vous utilisez BeautifulSoup
from bs4 import BeautifulSoup
from lxml.html.soupparser import convert_tree

soup = BeautifulSoup(html_content, "html.parser")
tree = convert_tree(soup)[0]
result = extract(tree)

Utiliser des configurations réutilisables

Pour éviter de répéter les mêmes paramètres dans tous vos scripts, créez des configurations prédéfinies.

from trafilatura.settings import Extractor

# Configuration pour un blog personnel
config_blog = Extractor(
    output_format="markdown",
    with_metadata=True,
    include_links=True,
    favor_precision=True
)

# Configuration pour de l'analyse de données
config_data = Extractor(
    output_format="json",
    include_tables=True,
    include_images=False,
    deduplicate=True
)

# Utilisation
result = extract(downloaded, options=config_blog)

Attendre entre chaque requête

Définissez un sleep_time par domaine dans les fonctions parallèles :

bufferlist, url_store = load_download_buffer(url_store, sleep_time=30)

Traiter plusieurs pages efficacement

Pour crawler plusieurs URLs, Trafilatura propose des outils de téléchargement parallèle qui respectent les serveurs.

from trafilatura.downloads import add_to_compressed_dict, buffered_downloads, load_download_buffer

# Liste de vos URLs
urls = ['https://site1.com/article1', 'https://site2.com/article2', 'https://site1.com/article3']

# Préparation du téléchargement groupé
url_store = add_to_compressed_dict(urls)
threads = 2  # Nombre de téléchargements simultanés

# Traitement par lots
while not url_store.done:
    # Charger un lot d'URLs avec délai automatique
    bufferlist, url_store = load_download_buffer(url_store, sleep_time=5)

    # Télécharger et traiter
    for url, html_content in buffered_downloads(bufferlist, threads):
        if html_content:
            result = extract(html_content)
            print(f"Traité: {url} - {len(result)} caractères")

Avantages de cette approche :

Téléchargement parallèle (plus rapide)
Délais automatiques par domaine (respectueux)
Gestion des erreurs intégrée
Optimisation mémoire

Utiliser un proxy SOCKS

Trafilatura peut passer par un proxy :

export http_proxy=socks5://USER:PASSWORD@PROXYHOST:PROXYPORT

Ou directement dans Python :

import trafilatura.downloads
trafilatura.downloads.PROXY_URL = "socks5://localhost:9050"

Réinitialiser la mémoire (en cas de fuite)

from trafilatura.meta import reset_caches
reset_caches()

Exploration du web (crawling) avec Trafilatura

Un crawler web est un outil qui explore des sites internet à partir de liens trouvés dans les pages, pour les analyser ou les stocker. Trafilatura intègre un crawler “focalisé”, respectueux des règles d’accès (robots.txt), capable d’explorer efficacement un site tout en évitant les doublons.

Intra-site vs inter-sites

Crawl intra-site : explorer un site unique à partir de sa page d’accueil (navigation, archives, catégories)
Crawl inter-sites : explorer plusieurs domaines, plus complexe à gérer (bruit, erreurs, ressources)

Trafilatura est surtout adapté au crawling intra-site, ou à partir de listes filtrées manuellement.

Fonctionnement du crawler

On commence avec une liste d’URLs de départ (“seed”).
Le crawler analyse les pages, récupère les liens internes utiles.
Il construit une file d’attente (frontier) de liens à visiter.
Il évite les doublons d’URL ou de contenu.
Il respecte les délais entre requêtes (selon le domaine).

Utilisation en Python : `focused_crawler`

from trafilatura.spider import focused_crawler

# premier passage
to_visit, known_links = focused_crawler("https://example.org", max_seen_urls=1)

# second passage
to_visit, known_links = focused_crawler(
    "https://example.org",
    max_seen_urls=10,
    max_known_urls=100000,
    todo=to_visit,
    known_links=known_links
)

Arguments utiles :

max_seen_urls : pages à visiter
max_known_urls : pages découvertes au total
todo : liste des pages restantes à visiter
known_links : liste des liens déjà vus
lang="fr" : filtrage par langue

Pour savoir si le crawl peut continuer :

from trafilatura.spider import is_still_navigation

is_still_navigation(to_visit)  # True ou False

Déduplication

Lorsqu’on extrait beaucoup de contenu web, il est courant de rencontrer des doublons : mêmes paragraphes répétés, mêmes articles ou pages très similaires. Cela peut fausser les analyses et gaspiller des ressources. Trafilatura propose deux niveaux de détection des doublons : au niveau des segments (paragraphes) et des documents entiers.

Doublons dans une page (segments)

Cela concerne les éléments répétés comme les menus, pieds de page ou extraits d’articles visibles sur plusieurs pages d’un même site.

Lors de l’extraction, activez la déduplication :

extract(downloaded, deduplicate=True)

Ou via la classe Extractor :

from trafilatura.settings import Extractor
options = Extractor()
options.dedup = True
extract(downloaded, options=options)

Doublons entre documents (similaires ou identiques)

À grande échelle, il faut identifier des contenus presque identiques. Trafilatura utilise Simhash, un algorithme de hachage sensible à la similarité.

from trafilatura.deduplication import Simhash

first = Simhash("Ceci est un texte.")
second = Simhash("Ceci est un test.")
second.similarity(first)  # Résultat entre 0 et 1 (ex. 0.84)

Générer un nom de fichier unique

Utile pour nommer automatiquement les fichiers en fonction de leur contenu :

from trafilatura.deduplication import generate_hash_filename
generate_hash_filename("Voici un article.")
# Exemple : 'qAgzZnskrcRgeftk'

Bonnes pratiques

L’utilisation efficace de Trafilatura nécessite de respecter quelques règles essentielles :

Vérifiez toujours robots.txt avant de crawler, si le site en dispose. Cela permet de respecter les règles d’accès définies par le propriétaire du site.

from urllib.robotparser import RobotFileParser

def can_crawl(url):
    rp = RobotFileParser()
    rp.set_url(url + '/robots.txt')
    rp.read()
    return rp.can_fetch('*', url)

Utilisez un User-Agent identifiable et respectez les délais :

import trafilatura.downloads
import time

trafilatura.downloads.DEFAULT_HEADERS['User-Agent'] = 'MonBot/1.0 (contact@example.com)'

def crawl_respectfully(urls, delay=2):
    for url in urls:
        if can_crawl(url):
            downloaded = fetch_url(url)
            result = extract(downloaded)
            time.sleep(delay)
            yield result

Pour crawler de manière responsable, il est recommandé d’ajouter un délai entre les requêtes pour éviter de surcharger le serveur :

import trafilatura.downloads
import time

def crawl_with_delay(urls, delay=5):
    for url in urls:
        if can_crawl(url):
            downloaded = fetch_url(url)
            result = extract(downloaded)
            time.sleep(delay)  # Délai entre les requêtes
            yield result

Conclusion

Trafilatura est un outil puissant pour l’extraction de texte web, offrant une solution simple et efficace pour transformer des pages HTML en formats structurés comme Markdown ou JSON. Que vous soyez développeur, data scientist ou administrateur système, il vous permet d’automatiser l’extraction de contenu web de qualité, tout en respectant les bonnes pratiques du web. Grâce à sa documentation complète et à sa flexibilité, Trafilatura s’intègre facilement dans vos workflows, que ce soit pour des projets personnels ou professionnels. N’hésitez pas à explorer ses fonctionnalités avancées pour adapter l’extraction à vos besoins spécifiques, et à contribuer à son développement si vous le souhaitez.

Plus d’informations

Pour en savoir plus sur Trafilatura, consultez la documentation officielle ↗.