Comment scraper des pages Facebook avec PyCharmun tutoriel Python et PyCharm

Les pages Facebook publiques, les profils de marques et d'entreprises que tout le monde peut consulter sans se connecter, contiennent de nombreux signaux publics utiles : le nom de la page, le texte visible des publications publiques et les compteurs agrégés qu'affiche une publication. Pour la veille concurrentielle, la surveillance de marque ou le benchmarking de contenu, cette surface publique vaut la peine d'être lue par programmation. Ce guide vous montre comment scraper une page Facebook publique avec Python, développé et exécuté dans PyCharm, d'une façon qui fonctionne réellement.

Pour être sans ambiguïté dès le départ : tout ce qui suit est limité aux pages Facebook publiques uniquement. Cela signifie le nom public de la page, le texte visible des publications publiques et les compteurs agrégés publics qu'une page ou une publication montre à tout visiteur. Cela ne couvre pas les groupes privés, les listes de membres, les profils personnels, le contenu protégé par une connexion, les commentaires liés à des individus nommés ou toutes les données personnelles des personnes. Facebook et sa société mère Meta restreignent l'accès automatisé dans leurs conditions, alors lisez la section légalité vers la fin avant de pointer ceci sur quoi que ce soit de réel. Pour un usage en production ou commercial, l'API officielle Facebook Graph est le bon outil, pas un scraper.

Ce que vous allez construire

Un petit script Python, écrit et exécuté dans PyCharm, qui prend l'URL d'une page Facebook publique, récupère la page entièrement rendue via la Crawling API avec un token JavaScript et analyse quelques champs publics :

• Nom public de la page le nom de la marque ou de l'entreprise affiché sur la page.
• Texte public des publications le texte visible du corps des publications publiques sur la page.
• Compteurs publics les chiffres agrégés qu'une page publique affiche, comme le nombre de réactions ou de partages d'une publication, traités comme des nombres uniquement.
• URLs des publications publiques le lien permanent vers chaque publication publique.

Notez ce qui est délibérément absent : pas de listes de membres de groupes, pas d'identités de commentateurs, pas de profils personnels, pas de coordonnées d'individus. Ce sont des données personnelles, et les collecter est volontairement hors de portée ici. L'ancienne version de ce tutoriel ciblait les groupes Facebook ; cette réécriture reste strictement sur les pages publiques, qui est la surface défendable.

Pourquoi une simple requête échoue sur Facebook

Faites une requête sur l'URL d'une page Facebook publique avec un simple client HTTP et vous obtiendrez une réponse techniquement réussie et pratiquement inutile. Le corps est une coquille JavaScript : le contenu réel n'apparaît qu'après l'exécution des scripts de la page dans un navigateur et la récupération de données depuis des endpoints internes. Facebook est l'une des cibles les plus difficiles sur le web public pour exactement cette raison, et ce depuis des années.

En plus du rendu, Facebook signale rapidement le trafic automatisé. Les plages d'IPs datacenter, l'absence de comportement de navigateur et les modèles de requêtes répétitifs sont défis ou limités en débit bien avant que le contenu intéressant ne se charge jamais. Un scraper fonctionnel a donc besoin de deux choses dans la même requête : un vrai navigateur qui rend la page et une adresse IP que la plateforme lit comme un visiteur ordinaire. Vous pouvez construire cela vous-même avec un navigateur headless et un pool de proxies résidentiels rotatifs, mais maintenir cette pile en bonne santé représente l'essentiel du travail. La Crawling API regroupe les deux en un seul appel : vous lui envoyez une URL avec un token JavaScript, elle rend la page derrière une IP résidentielle de confiance et retourne du HTML fini que vous pouvez analyser. Si vous souhaitez le contexte plus approfondi, consultez notre guide sur comment crawler des sites web JavaScript.

Prérequis

Quelques éléments à mettre en place d'abord. Aucun ne prend longtemps.

Python de base. Vous devez être à l'aise pour exécuter un script et installer des packages avec pip. Si vous débutez dans l'analyse HTML, notre introduction sur comment scraper un site web avec Python couvre le côté extraction.

Python 3.8 ou version ultérieure. Confirmez avec python --version. Si vous ne l'avez pas, installez-le depuis python.org. L'ancien tutoriel utilisait Python 2 et urllib2 ; les deux sont en fin de vie, donc cette réécriture cible Python 3 moderne.

PyCharm. Téléchargez l'édition Community gratuite depuis JetBrains et installez-la. PyCharm est l'IDE que nous utilisons pour créer le projet, installer les packages et exécuter le script.

Un compte Crawlbase et un token JS. Inscrivez-vous, ouvrez votre tableau de bord et copiez votre token JavaScript (JS) depuis la page de documentation du compte. Traitez-le comme un mot de passe : il authentifie vos requêtes, donc ne le mettez pas dans le contrôle de version.

Configurer le projet dans PyCharm

C'est la partie PyCharm du tutoriel. Ouvrez PyCharm et choisissez Nouveau projet. Nommez-le quelque chose comme facebook-page-scraper, laissez PyCharm créer un environnement virtuel pour vous (par défaut) et confirmez que l'interpréteur est Python 3.8 ou version ultérieure. Cliquez sur Créer. Ensuite, faites un clic droit sur le projet dans le panneau Projet, choisissez Nouveau, Fichier Python et nommez-le scraper.py.

PyCharm intègre un terminal en bas de la fenêtre, déjà activé dans l'environnement virtuel de votre projet. Ouvrez-le et installez les deux bibliothèques dont le scraper a besoin.

python --version

pip install crawlbase beautifulsoup4

Deux dépendances font le travail : crawlbase est le client officiel pour la Crawling API, et beautifulsoup4 analyse le HTML retourné pour que vous puissiez extraire des champs individuels par sélecteur. Si vous préférez l'interface graphique, la fenêtre d'outils Packages Python de PyCharm installe les mêmes packages sans toucher au terminal.

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

Commencez par obtenir la page finie. Dans scraper.py, importez CrawlingAPI, initialisez-le avec votre token JS et demandez l'URL d'une page Facebook publique. Vérifiez le code de statut avant d'analyser pour que les échecs restent visibles plutôt que silencieux.

from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_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.facebook.com/MetaForBusiness"
    html = crawl(page_url)
    print(html[:500] if html else "No HTML returned")

Exécutez-le depuis PyCharm : faites un clic droit dans l'éditeur et choisissez Exécuter 'scraper', ou appuyez sur la flèche verte d'exécution dans la gouttière. Les deux options d'attente comptent pour une cible rendue côté client. ajax_wait indique à l'API d'attendre que le contenu asynchrone finisse de se charger, et page_wait attend un nombre fixe de millisecondes après le chargement pour que les éléments à rendu tardif apparaissent avant la capture de la page. Cinq secondes est un bon point de départ ; augmentez si des champs reviennent vides. L'exemple utilise une page professionnelle publique précisément parce qu'elle est publique et impersonnelle. Vous devriez voir un vrai balisage de page dans le panneau Exécuter, ce qui confirme que le rendu fonctionne avant d'écrire un seul sélecteur.

Étape 2 : Analyser les champs publics avec BeautifulSoup

Avec du HTML rendu en main, chargez-le dans BeautifulSoup et extrayez les champs publics. Facebook expose beaucoup de métadonnées stables dans les balises <meta> de la page, ce qui est bien plus fiable que de chasser des classes CSS profondément imbriquées et fréquemment renommées. Le nom public de la page et la description se trouvent dans des balises meta Open Graph standard ; le texte public visible des publications et les liens permanents des publications se trouvent dans le DOM rendu.

from bs4 import BeautifulSoup

def meta(soup, prop):
    el = soup.find("meta", attrs={"property": prop})
    return el["content"] if el and el.has_attr("content") else None

def scrape_page(html):
    soup = BeautifulSoup(html, "html.parser")

    page_name = meta(soup, "og:title")
    summary = meta(soup, "og:description")

    post_urls = []
    for a in soup.select("a[href*='/posts/']"):
        href = a["href"].split("?")[0]
        if href.startswith("/"):
            href = f"https://www.facebook.com{href}"
        if href not in post_urls:
            post_urls.append(href)

    return {
        "page_name": page_name,
        "summary": summary,
        "post_urls": post_urls,
    }

La balise og:title contient le nom public de la page, et og:description contient souvent une courte chaîne de résumé publique. Les liens des publications sont collectés depuis les ancres dont le href contient /posts/, dépouillés des chaînes de requête, normalisés en URLs absolues et dédupliqués, puisque le même lien permanent peut apparaître plus d'une fois dans le DOM rendu. Tout ici est un signal public au niveau de la page, pas un profil d'un individu quelconque.

Étape 3 : Extraire le texte public et les compteurs d'une publication

Une page de publication publique contient le même type de métadonnées Open Graph, plus le texte public visible de la publication dans le DOM rendu. Vous pouvez en extraire le texte public de la publication et tout compteur public que la page affiche, comme un nombre de réactions ou de partages. Lisez ces chiffres comme de simples agrégats, jamais comme un moyen d'énumérer les personnes derrière eux.

import re
from bs4 import BeautifulSoup

def scrape_post(html):
    soup = BeautifulSoup(html, "html.parser")

    desc = soup.find("meta", attrs={"property": "og:description"})
    post_text = desc["content"] if desc and desc.has_attr("content") else None

    counts = {}
    for label in ("reaction", "share"):
        node = soup.find("div", attrs={"aria-label": re.compile(label, re.I)})
        if node:
            digits = re.sub(r"[^\d]", "", node.get_text())
            counts[label] = int(digits) if digits else None

    return {
        "post_text": post_text,
        "counts": counts,
    }

Cela n'extrait que des champs publics non personnels : le texte visible de la publication et les compteurs agrégés que la page affiche. Il ne lit pas les commentaires individuels, les identifiants des commentateurs ni qui a réagi à la publication. Les formes d'aria-label et de sélecteur évoluent au fil du temps, donc réinspectez-les quand un champ cesse de se résoudre. Cette retenue est intentionnelle, et c'est aussi ce qui rend le travail défendable. Les compteurs sont des chiffres ; les personnes derrière eux ne sont pas à votre disposition pour être collectées.

Étape 4 : Assembler le tout

Maintenant reliez la récupération et l'analyse en un seul script exécutable qui lit une page publique, puis visite ses premières publications publiques. Collez ceci sur scraper.py et exécutez-le depuis PyCharm.

import re
import json
import time
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_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

def main():
    page_url = "https://www.facebook.com/MetaForBusiness"
    html = crawl(page_url)
    if not html:
        return

    page = scrape_page(html)
    records = []
    for post_url in page["post_urls"][:5]:
        post_html = crawl(post_url)
        if post_html:
            record = scrape_post(post_html)
            record["url"] = post_url
            records.append(record)
        time.sleep(3)

    output = {"page_name": page["page_name"], "posts": records}
    print(json.dumps(output, indent=2, ensure_ascii=False))

if __name__ == "__main__":
    main()

Le time.sleep(3) entre les requêtes n'est pas décoratif. Le rythme est le facteur le plus important pour qu'une exécution reste saine, et nous y reviendrons. Le slice [:5] garde la démo petite ; augmentez-le uniquement quand votre rythme et votre volume sont responsables. Gardez les fonctions scrape_page et scrape_post des étapes précédentes dans le même fichier pour que ce script s'exécute de bout en bout.

À quoi ressemble la sortie

Exécutez le script complet dans PyCharm et vous obtenez un enregistrement propre des champs publics, prêt à être écrit en JSON, CSV ou dans une base de données.

{
  "page_name": "Meta for Business",
  "posts": [
    {
      "post_text": "New tools to help businesses reach customers.",
      "counts": { "reaction": 1820, "share": 214 },
      "url": "https://www.facebook.com/MetaForBusiness/posts/example123"
    }
  ]
}

Mise à l'échelle et maintien du non-blocage

Pour lire plus d'une page, enveloppez la boucle de crawl sur une liste d'URLs de pages publiques et écrivez chaque résultat sur disque au fur et à mesure, pour qu'un échec à mi-chemin ne perde pas tout. Même avec le rendu géré par la Crawling API, Facebook surveille le trafic ayant la forme d'un scraper. Quelques habitudes maintiennent une exécution saine, et elles s'appliquent à toute cible difficile et fortement défendue.

• Rythmez vos requêtes. Marteler les pages dans une boucle serrée est la façon la plus rapide d'être throttlé. Ajoutez de vrais délais, comme dans le time.sleep ci-dessus, et résistez à l'envie de paralléliser agressivement.
• Appuyez-vous sur la rotation. Un pool d'IPs résidentielles répartit les requêtes sur de nombreuses adresses de vrais utilisateurs pour qu'aucune ne déclenche une limite de débit. La Crawling API gère cela pour vous ; si vous construisez votre propre pile, c'est la partie à bien faire.
• Lisez les codes de statut. Une exécution qui commence à retourner des défis ou des erreurs vous dit que le débit actuel ou le niveau d'IP n'est plus suffisant. Ralentissez plutôt que de pousser plus fort.
• Gardez le volume faible et les cibles variées. La recherche sur des données publiques ne nécessite pas de crawler tout l'historique d'une page. Échantillonnez ce dont vous avez besoin et arrêtez.

Pour le playbook plus large, consultez notre guide sur comment scraper des sites web sans être bloqué. Si un appel de rendu plus rotation géré ne suffit pas pour votre volume et que vous souhaitez une sortie de page auto-analysée, notre article approfondi sur la maîtrise de l'extraction de données Facebook avec la Crawling API couvre la voie de sortie structurée.

Est-il légal de scraper Facebook ?

C'est la section à lire avant d'écrire du code en production. Facebook est détenu par Meta, et les Conditions d'utilisation de Meta restreignent fortement l'accès automatisé et la collecte de données. Le scraping automatisé peut aller à l'encontre de ces conditions quelle que soit la prudence de vos outils, et rien du code ci-dessus ne change cela. Il ne fait que faire fonctionner la partie technique. Lisez les Conditions d'utilisation de Meta et Facebook et le robots.txt de Facebook, respectez les limites de débit de la plateforme et traitez-les tous comme la frontière de ce que vous collectez.

Les règles honnêtes et restrictives à respecter. Ne collectez que des données publiques provenant de pages publiques : le nom public de la page, le texte visible des publications publiques, les compteurs agrégés publics et les URLs de publications publiques que tout le monde peut voir sans se connecter. Ne scrapez jamais les groupes privés, les listes de membres de groupes, les profils personnels, le contenu protégé par une connexion, les messages directs, les commentaires liés à des individus nommés ou toutes les données personnelles des personnes. L'ancienne version de ce tutoriel pointait sur les groupes Facebook ; c'est exactement la surface que cette réécriture évite, car le contenu des groupes et les données des membres sont personnels et fréquemment derrière une barrière de confidentialité. Ne contournez jamais l'authentification, ne résolvez pas un défi de connexion par programmation et n'utilisez pas les identifiants de quelqu'un pour atteindre du contenu. Ce sont des lignes rouges, et ce guide reste délibérément du côté public de toutes.

Quand des données personnelles sont impliquées, la loi sur la confidentialité s'applique. Sous le RGPD dans l'UE et la CCPA en Californie, vous avez besoin d'une base légale pour traiter des données personnelles, et vous devez honorer les demandes de suppression et de désinscription. La position la plus sûre est d'éviter entièrement les données personnelles et de s'en tenir aux agrégats publics au niveau de la page, ce que fait le script ci-dessus. Pour tout usage réel ou commercial, le bon outil est l'API officielle Facebook Graph. Elle est conçue pour un accès sanctionné aux pages que vous possédez ou gérez, vous donne une structure garantie et vous maintient dans les conditions de Meta. Cet article est un tutoriel technique limité strictement aux pages publiques. Ce n'est pas un soutien à la collecte massive de données personnelles, et il ne couvre rien derrière une connexion. Si votre projet nécessite plus qu'un petit échantillon de champs publics, l'API Graph ou un accord de données formel est la bonne voie, pas un scraper plus élaboré.

Foire aux questions

Pourquoi une simple requête ne retourne-t-elle pas de données depuis Facebook ?

Parce que Facebook rend son contenu de page et de publication côté client avec JavaScript. Le HTML initial est une coquille qui ne se remplit qu'après l'exécution des scripts de la page dans un navigateur, donc une requête HTTP brute retourne un corps presque vide. Pour obtenir de vraies données publiques vous devez d'abord rendre la page, ce que le token JS de la Crawling API gère pour vous.

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

Le token JS. Le token normal récupère du HTML statique, qui sur Facebook est la même coquille vide qu'une simple requête retourne. Le token JS rend la page dans un vrai navigateur avant de remettre le HTML, de sorte que les champs publics sont présents quand BeautifulSoup les analyse.

Quelles données Facebook est-il sûr de scraper ?

Uniquement les données publiques des pages publiques : le nom public de la page, le texte visible des publications publiques, les compteurs agrégés publics en tant que chiffres et les URLs des publications publiques. Les groupes privés, les listes de membres de groupes, les profils personnels, le contenu protégé par une connexion, les messages directs et les identités des commentateurs individuels sont hors limites. Ce sont des données personnelles, et les collecter va à l'encontre des conditions de Meta et, dans de nombreux endroits, de la loi sur la confidentialité.

Pourquoi ce tutoriel couvre-t-il les pages plutôt que les groupes ?

Parce que les pages publiques sont la surface défendable. Le contenu des groupes, les listes de membres et les publications des membres individuels sont des données personnelles et se trouvent fréquemment derrière une barrière de confidentialité, même pour les groupes étiquetés publics. Les pages de marques et d'entreprises sont conçues pour être vues par n'importe qui sans se connecter, donc lire leur nom public de page, leur texte de publication et leurs compteurs agrégés reste dans les limites publiques.

Devrais-je utiliser l'API officielle Facebook Graph ou scraper le site ?

Pour tout usage réel, continu ou commercial, utilisez l'API officielle Facebook Graph. C'est la voie sanctionnée, elle donne une structure garantie et vous maintient dans les conditions de Meta. Scraper un petit échantillon de champs de pages publiques avec l'approche ici convient à une recherche légère sur des données publiques où aucun accès à l'API n'est en place, tant que vous respectez les conditions, robots.txt et les limites de débit.

Comment éviter d'être bloqué en scrapant Facebook ?

Gardez votre taux de requêtes par IP faible, ajoutez de vrais délais entre les requêtes, variez vos cibles plutôt que de crawler l'historique complet d'une page, et routez via des IPs résidentielles rotatives pour qu'aucune adresse unique ne déclenche une limite de débit. La Crawling API gère la rotation et un pool d'IPs de confiance pour vous. Surveillez les codes de statut et ralentissez dès que vous commencez à voir des défis.

IK

Ian Kalvin

Ingénieur support technique · Crawlbase

Ingénieur support technique chez Crawlbase, il écrit depuis la première ligne de ce qui casse réellement en production, sur les configurations de scraping et de proxys.

FQ

Farah Qadeer

Visualisation de contenu · Crawlbase

Spécialiste de la visualisation de contenu chez Crawlbase, elle transforme des sujets denses de proxys et de web scraping en visuels clairs et en guides pas à pas.