Facebook-Daten extrahierenöffentliche Seiten mit der Crawling API

Eine öffentliche Facebook-Unternehmensseite ist eine nützliche Signalquelle: Eine Marke veröffentlicht dort Beiträge, Kunden reagieren darauf, und die seitenweiten Metadaten (Name, Beschreibungstext, aktuelle öffentliche Beiträge sowie die öffentlichen Reaktions- und Kommentarzahlen) sind die Art von Daten, die Wettbewerbsanalysen, Content-Benchmarking und Markenmonitoring antreiben. Das Problem ist, dass Facebook fast alles clientseitig mit JavaScript und AJAX rendert und automatisierten Traffic aggressiv herausfordert, sodass eine einfache HTTP-Anfrage eine nahezu leere Loader-Hülle statt des Inhalts zurückgibt, den Sie im Browser sehen können.

Dieser Leitfaden zeigt, wie Sie Daten von einer öffentlichen Facebook-Seite mit JavaScript und Node.js über die Crawling API extrahieren. Sie bauen ein kleines, lauffähiges Skript, das eine gerenderte öffentliche Unternehmensseite abruft und seitenweite Felder extrahiert: den Seitennamen, den Text öffentlicher Beiträge und öffentliche Engagement-Zahlen. Der gesamte Walkthrough bleibt auf öffentliche Unternehmens- und Markenseiten beschränkt. Er berührt keine persönlichen Profile, privaten Gruppen, Kommentare, die mit identifizierbaren Personen verknüpft sind, oder irgendetwas hinter einem Login. Der Abschnitt zu Rechtmäßigkeit und Datenschutz steht aus gutem Grund nahe am Anfang des Artikels, also lesen Sie ihn, bevor Sie dies auf irgendetwas ausrichten.

Was Sie bauen werden

Ein Node.js-Skript, das die URL einer öffentlichen Facebook-Unternehmensseite nimmt, das gerenderte HTML über die Crawling API abruft und einen strukturierten Datensatz öffentlicher seitenweiter Daten zurückgibt. Wir verwenden eine bekannte Markenseite als durchgehendes Beispiel und extrahieren diese Felder:

• Seitenname der öffentliche Anzeigename der Unternehmens- oder Markenseite, zum Beispiel "Alibaba.com".
• Beitragstext der öffentliche Textkörper aktueller Beiträge, die die Seite selbst veröffentlicht hat.
• Reaktionszahl die öffentliche Gesamtzahl der Reaktionen auf jeden Beitrag.
• Kommentarzahl die öffentliche Anzahl der Kommentare zu jedem Beitrag, nur als aggregierte Zahl.
• Teilungsanzahl die öffentliche Anzahl der Teilungen zu jedem Beitrag.

Beachten Sie, was bewusst fehlt: keine Kommentatornamen, kein individueller Kommentartext, keine Profildetails, keine Follower-Listen. Das sind persönliche Daten und außerhalb des Geltungsbereichs. Wir aggregieren auf Seiten- und Beitragsebene und hören dort auf.

Warum eine einfache Anfrage auf Facebook fehlschlägt

Wenn Sie eine Facebook-Seiten-URL mit einem einfachen HTTP-Client abrufen, erhalten Sie eine technisch erfolgreiche, aber praktisch leere Antwort. Zwei Kräfte wirken gegen Sie.

Erstens baut Facebook die Seite im Browser auf. Der Seitenname, der About-Bereich und jeder Beitrag werden dynamisch über JavaScript und AJAX-Aufrufe geladen, nachdem das ursprüngliche Dokument ankommt, und weitere Beiträge erscheinen erst beim Scrollen. Die rohe URL abrufen und Sie erhalten größtenteils das Markup für Lade-Spinner, nicht den darum herum gerenderten Inhalt. Die echten Daten zu erfassen bedeutet, auf die Auflösung dieser AJAX-Aufrufe zu warten und das Scrollen zu simulieren, das zusätzliche Inhalte auslöst.

Zweitens verteidigt sich Facebook aktiv gegen automatisierten Traffic. Es beobachtet IP-Adressen, markiert Anfragemuster, die nicht wie ein echter Browser aussehen, und setzt strenge Rate-Limits durch, die zu vorübergehenden oder permanenten Sperren führen können. Eine Datacenter-IP, die Anfragen in einer engen Schleife feuert, ist genau die Form, die es zu stoppen gebaut wurde.

Ein funktionierender Ansatz benötigt also zwei Dinge in einer Anfrage: einen echten Browser, der die Seite rendert und auf ihren asynchronen Inhalt wartet, und eine IP, die die Plattform als gewöhnlichen Besucher wahrnimmt. Sie können das selbst mit einem Headless Browser plus einem Pool rotierender Residential Proxies zusammenstellen, aber diesen Stack gesund zu halten ist der größte Teil der Arbeit. Die Crawling API kombiniert beides in einem einzigen Aufruf: Sie senden die URL mit einem JavaScript-Token und den richtigen Warteoptionen, sie rendert die Seite hinter einer vertrauenswürdigen IP und gibt fertiges HTML oder geparste JSON-Daten zurück. Für Hintergrundinformationen zu rendering-lastigen Zielen, lesen Sie wie man JavaScript-Websites crawlt.

Voraussetzungen

Sie benötigen einige Dinge, bevor Sie Code schreiben. Keines davon dauert lange.

Grundlegende JavaScript- und Node.js-Kenntnisse. Sie sollten damit vertraut sein, ein Node-Skript zu schreiben, auszuführen und Pakete mit npm zu installieren. Wenn Sie neu darin sind, behandelt unser Leitfaden zum Erstellen eines Web-Scrapers mit Node.js die Grundlagen, die dieses Tutorial voraussetzt.

Node.js 16 oder neuer. Bestätigen Sie Ihre Version mit node --version. Wenn Sie es nicht haben, installieren Sie es von der Node.js-Website oder über einen Versionsmanager wie nvm.

Ein Crawlbase-Konto und JS-Token. Melden Sie sich für ein kostenloses Konto an, öffnen Sie Ihr Dashboard und kopieren Sie Ihr JavaScript (JS)-Token. Crawlbase gibt Ihnen bis zu 20.000 kostenlose Anfragen zum Start und Sie zahlen nur für erfolgreiche Anfragen. Facebook wird clientseitig gerendert, daher benötigen Sie hier das JavaScript-Token, nicht das normale. Behandeln Sie das Token wie ein Passwort und halten Sie es aus der Versionskontrolle heraus.

Das Projekt einrichten

Erstellen Sie einen Projektordner, initialisieren Sie ihn und installieren Sie den Crawlbase Node-Client.

node --version

mkdir facebook-page-scraper && cd facebook-page-scraper
npm init -y

npm install crawlbase

Das crawlbase-Paket ist der offizielle Node-Client für die Crawling API. Für die seitenweite Demo nutzen wir den in Crawlbase integrierten Facebook-Seiten-Scraper, der strukturiertes JSON zurückgibt, sodass wir für das Hauptbeispiel keinen separaten HTML-Parser benötigen.

Schritt 1: Die gerenderte öffentliche Seite abrufen

Beginnen Sie damit, die fertige Seite zu erhalten. Importieren Sie die CrawlingAPI-Klasse, initialisieren Sie sie mit Ihrem JS-Token und fordern Sie eine öffentliche Unternehmensseiten-URL an. Die Warteoptionen machen einen Facebook-Abruf überhaupt funktionsfähig, also sind sie hier wichtiger als auf einer statischen Website.

const { CrawlingAPI } = require('crawlbase');

const api = new CrawlingAPI({ token: 'YOUR_CRAWLBASE_TOKEN' });

// A PUBLIC business/brand Page only, never a personal profile or private group
const pageUrl = 'https://www.facebook.com/Alibaba.comGlobal/';

async function fetchPage(url) {
  const options = {
    format: 'json',
    ajax_wait: 'true',
    scroll: 'true',
    scroll_interval: 30,
  };
  const response = await api.get(url, options);
  if (response.statusCode === 200) {
    return JSON.parse(response.body);
  }
  console.error(`Request failed: ${response.statusCode}`);
  return null;
}

fetchPage(pageUrl).then((data) => {
  if (data) console.log(data.body.slice(0, 500));
});

Jede Option hat ihren Platz. format: 'json' fordert eine strukturierte Antwort an, damit das gerenderte HTML im body-Feld ankommt statt als rohes Dokument. ajax_wait: 'true' weist die API an zu warten, bis die AJAX-Aufrufe der Seite aufgelöst sind, was wesentlich ist, weil Facebook seinen echten Inhalt so lädt; überspringen Sie es und Sie erfassen Loader-Markup. scroll: 'true' simuliert einen scrollenden Benutzer, damit weitere Beiträge laden, und scroll_interval legt fest, wie viele Sekunden gescrollt wird (maximal 60). Führen Sie das Skript mit node script.js aus und Sie sollten echtes Seiten-Markup im Ausschnitt sehen, keine abgespeckte Hülle. Das bestätigt, dass das Rendering funktioniert, bevor Sie irgendetwas parsen.

Schritt 2: Strukturierte Seitendaten mit dem integrierten Scraper abrufen

Rohes HTML ist handhabbar, aber Sie müssten Selektoren gegen Facebooks häufig wechselndes Markup schreiben und warten. Die Crawling API wird mit einem integrierten facebook-page-Scraper ausgeliefert, der die öffentlichen Seitendaten bereits als JSON geparst zurückgibt, was das richtige Werkzeug für die seitenweite Extraktion ist. Sie aktivieren ihn mit dem scraper-Parameter.

const { CrawlingAPI } = require('crawlbase');

const api = new CrawlingAPI({ token: 'YOUR_CRAWLBASE_TOKEN' });
const pageUrl = 'https://www.facebook.com/Alibaba.comGlobal/';

async function scrapePage(url) {
  const options = {
    ajax_wait: 'true',
    scraper: 'facebook-page',
  };
  const response = await api.get(url, options);
  if (response.statusCode === 200) {
    return JSON.parse(response.body);
  }
  console.error(`Request failed: ${response.statusCode}`);
  return null;
}

scrapePage(pageUrl).then((data) => {
  if (data) console.log(JSON.stringify(data.body, null, 2));
});

Die Scraper-Antwort enthält seitenweite Felder wie den Seitennamen und den About-Text sowie ein Array der öffentlichen Beiträge, die die Seite veröffentlicht hat, wobei jeder Beitrag seinen Text und seine öffentlichen Reaktions-, Kommentar- und Teilungszahlen enthält. Da der Scraper das Parsing übernimmt, jagen Sie keine CSS-Selektoren gegen Markup, das sich wöchentlich ändert. Mehrere Scraper werden mit der Crawling API ausgeliefert; der facebook-page-Scraper ist speziell für öffentliche Seiten-Layouts gebaut.

Schritt 3: Nur die öffentlichen seitenweiten Felder extrahieren

Jetzt schränken Sie die Scraper-Ausgabe genau auf die öffentlichen Felder ein, die wir wollen, und lassen alles andere weg. Hier setzen wir den Geltungsbereich durch: Seitenname, Beitragstext und die drei aggregierten Zahlen pro Beitrag. Wir lesen oder speichern keine Kommentatoridentitäten oder individuellen Kommentartexte.

const { CrawlingAPI } = require('crawlbase');

const api = new CrawlingAPI({ token: 'YOUR_CRAWLBASE_TOKEN' });
const pageUrl = 'https://www.facebook.com/Alibaba.comGlobal/';

async function scrapePage(url) {
  const options = { ajax_wait: 'true', scraper: 'facebook-page' };
  const response = await api.get(url, options);
  if (response.statusCode !== 200) {
    console.error(`Request failed: ${response.statusCode}`);
    return null;
  }
  return JSON.parse(response.body).body;
}

function extractPublicData(page) {
  const posts = (page.posts || []).map((post) => ({
    text: post.text || null,
    reactionCount: post.reactionCounts || 0,
    commentCount: post.commentsCount || 0,
    shareCount: post.sharesCount || 0,
  }));

  return {
    pageName: page.pageName || page.title || null,
    postCount: posts.length,
    posts,
  };
}

async function main() {
  const page = await scrapePage(pageUrl);
  if (!page) return;
  const publicData = extractPublicData(page);
  console.log(JSON.stringify(publicData, null, 2));
}

main();

Die extractPublicData-Funktion übernimmt die Bereichseinschränkung. Sie behält den Seitennamen, den Beitragstext und die drei öffentlichen Zahlen pro Beitrag und liest nichts, das mit einer identifizierbaren Person verknüpft ist. Jedes Feld fällt auf einen sicheren Standard zurück, wenn der Scraper es weglässt, da nicht jeder Beitrag Teilungen oder Kommentare anzeigt. Feldnamen entsprechen den Antwortschlüsseln des Scrapers (pageName, reactionCounts, commentsCount, sharesCount); wenn ein Schlüssel leer zurückkommt, prüfen Sie die Live-Scraper-Ausgabe und passen Sie an, da sich Seiten-Layouts weiterentwickeln.

Wie die Ausgabe aussieht

Führen Sie das vollständige Skript mit node script.js aus und Sie erhalten ein kompaktes JSON-Objekt: den Seitennamen und eine Liste öffentlicher Beiträge mit ihrem Text und aggregierten Zahlen, bereit zum Schreiben in eine Datei oder Datenbank.

{
  "pageName": "Alibaba.com",
  "postCount": 2,
  "posts": [
    {
      "text": "Source smarter this season with verified suppliers.",
      "reactionCount": 1280,
      "commentCount": 94,
      "shareCount": 37
    },
    {
      "text": "New buyer guide: how to vet a manufacturer in 5 steps.",
      "reactionCount": 863,
      "commentCount": 51,
      "shareCount": 22
    }
  ]
}

Jeder Wert hier ist öffentlich und seitenebene. Es gibt keine Benutzernamen, keinen individuellen Kommentartext und keine Profildaten, was genau die Grenze ist, die dieses Tutorial hält.

Scrollen und AJAX-Inhalte handhaben

Zwei Parameter aus Schritt 1 machen Facebook handhabbar, und sie sind es wert, verstanden zu werden, bevor Sie dies in irgendeinem Volumen ausführen.

• ajax_wait. Facebook hydratisiert seinen Inhalt durch AJAX, nachdem das Dokument geladen wird. Ohne ajax_wait: 'true' erfassen Sie die Seite, bevor dieser Inhalt ankommt, und erhalten Loader-Markup. Mit ihr gibt die API das HTML erst zurück, sobald die asynchronen Aufrufe aufgelöst wurden.
• scroll und scroll_interval. Beiträge laden sich progressiv, wenn ein Benutzer scrollt. scroll: 'true' simuliert das, und scroll_interval steuert, wie viele Sekunden gescrollt wird, bis zu einem Maximum von 60. Ein längeres Intervall bringt mehr Beiträge auf Kosten einer langsameren Anfrage, also passen Sie es daran an, wie viele aktuelle Beiträge Sie tatsächlich benötigen.

Über Daten hinaus kann die Crawling API auch einen Screenshot der gerenderten Seite mit dem screenshot-Parameter zurückgeben und eine screenshot_url in der Antwort liefern, die nach etwa einer Stunde abläuft. Das ist nützlich zur visuellen Bestätigung, was erfasst wurde, aber die strukturierten Felder oben sind das, worauf Sie aufbauen.

Innerhalb der Rate-Limits bleiben

Auch wenn das Rendering gehandhabt wird, setzt Facebook strenge Rate-Limits durch, und deren Überschreitung riskiert vorübergehende oder permanente Sperren. Einige Gewohnheiten halten einen Lauf gesund und respektvoll.

• Drosseln Sie Ihre Anfragen. Schlagen Sie Seiten nicht in einer engen Schleife. Verteilen Sie Anfragen und halten Sie das Gesamtvolumen niedrig; das ist sowohl eine Höflichkeit als auch der schnellste Weg, um nicht markiert zu werden.
• Setzen Sie auf Rotation. Anfragen, die über einen Pool von Residential IPs verteilt werden, sind weit weniger wahrscheinlich, ein Limit auszulösen als eine einzelne Datacenter-Adresse. Die Crawling API übernimmt Rotation für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, in den Sie investieren sollten. Lesen Sie wie man Websites scrapt, ohne blockiert zu werden für das breitere Playbook.
• Beobachten Sie die Statuscodes. Wenn Antworten als Herausforderungen oder Fehler zurückkommen, ist das ein Signal zum Zurückgehen, kein Rauschen, durch das man drücken sollte.

Für größere, geplante Jobs über viele öffentliche Seiten hinweg passt eine asynchrone Queue besser als eine synchrone Schleife. Unser Leitfaden zum Extrahieren von Daten mit dem Crawlbase Crawler behandelt dieses Muster, bei dem Anfragen in eine Queue eingereiht und an einen Webhook geliefert werden, anstatt Ihr Skript zu blockieren.

Ist es legal, Facebook zu scrapen?

Lesen Sie diesen Abschnitt, bevor Sie irgendetwas ausführen. Facebooks Nutzungsbedingungen schränken die automatisierte Erfassung stark ein. Seine Bedingungen und seine Automated-Access-Richtlinien verbieten Scraping in weiten Teilen, und diese Einschränkung gilt unabhängig davon, wie sorgfältig Ihr Tooling ist. Kein Code in diesem Leitfaden setzt Facebooks Bedingungen außer Kraft; er macht nur den technischen Teil zum Funktionieren. Bevor Sie irgendetwas erfassen, lesen Sie Facebooks Nutzungsbedingungen, seine robots.txt und seine Entwickler- und Plattformrichtlinien, und behandeln Sie alle drei als Grenze für das, was Sie berühren dürfen.

Wenn Sie aus Forschungs- oder Bildungszwecken fortfahren, bleiben Sie strikt in einem engen öffentlichen Bereich. Erfassen Sie nur öffentliche Daten von öffentlichen Unternehmens- oder Markenseiten: den Seitennamen, den Text der Beiträge, die die Seite selbst veröffentlicht hat, und aggregierte öffentliche Engagement-Zahlen. Erfassen Sie keine persönlichen Daten. Das bedeutet: keine persönlichen Profile, keine privaten Gruppen, keine Follower- oder Mitgliedslisten, keine privaten Nachrichten und keine individuellen Kommentare, die mit identifizierbaren Personen verknüpft sind. Benutzernamen, Handles, Profildetails und von Benutzern verfasste Kommentare sind persönliche Daten, und das Erstellen eines Profils einer identifizierbaren Person daraus ist genau das, was zu vermeiden ist. Aggregieren Sie auf Seiten- und Beitragsebene, wie der obige Code es tut, und hören Sie dort auf.

Wo persönliche Daten überhaupt involviert sind, gilt das Datenschutzrecht. Unter der DSGVO und dem CCPA benötigen Sie eine Rechtsgrundlage zur Verarbeitung persönlicher Daten und müssen Lösch- und Opt-out-Anfragen erfüllen, was eine schwere Verpflichtung ist, die öffentliche-Seiten-Aggregatzahlen speziell umgehen sollen. Für jede produktive Verwendung ist der sanctionierte und weit sicherere Weg die offizielle Facebook Graph API, die autorisierten, ratenbegrenzten Zugang zu den Daten bietet, die ein Seiteninhaber oder eine App sehen darf, mit klaren angehängten Bedingungen. Bevorzugen Sie stark die Graph API. Verwenden Sie den Public-Data-Ansatz in diesem Leitfaden nur für kleine, bildungsbezogene, öffentliche-Seiten-Arbeit und niemals als Weg um einen Login, eine Datenschutzeinstellung oder die Bedingungen der Plattform herum.

Häufig gestellte Fragen

Warum gibt eine einfache Anfrage keinen echten Inhalt von einer Facebook-Seite zurück?

Weil Facebook seinen Inhalt clientseitig lädt. Seitenname, About-Bereich und Beiträge kommen über JavaScript und AJAX nach dem ursprünglichen Dokument an, und weitere Beiträge erscheinen erst beim Scrollen. Eine einfache HTTP-Anfrage erfasst die Seite, bevor das passiert, sodass Sie Loader-Markup statt Daten erhalten. Das Rendern der Seite und das Warten auf AJAX mit dem JS-Token der Crawling API ist das, was den tatsächlichen Inhalt zurückgibt.

Brauche ich das normale Token oder das JS-Token für Facebook?

Verwenden Sie das JavaScript (JS)-Token. Facebook baut seine Seiten mit clientseitigem Rendering, sodass das normale Token, das statisches HTML abruft, mit Loader-Markup und keinem bedeutungsvollen Inhalt zurückkommt. Das JS-Token rendert die Seite zuerst in einem echten Browser, was die Daten erscheinen lässt.

Welche öffentlichen Daten kann ich sicher von einer Facebook-Unternehmensseite extrahieren?

Beschränken Sie sich auf öffentliche seitenweite Felder: den Seitennamen, den Text der Beiträge, die die Seite selbst veröffentlicht hat, und aggregierte Engagement-Zahlen (Reaktionen, Kommentare, Teilungen) als Zahlen. Vermeiden Sie alles Persönliche, einschließlich Kommentatornamen, individuellen Kommentartext, Profildetails, Follower-Listen, private Gruppen und alles hinter einem Login. Aggregierte Zahlen auf Seiten- und Beitragsebene sind der vertretbare Geltungsbereich.

Kann ich persönliche Profile oder private Gruppen scrapen?

Nein, und dieser Leitfaden behandelt das nicht. Persönliche Profile, private Gruppen, Mitgliedslisten und private Nachrichten sind persönliche und nicht-öffentliche Daten, und deren Erfassung verstößt gegen Facebooks Bedingungen und das Datenschutzrecht. Dieser Walkthrough ist bewusst auf öffentliche Unternehmens- und Markenseiten beschränkt. Für sanctionierten Zugang zu mehr verwenden Sie die Facebook Graph API mit entsprechender Autorisierung.

Soll ich stattdessen die Facebook Graph API verwenden?

Für jede produktive oder kommerzielle Nutzung ja. Die Facebook Graph API ist der offizielle, autorisierte Weg mit Rate-Limits und klaren Bedingungen, und sie ist das richtige Werkzeug, wenn ein Seiteninhaber oder eine App zuverlässigen Zugang benötigt. Der Public-Data-Scraping-Ansatz hier ist nur für kleine, bildungsbezogene, öffentliche-Seiten-Arbeit geeignet, bei der kein API-Zugang besteht, und muss weiterhin Facebooks Bedingungen respektieren.

Wie vermeide ich Blockierungen oder Rate-Limiting?

Halten Sie das Anfragevolumen niedrig, drosseln Sie Anfragen statt in engen Schleifen zu arbeiten, und leiten Sie durch rotierende Residential IPs, sodass keine einzelne Adresse Facebooks Limits auslöst. Die Crawling API verwaltet Rotation und einen vertrauenswürdigen IP-Pool für Sie. Beobachten Sie die Statuscodes und gehen Sie zurück, sobald Sie Herausforderungen oder Fehler sehen, anstatt durchzudrücken.

HR

Hassan Rehan

Softwareentwickler · Crawlbase

Softwareentwickler bei Crawlbase, der praxisnahe Anleitungen zu rotierenden Proxys, Scraping und den praktischen Details schreibt, Proxys in echten Code einzubinden.