Comment scraper Healthlinemétadonnées d''articles en CSV

Healthline est l'un des éditeurs de santé et bien-être les plus visités sur le web, avec une riche archive d'articles examinés médicalement couvrant la nutrition, le fitness, les maladies et la santé mentale. Chaque article public porte une couche de métadonnées structurées genuinement utiles en soi : un titre, une signature d'auteur, une date de publication ou de mise à jour, une catégorie et un court résumé. Ces métadonnées alimentent la recherche de contenu, l'analyse des tendances sur les sujets de santé et des catalogues structurés de ce qu'un grand éditeur couvre, le tout sans toucher au corps des articles lui-même.

Ce guide vous montre comment scraper Healthline pour ces métadonnées d'articles publics avec Python, puis exporter les résultats en CSV. Vous construisez un petit scraper exécutable qui récupère une page de recherche ou de liste rendue via la Crawling API, analyse chaque résultat avec BeautifulSoup, et écrit des lignes propres sur le disque. L'ensemble du tutoriel se limite aux métadonnées publiques. Les corps d'articles Healthline sont du contenu éditorial protégé par le droit d'auteur, nous collectons donc la structure et les résumés pour la recherche, jamais le texte intégral pour le republier.

Ce que vous allez construire

Un script Python qui prend une URL de liste ou de recherche Healthline publique, récupère le HTML rendu via la Crawling API, et extrait un enregistrement structuré pour chaque article sur la page. Nous utiliserons une recherche par sujet comme fil conducteur et extrairons ces champs de métadonnées publiques par article :

• Titre de l'article le titre de l'article, par exemple "Antacids Associated with Higher Risk of Migraine".
• URL le lien canonique vers la page d'article publique.
• Auteur la signature, lorsque Healthline l'expose sur la page.
• Date de publication ou de mise à jour la date à laquelle l'article a été publié ou dernièrement examiné.
• Catégorie la section dans laquelle l'article se trouve, comme les actualités santé ou la nutrition.
• Résumé la courte description ou chapeau que Healthline affiche sous le titre.

Pourquoi une requête simple échoue sur Healthline

Si vous demandez une URL de liste ou de recherche Healthline avec un client HTTP brut, vous obtenez une réponse avec le statut 200 et presque aucune des données d'article dans le corps. Healthline rend ses cartes de résultats dans le navigateur avec JavaScript, donc le HTML initial est une coquille qui ne se remplit qu'après l'exécution des scripts de la page. Une page de résultats de recherche en particulier est assemblée côté client à partir d'un flux de données, ce qui signifie que les titres, liens et résumés que vous cherchez ne sont pas dans le balisage brut qu'un appel requests simple renvoie.

Un scraper Healthline fonctionnel a donc besoin de deux choses en une seule requête : un navigateur qui rend réellement la page, et une IP que le site lit comme un vrai visiteur. Vous pouvez assembler cela vous-même avec un navigateur sans interface graphique et un pool de proxies résidentiels rotatifs, mais les assembler et les maintenir en bonne santé représente l'essentiel du travail. La Crawling API combine les deux en un seul appel : vous lui envoyez l'URL avec un token JavaScript, elle rend la page derrière une IP de confiance, et elle renvoie le HTML final à analyser.

Prérequis

Vous avez besoin de quelques éléments en place avant d'écrire du code. Aucun ne prend longtemps.

Python de base. Vous devez être à l'aise pour écrire et exécuter un script Python et installer des paquets avec pip. Si vous découvrez l'analyse HTML, notre guide sur comment utiliser BeautifulSoup en Python couvre les bases des sélecteurs sur lesquels ce tutoriel s'appuie.

Python 3.8 ou version ultérieure. Confirmez votre version avec python --version. Si vous ne l'avez pas, installez-le depuis python.org ou via une distribution comme Anaconda.

Un compte Crawlbase et un token JS. Inscrivez-vous, ouvrez votre tableau de bord et copiez votre token JavaScript (JS) depuis la page docs du compte. Traitez le token comme un mot de passe : il authentifie vos requêtes, gardez-le hors du contrôle de version. Le niveau gratuit inclut 1 000 requêtes, suffisamment pour suivre ce guide de bout en bout.

Configurer le projet

Créez un dossier de projet et un environnement virtuel pour garder les dépendances isolées, puis installez les trois bibliothèques dont le scraper a besoin.

mkdir healthline_scraper
cd healthline_scraper

python -m venv healthline_env
source healthline_env/bin/activate

pip install crawlbase beautifulsoup4 pandas

Sous Windows, activez l'environnement avec healthline_env\Scripts\activate à la place de la ligne source. Trois dépendances font le travail : crawlbase est le client officiel pour la Crawling API, beautifulsoup4 analyse le HTML renvoyé pour que vous puissiez extraire des champs individuels par sélecteur CSS, et pandas structure les enregistrements et les écrit en CSV.

Étape 1 : Récupérer la page de liste rendue

Commencez par obtenir la page finale. Importez la classe CrawlingAPI, initialisez-la avec votre token JS, et demandez l'URL de liste. Vérifier le code de statut avant d'analyser rend les échecs visibles plutôt que silencieux. Notez les deux options d'attente : ajax_wait demande à l'API d'attendre que le contenu asynchrone finisse de se charger, et page_wait attend un nombre fixe de millisecondes pour que les cartes à rendu tardif apparaissent avant la capture de la page.

from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_JS_TOKEN"})

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 5000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

if __name__ == "__main__":
    page_url = "https://www.healthline.com/search?q1=migraine"
    html = crawl(page_url)
    print(html[:500] if html else "No HTML returned")

Lancez le script avec python scraper.py et vous devriez voir du vrai balisage de carte de résultats, pas la coquille vide qu'une récupération simple renvoie. Cinq secondes est un page_wait de départ raisonnable ; augmentez-le si les cartes reviennent vides. Cela confirme que le rendu fonctionne avant d'écrire un seul sélecteur.

Étape 2 : Inspecter la structure des cartes de résultats

Avant d'écrire des sélecteurs, ouvrez une page de recherche ou de liste Healthline dans votre navigateur et inspectez une carte de résultat avec les outils de développement. Healthline utilise des noms de classes hachés générés lors de la compilation, donc les chaînes exactes changent avec le temps. Au moment de la rédaction, chaque résultat de recherche lie via un <a> avec une classe comme css-17zb9f8, et la courte description se trouve dans un <div class="css-1evntxy"> adjacent. Les champs que vous voulez se mappent approximativement ainsi :

• Titre et URL de l'article se trouvent sur le lien du résultat : le texte du lien est le titre, le href est l'URL de l'article public.
• Résumé se trouve dans le bloc de description, le court chapeau que Healthline affiche sous chaque résultat.
• Catégorie peut être lue depuis le chemin URL, par exemple /health-news/ ou /nutrition/, que Healthline utilise comme préfixe de section.

L'auteur et la date ne sont pas toujours présents sur la carte de liste ; ils se trouvent sur la page de l'article elle-même, ce que couvre l'étape 4. Parce que les noms de classes de Healthline sont hachés et changent à chaque déploiement, traitez-les comme un modèle de départ plutôt qu'un contrat, et réinspectez une page en direct quand un champ revient vide.

Étape 3 : Analyser la liste et exporter en CSV

Le HTML rendu en main, chargez-le dans BeautifulSoup, sélectionnez chaque lien de résultat, et extrayez le titre, l'URL, le résumé et la catégorie de chacun. Encapsulez les lectures de champs pour qu'un élément manquant renvoie une chaîne vide plutôt que de faire planter l'exécution, puis passez les enregistrements à pandas pour écrire un CSV.

from bs4 import BeautifulSoup
import pandas as pd

def category_from_url(url):
    parts = url.split("/")
    return parts[3] if len(parts) > 3 else ""

def parse_listing(html):
    soup = BeautifulSoup(html, "html.parser")
    articles = []
    for link in soup.select('a.css-17zb9f8'):
        url = link.get("href", "")
        if not url:
            continue
        summary_el = link.find_next("div", class_="css-1evntxy")
        articles.append({
            "title": link.get_text(strip=True),
            "url": url,
            "category": category_from_url(url),
            "summary": summary_el.get_text(strip=True) if summary_el else "",
        })
    return articles

def save_to_csv(data, filename):
    df = pd.DataFrame(data)
    df.to_csv(filename, index=False)
    print(f"Saved {len(data)} rows to {filename}")

Le lien de résultat est lu une seule fois pour le titre et le href, la catégorie est dérivée du chemin URL sans sélecteur séparé, et le résumé passe par une lecture gardée qui renvoie une chaîne vide quand le bloc de description est absent. L'assistant save_to_csv transforme les enregistrements en DataFrame pandas et les écrit avec to_csv, l'export sur lequel s'appuie la suite du guide.

Étape 4 : Enrichir avec l'auteur, la date et la catégorie depuis la page d'article

La liste vous donne le titre, l'URL et le résumé. Pour renseigner l'auteur et la date de publication ou de mise à jour, récupérez chaque page d'article et lisez ses métadonnées publiques. Healthline expose le titre dans un <h1>, la signature dans un bloc portant un attribut data-testid="byline", et la date dans un élément <time> dont l'attribut datetime contient un horodatage lisible par machine. Nous lisons uniquement ces métadonnées, jamais le corps de l'article.

def text_or_empty(soup, selector):
    el = soup.select_one(selector)
    return el.get_text(strip=True) if el else ""

def parse_article_meta(html, url):
    soup = BeautifulSoup(html, "html.parser")
    time_el = soup.find("time")
    return {
        "title": text_or_empty(soup, "h1"),
        "url": url,
        "author": text_or_empty(soup, '[data-testid="byline"]'),
        "date": time_el.get("datetime", "") if time_el else "",
        "category": category_from_url(url),
    }

Chaque champ a un repli pour qu'une signature ou date manquante renvoie une chaîne vide plutôt qu'une exception. L'attribut datetime de l'élément <time> est préférable au texte de date visible car il est déjà dans un format ISO cohérent, ce qui rend le tri et le filtrage triviaux une fois les données en CSV. Notez ce que cette fonction ne collecte délibérément pas : les paragraphes de l'article. Nous restons sur le titre, l'auteur, la date, la catégorie et le résumé de la liste.

Étape 5 : Assembler le tout

Maintenant câblez le scrape de la liste, l'enrichissement par article et l'export CSV dans un script exécutable unique. Récupérez la liste, analysez-la pour les URLs, récupérez chaque page d'article pour ses métadonnées, et écrivez tout dans un seul CSV. Une courte pause entre les requêtes garde l'exécution courtoise.

import time
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup
import pandas as pd

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_JS_TOKEN"})
OPTIONS = {"ajax_wait": "true", "page_wait": 5000}

def crawl(page_url):
    response = api.get(page_url, OPTIONS)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

def main():
    listing_url = "https://www.healthline.com/search?q1=migraine"
    listing_html = crawl(listing_url)
    if not listing_html:
        return

    listing = parse_listing(listing_html)
    records = []
    for item in listing:
        article_html = crawl(item["url"])
        if article_html:
            meta = parse_article_meta(article_html, item["url"])
            meta["summary"] = item["summary"]
            records.append(meta)
        time.sleep(2)

    save_to_csv(records, "healthline_articles.csv")

if __name__ == "__main__":
    main()

Ce code suppose que parse_listing, parse_article_meta, category_from_url et save_to_csv des étapes précédentes se trouvent dans le même fichier. Le flux est simple : une requête pour la liste, puis une requête par article pour l'enrichir avec l'auteur et la date, puis une seule écriture CSV à la fin. Le summary de la carte de liste est fusionné sur les métadonnées de chaque article pour que chaque ligne soit complète.

À quoi ressemble la sortie

Lancez le script complet avec python scraper.py et vous obtenez un CSV avec une ligne par article, chacune ne contenant que des métadonnées publiques, prêtes pour une analyse dans pandas ou un tableur.

title,url,author,date,category,summary
"Antacids Associated with Higher Risk of Migraine",https://www.healthline.com/health-news/antacids-increase-migraine-risk,"Nancy Schimelpfening",2024-01-09,health-news,"New research suggests people who take antacids may be at greater risk for migraine attacks."
"Migraine: What to Ask Your Doctor",https://www.healthline.com/health/migraine/what-to-ask-doctor-migraine,"Healthline Editorial Team",2023-11-02,health,"A short list of questions to bring to your next appointment."

Comme la date provient de l'attribut datetime de l'élément <time>, elle arrive au format ISO, vous pouvez donc trier par récence ou filtrer une plage de dates sans analyser du texte libre. La colonne catégorie, dérivée de chaque chemin URL, vous permet de regrouper les comptes par section pour voir où un éditeur concentre sa couverture.

Passer à l'échelle sur plusieurs sujets et pages

Une liste est une démonstration ; un vrai travail s'étend sur de nombreux sujets et pages de résultats. La recherche Healthline accepte un paramètre de requête, vous pouvez donc boucler sur une liste de sujets et réutiliser la même paire récupération-analyse pour chacun. Comme chaque résultat de recherche partage la même structure de carte, le parseur que vous avez déjà écrit fonctionne sur tous sans modification. Ajoutez les lignes de chaque sujet dans une liste et écrivez un seul CSV à la fin.

def scrape_topics(topics):
    all_articles = []
    for topic in topics:
        url = f"https://www.healthline.com/search?q1={topic}"
        html = crawl(url)
        if html:
            all_articles.extend(parse_listing(html))
        time.sleep(2)
    return all_articles

topics = ["migraine", "nutrition", "sleep"]
save_to_csv(scrape_topics(topics), "healthline_topics.csv")

Le time.sleep(2) entre les sujets est délibéré. Marteler la recherche dans une boucle serrée est le moyen le plus rapide d'être ralenti, même avec le rendu et la rotation gérés pour vous. Espacez les requêtes, et arrêtez tôt dès qu'un sujet ne renvoie plus de nouveaux articles.

Rester non bloqué

Même avec le rendu géré, Healthline surveille le trafic à l'allure d'un scraper. Quelques habitudes maintiennent une exécution en bonne santé, et elles s'appliquent à tout grand éditeur.

• Espacez vos requêtes. Répartissez les requêtes et variez vos sujets au lieu de crawler un chemin de recherche à plein régime.
• Misez sur la rotation. Un pool d'IP résidentielles répartit les requêtes sur de nombreuses adresses d'utilisateurs réels pour qu'aucune seule ne déclenche une limite de débit. La Crawling API s'en charge pour vous ; si vous gérez votre propre infrastructure, c'est la partie à bien configurer.
• Lisez les codes de statut. Une exécution qui commence à renvoyer des défis ou des erreurs vous indique que le débit ou le niveau d'IP actuel n'est plus suffisant. Traitez cela comme un signal à ralentir, pas du bruit à ignorer.

Pour le guide complet, consultez comment scraper des sites web sans être bloqué et l'analyse approfondie sur comment contourner les CAPTCHA lors du scraping web. Si vous préférez router votre propre trafic à travers un pool rotatif plutôt que d'utiliser l'API gérée, le Smart AI Proxy (aussi appelé AI Proxy) vous offre la même rotation d'IP résidentielles comme point de terminaison proxy de substitution.

Est-il légal de scraper Healthline ?

La question de savoir si le scraping de Healthline est autorisé dépend des conditions d'utilisation de Healthline, de votre juridiction et de ce que vous faites des données. Les conditions de Healthline restreignent l'accès automatisé et son contenu est du travail éditorial protégé par le droit d'auteur, donc le scraping peut aller à l'encontre de ces conditions quelle que soit la prudence de votre outillage. Rien dans ce code ne change cela ; il rend simplement la partie technique fonctionnelle. Lisez les Conditions d'utilisation de Healthline et son robots.txt, et traitez les deux comme la limite de ce que vous collectez.

Quelques lignes à respecter. Ne collectez que les métadonnées publiques : le titre de l'article, l'URL, la signature de l'auteur, la date de publication ou de mise à jour, la catégorie et le court résumé que tout le monde peut voir sur une page publique sans se connecter. Ne scrapez pas et ne republiez pas les corps d'articles complets. Les articles de Healthline sont du contenu médical et éditorial protégé par le droit d'auteur, et les reproduire est un problème de droit d'auteur, pas seulement un problème de conditions. Respectez les attentes de débit indiquées de Healthline et maintenez votre volume de requêtes suffisamment bas pour ne pas mettre à rude épreuve ses serveurs.

Un dernier point spécifique à un éditeur de santé : ce guide est destiné au catalogage et à la recherche sur les métadonnées publiques, pas à la source de conseils médicaux. Les informations de santé changent, et l'exactitude d'un article dépend d'un contexte qu'une ligne scrapée ne peut pas capturer. Ne comptez pas sur le contenu de santé scrapé pour des décisions médicales, et consultez un professionnel médical ou juridique qualifié avant d'agir sur la base de celui-ci ou de le redistribuer. Healthline ne propose pas d'API publique pour l'accès en masse aux articles, donc si votre projet nécessite le contenu complet ou une redistribution à grande échelle, la bonne voie est de demander une permission ou un accord de licence, pas un scraper plus astucieux.

Foire aux questions

Puis-je scraper Healthline avec juste requests et BeautifulSoup ?

Pas de manière fiable. Healthline rend ses cartes de résultats dans le navigateur avec JavaScript, donc un appel requests brut renvoie le statut 200 avec les listes vides. Vous avez besoin de quelque chose qui rend d'abord la page, ce que le token JS de la Crawling API plus les options ajax_wait et page_wait gèrent avant que BeautifulSoup voie le HTML.

Ai-je besoin du token normal ou du token JS pour Healthline ?

Le token JS. Le token normal récupère le HTML statique, qui sur Healthline est la même coquille vide qu'une récupération simple renvoie. Le token JS rend la page dans un vrai navigateur avant de renvoyer le HTML, donc les cartes d'articles sont présentes quand BeautifulSoup les analyse.

Quelles données dois-je collecter depuis Healthline ?

Restez sur les métadonnées publiques : le titre de l'article, l'URL, l'auteur, la date de publication ou de mise à jour, la catégorie et le court résumé affiché sur les pages publiques. Ne scrapez pas et ne republiez pas les corps d'articles complets. Les articles de Healthline sont du contenu éditorial protégé par le droit d'auteur, donc la portée sûre et défendable est la structure et les résumés pour la recherche, pas la prose elle-même.

Comment exporter les données scrapées en CSV ?

Construisez une liste de dictionnaires, un par article, puis passez-la à pandas avec pd.DataFrame(data).to_csv("healthline_articles.csv", index=False). L'assistant save_to_csv dans ce guide encapsule exactement cela. Comme chaque ligne ne contient que des champs de métadonnées plats, le CSV s'ouvre proprement dans n'importe quel tableur ou se recharge dans pandas pour analyse.

Mes sélecteurs renvoient des chaînes vides. Qu'est-ce qui a changé ?

Très probablement le balisage de Healthline. Les noms de classes hachés sur lesquels le parseur s'appuie changent à chaque déploiement, et une refonte peut renommer les hooks de signature ou de date. Réinspectez une page en direct dans les outils de développement de votre navigateur et mettez à jour les sélecteurs. La maintenance périodique des sélecteurs est normale pour tout scraper en production.

Les informations de santé scrapées sont-elles sûres à utiliser ?

Non. Traitez les lignes scrapées comme des métadonnées pour le catalogage et la recherche, pas comme des conseils médicaux. Les informations de santé changent et dépendent d'un contexte qu'un seul champ ne peut pas capturer, consultez donc un professionnel médical ou juridique qualifié avant d'agir sur la base de celles-ci ou de les redistribuer. Pour le contenu complet ou une redistribution à grande échelle, demandez une permission ou une licence à Healthline plutôt que de scraper les corps.

HR

Hassan Rehan

Ingénieur logiciel · Crawlbase

Ingénieur logiciel chez Crawlbase, il rédige des guides pratiques sur les proxys rotatifs, le scraping et les détails concrets de l'intégration de proxys dans du vrai code.