Le RSS est l'un des moyens les plus sous-estimés — et pourtant les plus commodes — d'obtenir des données de sites web. Pendant que tout le monde débat de « parsing complexe » avec contournement de JavaScript et de captchas, des milliers de ressources livrent tranquillement leur contenu sous forme de XML propre et structuré. Encore faut-il savoir où chercher et comment le lire.
Dans cet article : ce qu'est le RSS, à quoi sert son parsing, comment trouver les flux d'un site et comment lire un fil dans différents langages de programmation.
Qu'est-ce que le RSS et pourquoi il est si facile à analyser
Le RSS (Really Simple Syndication) est un format XML standardisé dans lequel un site publie la liste de ses contenus récents : titres, liens, résumés, dates de publication, parfois le texte intégral et des pièces jointes. À côté existe le format Atom, très proche — même mission, seuls des détails de balisage diffèrent.
La différence clé avec le parsing HTML classique : la structure d'un flux est prévisible et stable. Pas besoin de s'accrocher à des classes CSS qui changeront à la prochaine refonte. Les champs sont partout les mêmes :
title— le titre ;link— le lien vers le contenu ;descriptionousummary— le résumé ;pubDateouupdated— la date de publication ;guidouid— l'identifiant unique de l'entrée.
Cela fait du RSS le point d'entrée idéal quand le site propose un tel flux.
À quoi sert le parsing de RSS
Les scénarios d'usage sont nombreux, et loin d'être tous évidents :
Agrégateurs d'actualités et de contenus. Le cas le plus classique : rassembler en un seul endroit les publications de dizaines de sources. C'est ainsi que fonctionnent lecteurs, digests thématiques et médias de niche.
Veille des mentions et des tendances. Détection quasi temps réel de l'apparition de mots-clés (nom d'entreprise, de marque, de personnalité) dans les fils des médias et des blogs, sans délai ni parcours manuel des sites.
Alimentation et automatisation. Publication automatique sur les réseaux sociaux et les canaux Telegram, mise à jour de vitrines, préparation de calendriers éditoriaux — tout cela se construit sur des données fraîches issues des flux.
Intelligence concurrentielle. Beaucoup d'entreprises tiennent un blog avec RSS. En vous y abonnant programmatiquement, vous êtes le premier informé des versions, articles et annonces.
Données pour l'analyse et le ML. Les flux RSS sont une source de textes propre et bon marché pour entraîner des modèles, analyser la tonalité, regrouper des sujets et construire des graphes d'actualités.
Notifications. Alertes personnelles sur les nouvelles offres d'emploi, annonces, messages de forums, mises à jour de documentation.
L'avantage principal sur le scraping HTML : vitesse de développement, stabilité et charge faible, pour vous comme pour la source.
Comment trouver des sites et des flux RSS
Beaucoup de sites publient un flux RSS sans le mettre en avant. Voici des méthodes qui fonctionnent.
1. La balise meta dans le code HTML de la page
Les sites bien configurés déclarent leur flux dans le <head> :
<link rel="alternate" type="application/rss+xml" title="RSS" href="/feed.xml">
<link rel="alternate" type="application/atom+xml" title="Atom" href="/atom.xml">
Il suffit d'ouvrir le code source de la page (Ctrl+U) et de chercher application/rss+xml ou application/atom+xml. Cette même balise peut être extraite programmatiquement pour la découverte automatique de flux.
2. Les structures d'URL courantes
Une grande partie des flux vit à des chemins prévisibles. Il suffit de les tester :
/rss
/rss.xml
/feed
/feed.xml
/feeds
/atom.xml
/index.xml
/rss/all.xml
À connaître pour les plateformes populaires :
- WordPress :
/feed/,/?feed=rss2, pour une rubrique —/category/nom/feed/; - Blogger :
/feeds/posts/default; - YouTube :
https://www.youtube.com/feeds/videos.xml?channel_id=ID_DE_LA_CHAINE; - Reddit : ajoutez
.rssà n'importe quelle section, par exemple/r/programming.rss; - Substack / Medium :
/feed.
3. Opérateurs de recherche et services
Dans un moteur de recherche, des requêtes comme site:example.com rss ou inurl:feed site:example.com aident. Il existe aussi des services de découverte de flux (RSS.app, Feedly) qui trouvent eux-mêmes les fils disponibles à partir de l'adresse du site. Et si aucun flux officiel n'existe, certains outils génèrent un RSS à partir de pages HTML ordinaires — mais on se rapproche alors du parsing classique.
Exemples d'implémentation dans différents langages
Voici des exemples minimaux et fonctionnels de lecture d'un flux. Partout, des bibliothèques éprouvées qui gèrent à la fois RSS et Atom et vous épargnent les différences de versions du standard.
Python
La bibliothèque feedparser est le standard de fait de l'écosystème Python.
# pip install feedparser
import feedparser
feed = feedparser.parse("https://example.com/feed.xml")
print(f"Source : {feed.feed.get('title', 'sans titre')}")
for entry in feed.entries:
print("—" * 40)
print("Titre :", entry.get("title"))
print("Lien : ", entry.get("link"))
print("Date : ", entry.get("published", "inconnue"))
print("Résumé :", entry.get("summary", "")[:200])
feedparser normalise lui-même les champs : entry.title et entry.link sont disponibles que le fil soit RSS ou Atom.
JavaScript / Node.js
Le paquet rss-parser se marie bien avec async/await.
// npm install rss-parser
import Parser from "rss-parser";
const parser = new Parser();
async function readFeed(url) {
const feed = await parser.parseURL(url);
console.log(`Source : ${feed.title}`);
feed.items.forEach((item) => {
console.log("—".repeat(40));
console.log("Titre :", item.title);
console.log("Lien : ", item.link);
console.log("Date : ", item.pubDate);
});
}
readFeed("https://example.com/feed.xml").catch(console.error);
PHP
PHP dispose de la bibliothèque SimplePie, mais pour les besoins de base le SimpleXML intégré suffit.
<?php
// Variante sans dépendances — SimpleXML intégré
$feed = simplexml_load_file("https://example.com/feed.xml");
echo "Source : " . $feed->channel->title . PHP_EOL;
foreach ($feed->channel->item as $item) {
echo str_repeat("—", 40) . PHP_EOL;
echo "Titre : " . $item->title . PHP_EOL;
echo "Lien : " . $item->link . PHP_EOL;
echo "Date : " . $item->pubDate . PHP_EOL;
}
Pour la production, préférez SimplePie (composer require simplepie/simplepie) : cache, gestion d'Atom et robustesse face au XML « sale ».
Go
Dans l'écosystème Go, gofeed est populaire et comprend les deux formats à la fois.
// go get github.com/mmcdole/gofeed
package main
import (
"fmt"
"github.com/mmcdole/gofeed"
)
func main() {
fp := gofeed.NewParser()
feed, err := fp.ParseURL("https://example.com/feed.xml")
if err != nil {
panic(err)
}
fmt.Println("Source :", feed.Title)
for _, item := range feed.Items {
fmt.Println("————————————————")
fmt.Println("Titre :", item.Title)
fmt.Println("Lien : ", item.Link)
fmt.Println("Date : ", item.Published)
}
}
Ruby
Le gem feedjira règle la question avec concision.
# gem install feedjira
require "feedjira"
require "httparty"
xml = HTTParty.get("https://example.com/feed.xml").body
feed = Feedjira.parse(xml)
puts "Source : #{feed.title}"
feed.entries.each do |entry|
puts "—" * 40
puts "Titre : #{entry.title}"
puts "Lien : #{entry.url}"
puts "Date : #{entry.published}"
end
Les pièges à garder en tête
Le parsing de RSS est simple, mais le travail réel révèle des subtilités :
- Déduplication. La même entrée revient plusieurs fois dans le flux. Conservez les
guid/iddéjà traités pour ne pas dupliquer les contenus. - Contenu incomplet. Le flux ne livre souvent que l'annonce, pas le texte intégral. Il faut alors charger la page liée et la parser.
- Encodages et XML « sale ». Tous les flux ne sont pas valides. Les bonnes bibliothèques pardonnent les erreurs, pas les parseurs faits maison.
- Fréquence d'interrogation. Ne sollicitez pas le flux chaque seconde. Respectez les en-têtes
ETagetLast-Modifiedpour ne pas retélécharger l'identique et éviter le blocage. - Limites du flux. Un RSS ne livre généralement que les 10–50 dernières entrées. Impossible de reconstituer l'historique ainsi — il faut une archive ou une veille continue avec accumulation.
- Passage à l'échelle. Avec des centaines de sources apparaissent planificateur, files d'attente, surveillance des flux « tombés » et stockage. Le petit script devient une vraie infrastructure.
Quand confier cela à des professionnels
Lire un flux prend cinq minutes. Mais bâtir un flot stable d'actualités depuis des centaines de sources, ramener des formats hétérogènes à une structure unique, assurer la déduplication, le chargement des textes intégraux, le nettoyage et un fonctionnement 24 h/24 — c'est déjà un vrai travail d'ingénierie.
Si vous voulez un résultat prêt à l'emploi plutôt que la maintenance de votre propre chaîne de parsing, découvrez notre service « Extraction d'articles de presse ». Nous prenons en charge la recherche et le raccordement des sources (y compris les sites sans RSS apparent), la normalisation des données, le filtrage selon vos thèmes et mots-clés, et la livraison d'un flux d'actualités propre et structuré au format qui vous convient — API, export ou intégration directe dans votre système. Vous recevez des données prêtes ; la routine des flux, encodages et sources instables est pour nous.
Le RSS reste l'un des moyens les plus efficaces d'obtenir des données là où il est disponible : structure prévisible, faible charge, développement rapide. Commencez par chercher les flux des sites qui vous intéressent, essayez les exemples ci-dessus dans votre langage — et quand la tâche dépassera le cadre d'un script, vous saurez à qui vous adresser.