Stack Overflow-Fragen scrapenFragen, Tags und Stimmen

Stack Overflow ist eine der größten öffentlichen Wissensbasen für Entwickler, und jede Fragen-Listingseite enthält strukturierte Signale, die es wert sind, gesammelt zu werden: den Fragentitel, die zugeordneten Tags, die Stimmanzahl, die Anzahl der Antworten, wie viele Personen sie aufgerufen haben, und einen Link zum vollständigen Thread. Über einen Tag aggregiert verrät diese Datenmenge, welche Themen an Fahrt gewinnen, welche Probleme unbeantwortet bleiben und wie die Fragen zu einer Technologie sich im Laufe der Zeit entwickeln.

Dieser Leitfaden zeigt, wie man Stack Overflow-Fragen mit JavaScript und Node.js mithilfe von Cheerio scrapt. Es wird ein kleines, lauffähiges Scraper-Skript erstellt, das eine öffentliche Fragen-Listingseite über die Crawling API abruft, einen Datensatz pro Frage parst, die Paginierung über einen Tag abhandelt und die Ergebnisse als JSON und CSV exportiert. Der gesamte Walkthrough bleibt auf öffentliche Listing-Daten beschränkt, und der Abschnitt zur Rechtslage gegen Ende ist kein Boilerplate, also vor dem Einsatz auf echtem Volumen lesen.

Was du bauen wirst

Ein Node.js-Skript, das eine öffentliche Stack Overflow-Tag-URL nimmt, das HTML der Seite über die Crawling API abruft und für jede Frage im Listing einen strukturierten Datensatz extrahiert. Als laufendes Beispiel dient der javascript-Tag, und folgende Felder werden pro Frage abgerufen:

• Titel der Fragetext, beispielsweise "How do I return the response from an asynchronous call?".
• Tags die Liste der Tags, unter denen die Frage eingeordnet wurde, wie "javascript, async-await, promise".
• Stimmen die Nettostimmzahl, die auf der Zusammenfassungskarte angezeigt wird.
• Antworten die Anzahl der Antworten, mit "0 answers" wenn noch keine vorhanden sind.
• Aufrufe die auf der Karte angezeigte Aufrufzahl.
• Link die absolute URL zur einzelnen Frageseite.

Warum eine einfache Anfrage bei Stack Overflow zu kurz greift

Stack Overflow liefert einen Großteil des Listing-Markups serverseitig aus, daher kommt man mit einer einfachen HTTP-Anfrage hier weiter als bei einer stark clientseitig gerenderten Site. Das Problem ist die Konsistenz im Volumen. Stack Overflow beobachtet automatisierten Traffic, und eine Rechenzentrum-IP, die schnelle, repetitive Anfragen stellt, wird ratenbegrenzt oder erhält statt Fragen-Markup eine Challenge-Seite. Wenn das passiert, sieht der Parser ein unerwartetes Layout und der Lauf degradiert still.

Ein zuverlässiger Stack Overflow-Scraper benötigt daher eine IP, die die Site als echten Besucher liest, und bei Seiten, die auf Skripte angewiesen sind, einen Browser, der vor dem Parsen rendert. Das kann man selbst mit einem Pool aus rotierenden Residential-Proxys und einem Headless-Browser zusammenstellen, aber diesen Stack am Laufen zu halten, ist der Großteil der Arbeit. Die Crawling API bündelt beides in einem einzigen Aufruf: Man sendet ihr die URL, sie ruft sie hinter einer vertrauenswürdigen IP ab (und rendert die Seite, wenn man den JavaScript-Token übergibt) und gibt fertiges HTML zum Parsen zurück.

Voraussetzungen

Vor dem Schreiben von Code müssen einige Dinge bereitstehen. Keines davon dauert lange.

Node.js 16 oder neuer. Die Version mit node --version prüfen. Falls nicht vorhanden, von der Node.js-Website oder über einen Versionsmanager wie nvm installieren.

JavaScript- und Node.js-Grundkenntnisse. Man sollte in der Lage sein, ein Node-Skript zu schreiben, auszuführen und Pakete mit npm zu installieren. Wer neu in Node ist, findet in den offiziellen Docs und einem Einsteigerkurs das für dieses Tutorial nötige Niveau. Für einen ausführlicheren Walkthrough siehe unsere Anleitung zum Aufbau eines Web-Scrapers mit Node.js.

Ein Crawlbase-Konto und Token. Anmelden, das Dashboard öffnen und den normalen Anfragen-Token von der Account-Docs-Seite kopieren. Den Token wie ein Passwort behandeln: er authentifiziert die Anfragen, also aus der Versionskontrolle heraushalten.

Das Projekt einrichten

Einen Projektordner erstellen, initialisieren und die beiden Bibliotheken installieren, die der Scraper benötigt.

node --version

mkdir stackoverflow-scraper && cd stackoverflow-scraper
npm init -y

npm install crawlbase cheerio

Zwei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Node-Client für die Crawling API, und cheerio parst das zurückgegebene HTML mit einer jQuery-ähnlichen API, damit man einzelne Felder per CSS-Selektor extrahieren kann. Wer mit Selektoren noch nicht vertraut ist, findet im Primer zu XPath und CSS-Selektoren einen guten Begleiter.

Schritt 1: Die Fragen-Listingseite abrufen

Zunächst die Seite abrufen. Die Klasse CrawlingAPI importieren, sie mit dem Token initialisieren und die Tag-URL anfordern. Den Statuscode vor dem Parsen zu prüfen, hält Fehler laut statt still.

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

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

async function crawl(pageUrl) {
  const response = await api.get(pageUrl);
  if (response.statusCode === 200) {
    return response.body;
  }
  console.error(`Request failed: ${response.statusCode}`);
  return null;
}

const tagUrl = 'https://stackoverflow.com/questions/tagged/javascript';
crawl(tagUrl).then((html) => {
  console.log(html ? html.slice(0, 500) : 'No HTML returned');
});

Die Tag-URL folgt einem festen Muster: https://stackoverflow.com/questions/tagged/<tag>. javascript durch einen beliebigen Tag ersetzen, den man untersuchen möchte, z. B. python oder node.js. Das Skript mit node scraper.js ausführen, und es sollte echtes Fragen-Markup in den ersten 500 Zeichen zu sehen sein, keine Challenge-Seite. Das bestätigt, dass die Anfrage funktioniert, bevor ein einziger Selektor geschrieben wird.

Schritt 2: Jede Frage mit Cheerio parsen

Mit dem HTML in der Hand lädt man es in Cheerio und geht durch die Fragenkarten. Stack Overflow legt jede Frage in einem sich wiederholenden .js-post-summary-Block innerhalb von #questions aus, also werden alle Zusammenfassungen ausgewählt und dann Titel, Tags, Stimmen, Antworten, Aufrufe und Link aus dem Inneren gelesen. Die .replace(/\s+/g, ' ').trim()-Kette verdichtet die Leerzeichen, mit denen Stack Overflow sein Markup polstert, zu sauberem, einfach beabstandetem Text.

const cheerio = require('cheerio');

const clean = (text) => text.replace(/\s+/g, ' ').trim();

function parseQuestions(html) {
  const $ = cheerio.load(html);
  const questions = [];

  $('#questions .js-post-summary').each((_, element) => {
    const el = $(element);
    const title = clean(el.find('.s-post-summary--content-title').text());
    const link = el.find('.s-link').attr('href') || '';
    const votes = clean(
      el.find('.js-post-summary-stats .s-post-summary--stats-item:first-child').text()
    );
    const answers =
      clean(el.find('.js-post-summary-stats .has-answers').text()) || '0 answers';
    const views = clean(
      el.find('.js-post-summary-stats .s-post-summary--stats-item:last-child').text()
    );
    const tags = el
      .find('.js-post-tag-list-item')
      .map((__, tag) => clean($(tag).text()))
      .get()
      .filter(Boolean);

    questions.push({
      title,
      tags,
      votes,
      answers,
      views,
      link: link.includes('https://') ? link : `https://stackoverflow.com${link}`,
    });
  });

  return questions;
}

Einige Details sorgen dafür, dass dies der Seite treu bleibt. Stimmen und Aufrufe befinden sich beide unter .js-post-summary-stats als .s-post-summary--stats-item-Einträge, daher matcht der erste Stimmen und der letzte Aufrufe. Die Antwortanzahl trägt die Klasse .has-answers nur, wenn eine Frage Antworten hat, weshalb sie auf '0 answers' zurückfällt, wenn der Selektor leer zurückkommt. Tags kommen von jedem .js-post-tag-list-item, in ein Array gemappt, damit sie strukturiert bleiben. Der Link wird aus dem href des Ankers gelesen und absolut gemacht, da Stack Overflow einen relativen Pfad wie /questions/123/... zurückgibt.

Schritt 3: Alles zusammensetzen und exportieren

Jetzt das Abrufen und das Parsen in ein lauffähiges Skript einbinden und die Datensätze in JSON und CSV schreiben. JSON behält das verschachtelte Tag-Array für die programmgesteuerte Nutzung intakt; CSV flacht jeden Datensatz für Tabellenkalkulationen in eine Zeile, wobei die Tags mit einem Trennzeichen verbunden werden.

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

const api = new CrawlingAPI({ token: 'YOUR_CRAWLBASE_TOKEN' });
const clean = (text) => text.replace(/\s+/g, ' ').trim();

async function crawl(pageUrl) {
  const response = await api.get(pageUrl);
  if (response.statusCode === 200) return response.body;
  console.error(`Request failed: ${response.statusCode}`);
  return null;
}

function parseQuestions(html) {
  const $ = cheerio.load(html);
  const questions = [];
  $('#questions .js-post-summary').each((_, element) => {
    const el = $(element);
    const link = el.find('.s-link').attr('href') || '';
    questions.push({
      title: clean(el.find('.s-post-summary--content-title').text()),
      tags: el
        .find('.js-post-tag-list-item')
        .map((__, tag) => clean($(tag).text()))
        .get()
        .filter(Boolean),
      votes: clean(
        el.find('.js-post-summary-stats .s-post-summary--stats-item:first-child').text()
      ),
      answers:
        clean(el.find('.js-post-summary-stats .has-answers').text()) || '0 answers',
      views: clean(
        el.find('.js-post-summary-stats .s-post-summary--stats-item:last-child').text()
      ),
      link: link.includes('https://') ? link : `https://stackoverflow.com${link}`,
    });
  });
  return questions;
}

function toCsv(rows) {
  const headers = ['title', 'tags', 'votes', 'answers', 'views', 'link'];
  const escape = (value) => `"${String(value).replace(/"/g, '""')}"`;
  const lines = [headers.join(',')];
  for (const row of rows) {
    lines.push(
      [
        escape(row.title),
        escape(row.tags.join('|')),
        escape(row.votes),
        escape(row.answers),
        escape(row.views),
        escape(row.link),
      ].join(',')
    );
  }
  return lines.join('\n');
}

async function main() {
  const tagUrl = 'https://stackoverflow.com/questions/tagged/javascript';
  const html = await crawl(tagUrl);
  if (!html) return;
  const questions = parseQuestions(html);
  fs.writeFileSync('questions.json', JSON.stringify(questions, null, 2));
  fs.writeFileSync('questions.csv', toCsv(questions));
  console.log(`Saved ${questions.length} questions to questions.json and questions.csv`);
}

main();

Das vollständige Skript mit node scraper.js ausführen. Es ruft die Tag-Seite ab, parst jede Fragenkarte und schreibt sowohl questions.json als auch questions.csv in den Projektordner. Das CSV maskiert Anführungszeichen und verbindet das Tag-Array mit einem Pipe-Zeichen, damit eine Frage mit mehreren Tags in einer einzelnen Zelle bleibt.

Wie die Ausgabe aussieht

Die JSON-Datei enthält ein Objekt pro Frage, mit den Tags als strukturiertes Array, bereit zum Laden in ein Analyse-Skript oder eine Datenbank.

[
  {
    "title": "How do I return the response from an asynchronous call?",
    "tags": ["javascript", "ajax", "asynchronous", "promise"],
    "votes": "8632 votes",
    "answers": "42 answers",
    "views": "2.1m views",
    "link": "https://stackoverflow.com/questions/14220321/how-do-i-return-the-response-from-an-asynchronous-call"
  },
  {
    "title": "What does \"use strict\" do in JavaScript?",
    "tags": ["javascript", "syntax", "jslint", "use-strict"],
    "votes": "9201 votes",
    "answers": "32 answers",
    "views": "1.0m views",
    "link": "https://stackoverflow.com/questions/1335851/what-does-use-strict-do-in-javascript"
  }
]

Die CSV-Entsprechung derselben Daten besteht aus einer Header-Zeile plus einer Zeile pro Frage, wobei die Tags in eine einzige pipe-getrennte Zelle zusammengeführt werden.

title,tags,votes,answers,views,link
"How do I return the response from an asynchronous call?","javascript|ajax|asynchronous|promise","8632 votes","42 answers","2.1m views","https://stackoverflow.com/questions/14220321/..."
"What does ""use strict"" do in JavaScript?","javascript|syntax|jslint|use-strict","9201 votes","32 answers","1.0m views","https://stackoverflow.com/questions/1335851/..."

Tag-Seiten durchlaufen

Eine Seite mit Fragen ist eine Demo; ein echter Job durchläuft die Paginierung. Stack Overflow stellt die Seitennummer über den page-Query-Parameter bereit, damit man jede Seiten-URL in einer Schleife aufbauen, sie über die Crawling API abrufen, mit derselben Funktion parsen und die Zeilen sammeln kann. Da jede Listingseite dieselbe Kartenstruktur teilt, funktioniert der bereits geschriebene Parser auf allen ohne Änderungen.

async function scrapeTag(tag, totalPages) {
  const all = [];
  for (let page = 1; page <= totalPages; page++) {
    const url =
      `https://stackoverflow.com/questions/tagged/${tag}?tab=newest&page=${page}`;
    const html = await crawl(url);
    if (html) all.push(...parseQuestions(html));
  }
  return all;
}

scrapeTag('javascript', 3).then((rows) => {
  console.log(`Collected ${rows.length} questions`);
});

Um jede Zeile mit dem vollständigen Fragetext, der akzeptierten Antwort oder dem Kommentar-Thread anzureichern, den link aus jeder Karte nehmen und diese einzelne Frageseite über dieselbe crawl-Funktion abrufen, dann einen kleinen Parser für das Fragen-Layout schreiben. Das Muster ist identisch: abrufen, dann parsen. Mehr zu rendering-intensiven Zielen findet sich unter wie man JavaScript-Websites crawlt.

Entsperrt bleiben

Selbst mit übernommener vertrauenswürdiger IP beobachtet Stack Overflow Scraper-artigen Traffic. Einige Gewohnheiten halten einen Lauf gesund, und sie gelten für jede Site, die man in großem Umfang scrapt.

• Anfragen verteilen. Seiten in einer engen Schleife zu bombardieren, ist der schnellste Weg zum Drosseln. Anfragen aufteilen und Tags variieren statt einen Pfad mit voller Geschwindigkeit zu crawlen.
• Auf Rotation setzen. Ein Pool aus Residential-IPs verteilt Anfragen über viele echte Nutzeradressen, damit keine einzelne ein Rate-Limit auslöst. Die Crawling API übernimmt das; wer seinen eigenen Stack aufbaut, sollte hier besonders sorgfältig vorgehen.
• Statuscodes beachten. Ein Lauf, der beginnt, Challenges oder Fehler zurückzugeben, signalisiert, dass die aktuelle Rate oder IP-Stufe nicht mehr ausreicht. Das als Signal zum Zurückrudern, nicht als zu ignorierendes Rauschen behandeln.

Das umfassendere Playbook findet sich unter wie man Websites scrapt, ohne blockiert zu werden. Wer Parsing-Stacks jenseits von Cheerio vergleichen möchte, findet in der Übersicht der besten Open-Source-Scraping-Bibliotheken eine nützliche Karte. Wer Developer-Community-Daten breiter sammelt, findet denselben Fetch-then-Parse-Ansatz beim Scrapen von GitHub-Repositories und -Profilen.

Ist es legal, Stack Overflow zu scrapen?

Ob das Scrapen von Stack Overflow erlaubt ist, hängt von den Nutzungsbedingungen, der jeweiligen Rechtsordnung und dem Verwendungszweck der Daten ab. Stack Overflow, Teil des Stack Exchange-Netzwerks, veröffentlicht Netzwerk-Nutzungsbedingungen und eine Acceptable Use Policy, die automatisierten Zugriff einschränken, daher kann Scraping gegen diese Bedingungen verstoßen, unabhängig davon, wie sorgfältig das Tooling ist. Keiner der Codes hier ändert das; er lässt nur den technischen Teil funktionieren. Die Stack Exchange-Bedingungen und die robots.txt der Site lesen und beide als Grenze dafür behandeln, was und wie schnell man sammelt.

Bevor man überhaupt einen Scraper schreibt, sollte man prüfen, ob der sanktionierte Weg den Bedarf deckt, denn bei Stack Overflow ist das oft der Fall. Stack Exchange bietet eine offizielle Stack Exchange API an, die Fragen, Tags, Stimmen, Antworten und Aufrufe als sauberes JSON zurückgibt, und veröffentlicht periodische Daten-Dumps des gesamten öffentlichen Inhalts unter einer Creative-Commons-Lizenz. Für Recherche, Analyse oder alles im großen Umfang sind die API und die Daten-Dumps die richtigen Tools: strukturiert, ratenbegrenzt zu den vereinbarten Bedingungen, und sie halten einen auf der richtigen Seite der Netzwerkrichtlinien. Zu Scraping nur für kleine, öffentliche, einmalige Bedürfnisse greifen, die die API nicht abdeckt.

Die Arbeit auf öffentliche, nicht-personenbezogene Daten beschränken. Fragetitel, Tags und die aggregierten Stimm-, Antwort- und Aufrufzahlen, die in diesem Leitfaden verwendet werden, sind öffentliche Listing-Signale. Nutzerinhalte sind eine andere Sache: Benutzernamen, Reputation, Profildetails und die Texte, die Menschen schreiben, sind personenbezogene Daten, und das Weiterveröffentlichen der Inhalte einer Person oder die Verknüpfung mit ihrer Identität kann Verpflichtungen unter Datenschutzgesetzen wie der DSGVO und dem CCPA auslösen, einschließlich einer Rechtsgrundlage für die Verarbeitung und der Berücksichtigung von Löschanfragen. Dieser Leitfaden deckt nichts hinter einem Login, private Nachrichten oder den Aufbau von Profilen identifizierbarer Nutzer ab. Wo möglich aggregieren und die offizielle API oder Daten-Dumps bevorzugen, wenn das Projekt Daten auf Nutzerebene berührt.

Häufig gestellte Fragen

Brauche ich den normalen Token oder den JS-Token für Stack Overflow?

Der normale Token reicht für die Fragen-Listingseiten in diesem Leitfaden, da Stack Overflow dieses Markup serverseitig ausliefert. Den JS-Token einsetzen, wenn eine Zielseite ihren Inhalt clientseitig lädt und ohne Felder zurückkommt. Hier mit dem normalen Token beginnen und nur wechseln, wenn eine gescrapte Seite leere Selektoren zurückgibt.

Welche Felder kann ich aus einem Stack Overflow-Fragen-Listing extrahieren?

Aus jeder Zusammenfassungskarte kann man den Fragentitel, die zugeordneten Tags, die Nettostimmzahl, die Anzahl der Antworten, die Aufrufzahl und den Link zur vollständigen Frage abrufen. Dieser Leitfaden ordnet jeden dieser Werte einem CSS-Selektor zu und stellt sie zu einem Datensatz pro Frage zusammen, exportiert nach JSON und CSV.

Meine Selektoren geben leere Werte zurück. Was hat sich geändert?

Mit großer Wahrscheinlichkeit das Markup von Stack Overflow. Die js-post-summary-Karten-Klassen, der s-post-summary--content-title-Titel-Wrapper und die js-post-tag-list-item-Tag-Marker können sich ohne Vorankündigung ändern. Eine Live-Seite in den Browser-DevTools erneut untersuchen und die Selektoren aktualisieren. Periodische Selektor-Wartung ist bei jedem produktiven Scraper normal.

Soll ich die Stack Exchange API nutzen oder die Site scrapen?

Wenn man Volumen, garantierte Struktur oder den vollständigen öffentlichen Inhalt benötigt, die offizielle Stack Exchange API oder ihre Creative-Commons-Daten-Dumps verwenden. Sie sind dafür gebaut und halten einen auf der richtigen Seite der Netzwerkbedingungen. Das Scrapen öffentlicher Listingseiten mit dem Ansatz in diesem Leitfaden eignet sich für kleine, öffentliche Datenbedürfnisse, die die API nicht abdeckt, solange ToS, robots.txt und Rate-Limits respektiert werden.

Kann ich Nutzerprofile oder Reputation von Stack Overflow scrapen?

Dieser Leitfaden tut das bewusst nicht. Benutzernamen, Reputation und die Inhalte, die Menschen schreiben, sind personenbezogene Daten, und der Aufbau von Profilen identifizierbarer Nutzer kann Verpflichtungen unter Datenschutzgesetzen wie der DSGVO und dem CCPA auslösen. Bei öffentlichen Listing-Signalen wie Titeln, Tags und aggregierten Zählungen bleiben, wo möglich aggregieren und die offizielle API einsetzen, wenn das Projekt genuinen Bedarf an Daten auf Nutzerebene hat.

Wie vermeidet man Blockierungen beim Scrapen von Stack Overflow?

Die Anfragerate pro IP niedrig halten, Tags variieren statt einen Pfad in der Schleife zu durchlaufen, und über rotierende Residential-IPs leiten, damit keine einzelne Adresse ein Rate-Limit auslöst. Die Crawling API verwaltet Rotation und einen vertrauenswürdigen IP-Pool; wer seinen eigenen Stack aufbaut, sollte dort investieren. Die Statuscodes beobachten und zurückrudern, wenn Challenges auftreten.

MA

Muhammad Atif

Senior Full Stack Developer · Crawlbase

Senior Full Stack Developer bei Crawlbase, der die Plattform aufbaut und über Scraping-Architektur, Proxys und Datenpipelines schreibt.

IK

Ian Kalvin

Technical Support Engineer · Crawlbase

Technical Support Engineer bei Crawlbase, der von der Front darüber schreibt, was beim Scraping und bei Proxy-Setups im Produktivbetrieb tatsächlich kaputtgeht.