Goodreads-Bewertungen scrapenBücher, Bewertungen und Rezensionen

Goodreads ist einer der größten öffentlichen Buchkataloge im Web, und jede öffentliche Buchseite trägt genau das Lesersignal, das Trendanalysen, Empfehlungsmaschinen und Marktforschung antreibt: einen Titel, einen Autor, eine Durchschnittsbewertung, wie viele Personen bewertet haben, und den Text öffentlicher Rezensionen. Das Problem: Goodreads rendert einen Großteil dieser Inhalte clientseitig und lädt Rezensionen asynchron, sodass eine einfache HTTP-Anfrage nur eine dünne Hülle statt der gewünschten Bewertungen und Rezensionen liefert.

Diese Anleitung zeigt, wie man Goodreads-Bewertungen und Rezensionen mit Python zuverlässig scraped. Sie bauen einen kleinen, lauffähigen Scraper, der eine gerenderte Buchseite über die Crawling API abruft, die gewünschten Felder mit BeautifulSoup parst und einen sauberen strukturierten Datensatz ausgibt. Die gesamte Anleitung beschränkt sich auf öffentliche Buch- und Rezensionsdaten, und der Legalitätsabschnitt gegen Ende ist kein Standardtext, also lesen Sie ihn, bevor Sie das auf beliebiges Volumen anwenden.

Was Sie bauen werden

Ein Python-Skript, das eine öffentliche Goodreads-Buch-URL entgegennimmt, das gerenderte HTML über die Crawling API abruft und einen strukturierten Datensatz des Buches und seiner sichtbaren Rezensionen extrahiert. Als durchgehendes Beispiel verwenden wir einen bekannten öffentlichen Titel und lesen folgende Felder aus:

• Buchtitel der Name des Buches, zum Beispiel "The Great Gatsby".
• Autor der auf der Buchseite genannte Autor.
• Durchschnittsbewertung der von Goodreads aus Nutzerbewertungen berechnete Gesamtscore.
• Bewertungsanzahl wie viele Personen das Buch bewertet haben.
• Rezensionen der öffentliche Rezensionstext auf der Seite mit dem Anzeigenamen des Rezensenten.

Warum eine einfache Anfrage auf Goodreads scheitert

Wenn Sie eine Goodreads-Buch-URL mit einem einfachen HTTP-Client anfragen, erhalten Sie eine 200-Antwort und fast keinen Rezensionsinhalt im Body. Zwei Dinge wirken gegen Sie. Erstens rendert Goodreads einen Großteil der Bewertungs- und Rezensionsbereiche im Browser mit JavaScript, sodass das anfängliche HTML eine Hülle ist, die sich erst füllt, nachdem die Seitenskripte ausgeführt wurden. Zweitens lädt die Rezensionsliste asynchron und wächst hinter Interaktionen, sodass selbst ein teilweises Rendering die gewünschten Daten verpassen kann, wenn die Seite nicht genug Zeit zum Stabilisieren bekommt.

Ein funktionsfähiger Goodreads-Scraper braucht also zwei Dinge in einer Anfrage: einen Browser, der die Seite tatsächlich rendert, und eine IP, die die Plattform als echten Besucher liest. Sie können das selbst mit einem Headless-Browser und einem Pool aus rotierenden Residential-Proxys zusammenstellen, aber diese zu verknüpfen und in Schuss zu halten, ist der größte Teil der Arbeit. Die Crawling API bündelt beides in einem einzigen Aufruf: Sie senden ihr die URL mit einem JavaScript-Token, sie rendert die Seite hinter einer vertrauenswürdigen IP und gibt fertiges HTML zum Parsen zurück.

Voraussetzungen

Vor dem Schreiben von Code müssen einige Dinge vorhanden sein. Keines davon nimmt viel Zeit in Anspruch.

Grundlegendes Python. Sie sollten in der Lage sein, ein Python-Skript zu schreiben und auszuführen sowie Pakete mit pip zu installieren. Wer neu im Parsen von HTML ist: Unser Leitfaden zu BeautifulSoup in Python deckt die Grundlagen der Selektoren ab, auf die dieses Tutorial aufbaut.

Python 3.8 oder höher. Bestätigen Sie Ihre Version mit python --version. Falls nicht installiert, installieren Sie es von python.org oder über eine Distribution wie Anaconda.

Ein Crawlbase-Konto und JS-Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihren JavaScript-Token (JS-Token) von der Konto-Dokumentationsseite. Behandeln Sie den Token wie ein Passwort: Er authentifiziert Ihre Anfragen, also bewahren Sie ihn aus der Versionskontrolle heraus.

Projekt einrichten

Erstellen Sie eine virtuelle Umgebung, damit Projektabhängigkeiten isoliert bleiben, und installieren Sie dann die zwei Bibliotheken, die der Scraper benötigt.

python --version

python -m venv goodreads_env
source goodreads_env/bin/activate

pip install crawlbase beautifulsoup4

Unter Windows aktivieren Sie die Umgebung mit goodreads_env\Scripts\activate statt der source-Zeile. Zwei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Client für die Crawling API, und beautifulsoup4 parst das zurückgegebene HTML, sodass Sie einzelne Felder per CSS-Selektor auslesen können.

Schritt 1: Die gerenderte Buchseite abrufen

Beginnen Sie damit, die fertige Seite zu erhalten. Importieren Sie die CrawlingAPI-Klasse, initialisieren Sie sie mit Ihrem JS-Token und fordern Sie die Buch-URL an. Die Statusprüfung vor dem Parsen lässt Fehler laut statt still auftreten.

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.goodreads.com/book/show/4671.The_Great_Gatsby"
    html = crawl(page_url)
    print(html[:500] if html else "No HTML returned")

Die zwei Wait-Optionen sind bei einem clientseitig gerenderten Ziel wie diesem wichtig. ajax_wait weist die API an, auf das Laden asynchroner Inhalte zu warten, und page_wait hält für eine feste Anzahl von Millisekunden nach dem Laden an, sodass spät rendernde Elemente erscheinen, bevor die Seite erfasst wird. Fünf Sekunden sind ein vernünftiger Ausgangswert; erhöhen Sie ihn, wenn die Rezensionsfelder leer zurückkommen. Führen Sie das Skript mit python scraper.py aus und Sie sollten echtes Buch-Markup sehen, nicht die dünne Hülle, die eine einfache Anfrage zurückgibt. Das bestätigt, dass das Rendering funktioniert, bevor Sie einen einzigen Selektor schreiben.

Schritt 2: Die Buchfelder mit BeautifulSoup parsen

Mit gerendertem HTML laden Sie es in BeautifulSoup und lesen jedes Feld per Selektor aus. Eine Goodreads-Buchseite legt die Kerndetails in einer vorhersagbaren Struktur ab, sodass Sie Titel, Autor, Durchschnittsbewertung und Bewertungsanzahl auf einzelne Selektoren abbilden und dann die Rezensionskarten durchlaufen können, um den öffentlichen Rezensionstext zu sammeln. Hilfsfunktionen, die bei einem fehlenden Element None zurückgeben, verhindern, dass ein fehlender Wert den gesamten Lauf zum Absturz bringt.

from bs4 import BeautifulSoup

def text_of(node, selector):
    el = node.select_one(selector)
    return el.get_text(strip=True) if el else None

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

    rating_el = soup.select_one("div.RatingStatistics span.RatingStars")
    average_rating = rating_el["aria-label"] if rating_el else None

    reviews = []
    for card in soup.select("div.ReviewsList article.ReviewCard"):
        reviews.append({
            "user": text_of(card, 'div[data-testid="name"]'),
            "review": text_of(card, "section.ReviewText span.Formatted"),
        })

    return {
        "title": text_of(soup, 'h1.H1Title a[data-testid="title"]'),
        "author": text_of(soup, "span.ContributorLink__name"),
        "average_rating": average_rating,
        "ratings_count": text_of(soup, 'span[data-testid="ratingsCount"]'),
        "reviews": reviews,
    }

Der text_of-Helfer macht zwei nützliche Dinge auf einmal: Er fragt ein einzelnes Element innerhalb eines gegebenen Knotens ab und gibt None zurück, wenn das Element fehlt, anstatt bei einem .get_text()-Aufruf gegen nichts zu werfen. Den Knoten explizit zu übergeben ist hier wichtig, da jede Rezensionskarte ihren eigenen Bereich hat und Sie den Rezensenten-Namen und den Rezensionstext aus dieser Karte lesen möchten, nicht aus dem ersten Treffer auf der gesamten Seite. Die Durchschnittsbewertung wird aus dem aria-label-Attribut statt aus dem sichtbaren Text gelesen, daher wird sie separat behandelt.

Schritt 3: Weitere Rezensionen laden

Das erste Rendering zeigt nur einen ersten Ausschnitt der Rezensionen. Goodreads enthüllt den Rest hinter einer Schaltfläche "Weitere Rezensionen anzeigen" statt eines nummerierten Seitenumbruchs, sodass Sie die Seite auf diese Schaltfläche klicken lassen müssen, bevor sie erfasst wird, um tiefere Rezensionen zu erreichen. Die Crawling API bietet eine css_click_selector-Option, die während des Renderings auf ein übereinstimmendes Element klickt, wodurch Sie in derselben Anfrage einen größeren Rezensionssatz abrufen können.

def crawl_with_more_reviews(page_url):
    options = {
        "ajax_wait": "true",
        "page_wait": 5000,
        "css_click_selector": 'button:has(span[data-testid="loadMore"])',
    }
    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

Der Selektor trifft die Schaltfläche, die das Lade-Mehr-Steuerelement umschließt. Ein einmaliger Klick darauf erweitert die sichtbare Rezensionsliste, bevor das HTML erfasst wird, sodass derselbe scrape_book-Parser dann mehr Karten sieht, ohne dass eine Änderung notwendig ist. Wenn Sie noch mehr Rezensionen als ein Klick liefert benötigen, erhöhen Sie page_wait, um der erweiterten Liste Zeit zum Rendern zu geben. Hintergründe dazu, warum durch Interaktion gesteuerte Inhalte sich so verhalten, finden Sie in unserem Leitfaden zum Crawlen von JavaScript-Websites.

Schritt 4: Alles zusammensetzen

Verbinden Sie jetzt Abruf und Parse zu einem lauffähigen Skript. Rufen Sie das gerenderte HTML mit dem Lade-Mehr-Klick ab, übergeben Sie es an den Parser und schreiben Sie den strukturierten Datensatz in eine JSON-Datei.

import json
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

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

def crawl(page_url):
    options = {
        "ajax_wait": "true",
        "page_wait": 5000,
        "css_click_selector": 'button:has(span[data-testid="loadMore"])',
    }
    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 text_of(node, selector):
    el = node.select_one(selector)
    return el.get_text(strip=True) if el else None

def scrape_book(html):
    soup = BeautifulSoup(html, "html.parser")
    rating_el = soup.select_one("div.RatingStatistics span.RatingStars")
    average_rating = rating_el["aria-label"] if rating_el else None

    reviews = []
    for card in soup.select("div.ReviewsList article.ReviewCard"):
        reviews.append({
            "user": text_of(card, 'div[data-testid="name"]'),
            "review": text_of(card, "section.ReviewText span.Formatted"),
        })

    return {
        "title": text_of(soup, 'h1.H1Title a[data-testid="title"]'),
        "author": text_of(soup, "span.ContributorLink__name"),
        "average_rating": average_rating,
        "ratings_count": text_of(soup, 'span[data-testid="ratingsCount"]'),
        "reviews": reviews,
    }

def main():
    page_url = "https://www.goodreads.com/book/show/4671.The_Great_Gatsby"
    html = crawl(page_url)
    if not html:
        return
    data = scrape_book(html)
    with open("goodreads_book.json", "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)
    print(json.dumps(data, indent=2, ensure_ascii=False)[:600])

if __name__ == "__main__":
    main()

Wie die Ausgabe aussieht

Führen Sie das vollständige Skript mit python scraper.py aus und Sie erhalten einen sauberen strukturierten Datensatz für das Buch, bereit zum Schreiben in JSON, CSV oder eine Datenbank.

{
  "title": "The Great Gatsby",
  "author": "F. Scott Fitzgerald",
  "average_rating": "Rating 3.93 out of 5",
  "ratings_count": "5,432,109 ratings",
  "reviews": [
    {
      "user": "Alex",
      "review": "Charms you with some of the most elegant English prose ever published."
    },
    {
      "user": "Inge",
      "review": "There was one thing I really liked about The Great Gatsby. It was short."
    }
  ]
}

Auf viele Bücher skalieren

Ein Buch ist eine Demo; ein echter Auftrag läuft über eine Liste von Titeln. Die Struktur bleibt dieselbe: Halten Sie eine Liste von Buch-URLs, rufen Sie jede über die Crawling API ab, parsen Sie sie mit derselben Funktion und sammeln Sie die Zeilen. Da jede Buchseite dieselbe Struktur teilt, funktioniert der bereits geschriebene Parser über alle hinweg ohne Änderungen.

import time

books = [
    "https://www.goodreads.com/book/show/4671.The_Great_Gatsby",
    "https://www.goodreads.com/book/show/5470.1984",
]

results = []
for url in books:
    html = crawl(url)
    if html:
        results.append(scrape_book(html))
    time.sleep(2)

with open("goodreads_books.json", "w", encoding="utf-8") as f:
    json.dump(results, f, ensure_ascii=False, indent=2)

Das time.sleep(2) zwischen Anfragen drosselt die Schleife, sodass Sie Buchseiten nicht direkt hintereinander abfeuern. Um Buch-URLs in großem Maßstab zu sammeln, können Sie Goodreads-öffentliche Listen- und Regalseiten mit demselben Abruf-und-Parse-Muster scrapen, die Buchlinks sammeln und dann jede besuchen. Halten Sie das Volumen dabei vernünftig und respektieren Sie die unten beschriebenen Rate-Limits.

Geblockt bleiben verhindern

Auch wenn das Rendering gehandhabt wird, beobachtet Goodreads scrapertypischen Traffic. Einige Gewohnheiten halten einen Lauf gesund, und sie gelten für jedes große öffentliche Ziel.

• Dosieren Sie Ihre Anfragen. Buchseiten in einer engen Schleife zu hämmern ist der schnellste Weg, gedrosselt zu werden. Verteilen Sie Anfragen und variieren Sie Ihre Ziele statt einen Pfad mit voller Geschwindigkeit zu crawlen.
• Setzen Sie auf Rotation. Ein Pool aus Residential-IPs verteilt Anfragen über viele echte Nutzer-Adressen, sodass keine einzelne ein Rate-Limit auslöst. Die Crawling API erledigt das für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, den Sie richtig machen müssen.
• Lesen Sie die Statuscodes. Ein Lauf, der Herausforderungen oder Nicht-200-Antworten zurückzugeben beginnt, zeigt Ihnen, dass die aktuelle Rate oder IP-Stufe nicht mehr ausreicht. Behandeln Sie das als Signal zum Zurückrudern, nicht als Rauschen zum Ignorieren.

Das umfassende Playbook finden Sie unter Wie man Websites scraped, ohne geblockt zu werden und im tieferen Tauchgang zu Wie man CAPTCHAs beim Web-Scraping umgeht. Wenn Sie Ihren eigenen Traffic lieber durch einen rotierenden Pool leiten statt die verwaltete API zu verwenden, bietet der Smart AI Proxy (auch als AI Proxy bekannt) dieselbe Residential-IP-Rotation als Drop-in-Proxy-Endpunkt.

Ist das Scrapen von Goodreads legal?

Ob das Scrapen von Goodreads erlaubt ist, hängt von den Nutzungsbedingungen von Goodreads und Amazon, Ihrer Jurisdiktion und dem Verwendungszweck der Daten ab. Goodreads ist ein Amazon-eigenes Produkt, und seine Bedingungen schränken den automatisierten Zugriff ein, sodass Scraping unabhängig von der Sorgfalt Ihrer Werkzeuge gegen diese Bedingungen verstoßen kann. Keiner der hier gezeigten Code ändert das; er lässt lediglich den technischen Teil funktionieren. Lesen Sie die Goodreads-Nutzungsbedingungen und seine robots.txt, und behandeln Sie beides als Grenze dessen, was Sie sammeln.

Einige Linien, an denen Sie festhalten sollten. Sammeln Sie nur öffentliche Buch- und Rezensionsdaten: Titel, Autor, Durchschnittsbewertung, Bewertungsanzahl und den Rezensionstext, den jeder ohne Konto sehen kann. Respektieren Sie Goodreads' angegebene Rate-Erwartungen und halten Sie Ihr Anfragevolumen niedrig genug, dass Sie seine Server nicht belasten. Vermeiden Sie persönliche Daten von Rezensenten über das hinaus, was öffentlich auf der Seite angezeigt wird, und erstellen Sie keine Profile identifizierbarer Personen daraus. Wenn Sie die Daten kommerziell weiterverwenden möchten, holen Sie eine Genehmigung oder eine lizenzierte Quelle ein, statt anzunehmen, Schweigen sei Zustimmung.

Ein praktischer Hinweis speziell zu Goodreads: Die offizielle Goodreads-API ist faktisch veraltet und für neue Schlüssel geschlossen, sodass es kein aktives First-Party-Feed gibt, auf das man zurückfallen könnte, wie es manche Plattformen anbieten. Das lässt zwei realistische Optionen für öffentliche Daten: öffentliche Buchseiten zu scrapen wie hier gezeigt, oder die Daten über einen lizenzierten Anbieter zu beziehen. Diese Anleitung beschränkt sich bewusst auf öffentliche Buchseiteninhalte, weil das die Linie ist, die die Arbeit vertretbar hält. Sie deckt nichts hinter einem Login, private Regale oder Kontodaten eines Nutzers, persönliche Daten von Rezensenten über die öffentliche Anzeige hinaus, oder Versuche zur Authentifizierungsumgehung ab. Wenn Ihr Projekt mehr als öffentliche Buch- und Rezensionsdaten benötigt, ist eine lizenzierte Datenquelle der richtige Weg, kein ausgefeilterer Scraper.

Häufig gestellte Fragen

Warum gibt eine einfache Anfrage keine Rezensionen von Goodreads zurück?

Weil Goodreads seinen Bewertungs- und Rezensionsinhalt clientseitig mit JavaScript rendert und die Rezensionsliste asynchron lädt. Das anfängliche HTML ist eine Hülle, die sich erst füllt, nachdem die Seitenskripte in einem Browser ausgeführt wurden, also gibt eine rohe HTTP-Anfrage den Status 200 zurück, aber die Rezensionsfelder sind leer. Um echte Daten zu erhalten, müssen Sie die Seite zuerst rendern, was der JS-Token der Crawling API für Sie übernimmt.

Benötige ich den normalen Token oder den JS-Token für Goodreads?

Den JS-Token. Der normale Token ruft statisches HTML ab, das auf Goodreads dieselbe dünne Hülle ist, die eine einfache Anfrage zurückgibt. Der JS-Token rendert die Seite in einem echten Browser, bevor er das HTML zurückgibt, sodass Bewertungen und Rezensionstext vorhanden sind, wenn BeautifulSoup sie parst.

Wie lade ich mehr als die ersten paar Rezensionen?

Goodreads enthüllt zusätzliche Rezensionen hinter einer Schaltfläche "Weitere Rezensionen anzeigen" statt eines nummerierten Seitenumbruchs. Übergeben Sie eine css_click_selector-Option an die Crawling API, die diese Schaltfläche trifft, und sie wird während des Renderings geklickt, sodass das erfasste HTML die erweiterte Liste enthält. Erhöhen Sie page_wait, wenn die neu enthüllten Rezensionen vor der Erfassung Zeit zum Rendern brauchen.

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

Mit ziemlicher Sicherheit Goodreads' Markup. Seine RatingStars- und ReviewCard-Klassen, data-testid-Attribute und Bereichs-Wrapper ändern sich ohne Vorankündigung, sodass Selektoren, die letzten Monat funktionierten, jetzt brechen können. Inspizieren Sie eine Live-Buchseite in den Entwicklertools Ihres Browsers und aktualisieren Sie die Selektoren. Regelmäßige Selektor-Wartung ist bei jedem Produktions-Scraper normal.

Kann ich stattdessen die offizielle Goodreads-API verwenden?

In der Praxis nein. Die offizielle Goodreads-API ist faktisch veraltet und für neue Schlüssel geschlossen, sodass es kein aktives First-Party-Feed gibt, auf das man sich verlassen könnte. Für öffentliche Daten sind die realistischen Optionen das Scrapen öffentlicher Buchseiten mit dem Ansatz in dieser Anleitung oder das Beziehen der Daten über einen lizenzierten Anbieter. Respektieren Sie in jedem Fall die Nutzungsbedingungen, robots.txt und Rate-Limits.

Wie vermeide ich es, beim Scrapen von Goodreads geblockt zu werden?

Halten Sie Ihre Anfragerate je IP niedrig, variieren Sie Ihre Ziele statt einen Pfad zu loopen, und routen Sie durch rotierende Residential-IPs, sodass keine einzelne Adresse ein Rate-Limit auslöst. Die Crawling API verwaltet Rotation und einen vertrauenswürdigen IP-Pool für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, in den Sie investieren sollten. Beobachten Sie die Statuscodes und rudere zurück, wenn Sie beginnen, Herausforderungen zu sehen.

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.