Yelp mit Python scrapenUnternehmenseinträge und Bewertungen

Yelp ist eine der dichtesten Quellen für öffentliche lokale Unternehmensdaten im Web. Jedes Suchergebnis enthält einen Unternehmensnamen, eine Sternbewertung, eine Bewertungsanzahl, die Kategorien, unter denen das Unternehmen geführt wird, seine Nachbarschaft oder Adresse und einen Link zu seiner eigenen Yelp-Seite. Für die Recherche zu lokalen Unternehmen, die Wettbewerbsanalyse oder den Aufbau eines regionalen Datensatzes von Dienstleistern sind diese öffentlichen Eintragsfelder genau das strukturierte Signal, das Sie suchen, alles sichtbar ohne Anmeldung.

Diese Anleitung zeigt Ihnen, wie Sie Yelp mit Python auf zuverlässige Weise scrapen. Sie rufen gerenderte Suchergebnis-Seiten über die Crawling API ab, analysieren jede Unternehmenskarte mit BeautifulSoup, um Name, Bewertung, Bewertungsanzahl, Kategorie, Adresse und Link zu extrahieren, durchlaufen dann die Paginierung, um einen vollständigen Ergebnissatz abzudecken, und exportieren nach JSON oder CSV. Alles hier ist auf öffentliche Unternehmensdaten beschränkt, und der Abschnitt zur Rechtmäßigkeit am Ende ist kein Boilerplate, also lesen Sie ihn, bevor Sie dies auf echtes Volumen anwenden.

Was Sie bauen werden

Ein kleiner Python-Scraper, der eine Suchanfrage und einen Standort entgegennimmt, die gerenderte Yelp-Suchergebnis-Seite über die Crawling API abruft und einen strukturierten Datensatz für jedes Unternehmen auf der Seite extrahiert. Das laufende Beispiel sind "Italian Restaurants" in "San Francisco, CA", und für jeden Eintrag extrahieren wir diese Felder:

• Unternehmensname die primäre Kennung auf der Eintrags-Karte.
• Bewertung die aggregierte Sternbewertung des Unternehmens.
• Bewertungsanzahl wie viele Bewertungen diese Bewertung stützen.
• Kategorie die Unternehmenskategorien, unter denen der Eintrag geführt wird.
• Adresse die öffentliche Nachbarschaft oder Straßengegend, die für geografische Analysen verwendet wird.
• Link die URL zur eigenen Yelp-Seite des Unternehmens.

Warum ein einfacher Request bei Yelp scheitert

Sie können die requests-Bibliothek auf eine Yelp-Such-URL richten und an einem guten Tag etwas HTML zurückerhalten. Zwei Probleme treten schnell auf. Erstens rendert Yelp einen Großteil seiner Suchergebnis-Inhalte mit JavaScript, sodass das rohe HTML, das ein einfacher Request erhält, oft eine Hülle ist, die noch keine Unternehmenskarten enthält. Zweitens beobachtet Yelp scraperförmigen Traffic: Es begrenzt Raten nach IP, stellt CAPTCHAs für automatisiert wirkende Anfragen bereit und blockiert Datacenter-Adressen, die Seiten in einem engen, maschinenförmigen Muster abrufen. Eine einzelne Anfrage von Ihrem Laptop könnte gelingen; einige Hundert von derselben IP werden es nicht.

Ein Scraper, der den Job tatsächlich abschließt, benötigt also zwei Dinge: die Seite so gerendert, wie ein echter Browser sie rendern würde, und Anfragen, die als echter Besucher von einer vertrauenswürdigen IP erscheinen. Sie können das selbst mit einem Headless-Browser-Pool und einem Pool von rotierenden Residential-Proxies aufbauen, aber diesen Stack zu pflegen ist der Großteil der Arbeit. Die Crawling API faltet es in einen einzigen Aufruf: Sie senden ihr die URL, sie rendert das JavaScript und leitet die Anfrage über Residential-IPs serverseitig weiter, verarbeitet die Anti-Bot-Schicht und gibt das fertige HTML zum Parsen zurück.

Voraussetzungen

Einige Dinge müssen zuerst eingerichtet sein. Keines davon dauert lange.

Python-Grundkenntnisse. Sie sollten mit dem Ausführen eines Skripts und dem Installieren von Paketen mit pip vertraut sein. Falls Selektoren neu für Sie sind, behandelt die Einführung zu BeautifulSoup in Python die Parsing-Seite ausführlich.

Python 3.8 oder höher. Prüfen Sie mit python --version. Falls Sie es nicht haben, installieren Sie es von python.org oder über eine Distribution wie Anaconda.

Ein Crawlbase-Konto und Token. Melden Sie sich an, öffnen Sie Ihr Dashboard und kopieren Sie Ihr JavaScript-Token von der Konto-Dokumentationsseite. Sie erhalten bis zu 20.000 kostenlose Anfragen und es ist keine Kreditkarte erforderlich. Behandeln Sie das Token wie ein Passwort und halten Sie es außerhalb der Versionsverwaltung.

Das Projekt einrichten

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

python --version

python -m venv yelp_env
source yelp_env/bin/activate

pip install crawlbase beautifulsoup4 pandas

Unter Windows aktivieren Sie die Umgebung mit yelp_env\Scripts\activate statt der source-Zeile. Drei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Client für die Crawling API, beautifulsoup4 analysiert das zurückgegebene HTML, sodass Sie jedes Feld per CSS-Selektor extrahieren können, und pandas schreibt die Datensätze am Ende als CSV heraus.

Schritt 1: Eine gerenderte Suchseite abrufen

Beginnen Sie damit, eine Ergebnisseite zurückzubekommen. Bauen Sie die Such-URL aus Ihrer Abfrage und Ihrem Standort, importieren Sie die CrawlingAPI-Klasse, initialisieren Sie sie mit Ihrem Token und fordern Sie die URL mit aktiviertem JavaScript-Rendering an. Eine Yelp-Suche wird durch zwei URL-Parameter gesteuert: find_desc für die Unternehmenskategorie und find_loc für den Standort. Das Prüfen des Status vor dem Parsen hält Fehler laut statt still.

from urllib.parse import urlencode
from crawlbase import CrawlingAPI

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

def build_url(query, location, start=0):
    base = "https://www.yelp.com/search?"
    params = {"find_desc": query, "find_loc": location, "start": start}
    return base + urlencode(params)

def crawl(page_url):
    response = api.get(page_url, {"ajax_wait": "true", "page_wait": "3000"})
    if response["headers"]["cb_status"] == "200":
        return response["body"].decode("latin1")
    print(f"Request failed: {response['headers']['cb_status']}")
    return None

if __name__ == "__main__":
    url = build_url("Italian Restaurants", "San Francisco, CA")
    html = crawl(url)
    print(html[:500] if html else "No HTML returned")

Die Optionen ajax_wait und page_wait weisen die Crawling API an, JavaScript zu rendern und kurz zu warten, damit die Unternehmenskarten fertig geladen sind, bevor das HTML zurückkommt. Die Statusprüfung liest cb_status (legacy pc_status) aus den Antwort-Headern, was der Crawlbase-Status für die Anfrage ist, distinct vom upstream HTTP-Code. Führen Sie das Skript mit python yelp_scraper.py aus und Sie sollten echtes Ergebnis-Markup anstelle einer Herausforderungsseite oder einer leeren Hülle sehen. Das bestätigt, dass der Abrufpfad funktioniert, bevor Sie einen einzigen Selektor schreiben.

Schritt 2: Die Einträge mit BeautifulSoup parsen

Mit einer gerenderten Ergebnisseite zur Hand laden Sie sie in BeautifulSoup und durchlaufen die Ergebniskarten. Jedes Unternehmen sitzt in einer Karte unter einem vorhersagbaren Container, und darin werden Name, Bewertung, Bewertungsanzahl, Kategorie, Adresse und Link ihren eigenen Selektoren zugeordnet. Das defensive Lesen jedes Felds, das None zurückgibt, wenn ein Element fehlt, verhindert, dass ein fehlender Wert den Lauf unterbricht.

from bs4 import BeautifulSoup

BASE = "https://www.yelp.com"

def text_of(node):
    return node.get_text(strip=True) if node else None

def extract_business(card):
    name = card.select_one('div[class*="businessName"] h3 > span > a')
    rating = card.select_one('div.css-volmcs + div.css-1jq1ouh > span:first-child')
    reviews = card.select_one('div.css-volmcs + div.css-1jq1ouh > span:last-child')
    category = card.select('div[class*="priceCategory"] div > p > span:first-child a')
    address = card.select_one('div[class*="priceCategory"] div > p > span:last-child')

    return {
        "name": text_of(name),
        "rating": text_of(rating),
        "review_count": text_of(reviews),
        "category": ", ".join(c.get_text(strip=True) for c in category) if category else None,
        "address": text_of(address),
        "link": BASE + name["href"] if name and name.get("href") else None,
    }

def extract_businesses(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select('div[data-testid="serp-ia-card"]:not(.ABP)')
    return [extract_business(card) for card in cards]

Die Karten werden mit div[data-testid="serp-ia-card"]:not(.ABP) ausgewählt, was die organischen Ergebniskarten auswählt und gleichzeitig die Anzeigenplatzvarianten überspringt. Der businessName-Anker enthält sowohl den Anzeigenamen als auch das relative href zur Yelp-Seite dieses Unternehmens, sodass Name und Link aus demselben Element stammen. Bewertung und Bewertungsanzahl sind die zwei Spans, die dem Bewertungsblock folgen, und Kategorie und Adresse befinden sich in der Preis-und-Kategorie-Zeile. Der Helfer text_of gibt None zurück, wenn ein Element fehlt, anstatt bei einem .get_text()-Aufruf auf nichts zu werfen, was die Extraktion belastbar hält, wenn einer Karte ein Feld fehlt.

Schritt 3: Alles zusammensetzen

Verbinden Sie nun Abruf und Parsen zu einem ausführbaren Skript für eine einzelne Seite. Bauen Sie die URL, rufen Sie das gerenderte HTML ab, übergeben Sie es an den Parser und geben Sie die strukturierten Datensätze als JSON aus.

import json
from urllib.parse import urlencode
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})
BASE = "https://www.yelp.com"

def build_url(query, location, start=0):
    params = {"find_desc": query, "find_loc": location, "start": start}
    return BASE + "/search?" + urlencode(params)

def crawl(page_url):
    response = api.get(page_url, {"ajax_wait": "true", "page_wait": "3000"})
    if response["headers"]["cb_status"] == "200":
        return response["body"].decode("latin1")
    print(f"Request failed: {response['headers']['cb_status']}")
    return None

def text_of(node):
    return node.get_text(strip=True) if node else None

def extract_business(card):
    name = card.select_one('div[class*="businessName"] h3 > span > a')
    rating = card.select_one('div.css-volmcs + div.css-1jq1ouh > span:first-child')
    reviews = card.select_one('div.css-volmcs + div.css-1jq1ouh > span:last-child')
    category = card.select('div[class*="priceCategory"] div > p > span:first-child a')
    address = card.select_one('div[class*="priceCategory"] div > p > span:last-child')
    return {
        "name": text_of(name),
        "rating": text_of(rating),
        "review_count": text_of(reviews),
        "category": ", ".join(c.get_text(strip=True) for c in category) if category else None,
        "address": text_of(address),
        "link": BASE + name["href"] if name and name.get("href") else None,
    }

def extract_businesses(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select('div[data-testid="serp-ia-card"]:not(.ABP)')
    return [extract_business(card) for card in cards]

def main():
    url = build_url("Italian Restaurants", "San Francisco, CA")
    html = crawl(url)
    if not html:
        return
    data = extract_businesses(html)
    print(json.dumps(data, indent=2))

if __name__ == "__main__":
    main()

Wie die Ausgabe aussieht

Führen Sie das vollständige Skript mit python yelp_scraper.py aus und Sie erhalten eine saubere Liste strukturierter Datensätze, bereit zum Schreiben nach JSON, CSV oder in eine Datenbank.

[
  {
    "name": "Bella Trattoria",
    "rating": "4.3",
    "review_count": "(1.9k reviews)",
    "category": "Italian, Bars, Pasta Shops",
    "address": "Inner Richmond",
    "link": "https://www.yelp.com/biz/bella-trattoria-san-francisco"
  },
  {
    "name": "Sotto Mare",
    "rating": "4.3",
    "review_count": "(5.2k reviews)",
    "category": "Seafood, Italian, Bars",
    "address": "North Beach/Telegraph Hill",
    "link": "https://www.yelp.com/biz/sotto-mare-san-francisco"
  }
]

Jedes Feld, das eine Karte nicht enthält, kommt als null zurück, was erwartet wird und genau der Grund ist, warum der Parser jedes Feld defensiv liest, anstatt anzunehmen, dass jeder Schlüssel vorhanden ist. Die Bewertungsanzahl kommt als Anzeigestring wie "(1.9k reviews)" zurück; falls Sie eine saubere Ganzzahl für die Analyse benötigen, entfernen Sie die Klammern und expandieren Sie das k-Suffix in einem späteren Bereinigungsschritt.

Schritt 4: Paginierung über Ergebnisseiten handhaben

Eine Seite ist eine Demo; ein echter Auftrag deckt den vollständigen Ergebnissatz ab. Yelp paginiert seine Suchergebnisse über den start-URL-Parameter, der den Offset des ersten Ergebnisses auf der Seite setzt und in Zehnerschritten vorrückt. Das Durchlaufen der Seiten ist also eine Schleife über einen Bereich von Offsets: 0, 10, 20 und so weiter. Die gleichen Funktionen build_url und extract_businesses werden ohne Änderungen übernommen, also ist die Paginierung nur eine äußere Schleife, die sich zwischen Anfragen selbst taktet und das kombinierte Ergebnis nach JSON und CSV schreibt.

import json
import time
import pandas as pd

def scrape_all_pages(query, location, max_pages=5):
    all_rows = []
    for page in range(max_pages):
        start = page * 10
        url = build_url(query, location, start)
        html = crawl(url)
        if not html:
            print(f"Stopping at offset {start}: no HTML")
            break
        rows = extract_businesses(html)
        if not rows:
            print(f"No results at offset {start}; reached the end")
            break
        all_rows.extend(rows)
        print(f"Offset {start}: {len(rows)} businesses")
        time.sleep(2)
    return all_rows

if __name__ == "__main__":
    rows = scrape_all_pages("Italian Restaurants", "San Francisco, CA", max_pages=5)

    with open("yelp_businesses.json", "w") as f:
        json.dump(rows, f, indent=2)

    pd.DataFrame(rows).to_csv("yelp_businesses.csv", index=False)
    print(f"Saved {len(rows)} businesses to JSON and CSV")

Zwei Details machen diese Schleife produktionstauglich. Sie stoppt früh, wenn eine Seite keine Unternehmen zurückgibt, sodass Sie keine Anfragen nach der letzten echten Seite verschwenden, und sie schläft für zwei Sekunden zwischen Anfragen, damit der Lauf nicht als ein enges Burst ankommt. Der Export-Schritt schreibt beide Formate aus derselben Liste von Wörterbüchern: json.dump für eine strukturierte Datei und pandas für eine CSV, die sich direkt in einer Tabellenkalkulation öffnet. Passen Sie max_pages und den Sleep an Ihr Volumen an; je langsamer Sie gehen, desto weniger Aufmerksamkeit erregen Sie.

Ungeblockt bleiben

Selbst wenn die Crawling API Rendering, IP-Rotation und die Anti-Bot-Schicht übernimmt, halten einige Gewohnheiten einen Lauf gesund, und sie gelten für jedes lokale Verzeichnis-Ziel.

• Anfragen takten. Der obige Sleep ist nicht kosmetisch. Eine enge Schleife ist der schnellste Weg zur Drosselung; das Verteilen von Anfragen wirkt viel mehr wie normaler Traffic.
• Auf Rotation setzen. Ein Pool von Residential-IPs verteilt Anfragen über viele reale Benutzeradressen, 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.
• Statuscodes lesen. Ein Lauf, der anfängt, Herausforderungen oder Fehler zurückzugeben, signalisiert, dass die aktuelle Rate zu aggressiv ist. Behandeln Sie das als Signal zum Zurückgehen, nicht als Rauschen, das Sie ignorieren.

Für das breitere Playbook lesen Sie wie man Websites scrapt ohne gesperrt zu werden. Falls Ihr Ziel die breitere Kategorie lokaler Unternehmensverzeichnisse statt Yelp im Speziellen ist, decken der Leitfaden zum Scrapen lokaler Unternehmenseinträge und die Yellow Pages-Anleitung verwandte Quellen mit demselben Ansatz ab. Und wenn Sie den Bewertungstext hinter jedem Unternehmen statt der Suchergebnis-Zusammenfassung möchten, lesen Sie wie man Yelp-Bewertungen crawlt, und beachten Sie dabei die folgenden Datenschutzhinweise.

Ist es legal, Yelp zu scrapen?

Ob das Scrapen von Yelp erlaubt ist, hängt von den Nutzungsbedingungen der Website, Ihrer Jurisdiktion und dem ab, was Sie mit den Daten tun. Keiner der hier verwendeten Codes ändert das; er macht nur den technischen Teil funktionsfähig. Lesen Sie Yelps Nutzungsbedingungen und seine robots.txt und behandeln Sie beides als Grenze für das, was Sie sammeln und wie schnell. Yelps Bedingungen schränken den automatisierten Zugriff ein, daher ist der richtige Weg für alles über kleinmaßstäbliche Recherche hinaus Yelps eigener offizieller Kanal: die Yelp Fusion API bietet Unternehmens- und Suchdaten unter von Yelp unterstützten Bedingungen, was sicherer und dauerhafter ist als das Scrapen des Frontend.

Wenn Sie von öffentlichen Seiten sammeln, beschränken Sie es auf öffentliche Unternehmensdaten: den Unternehmensnamen, die aggregierte Bewertung, die Bewertungsanzahl, die Kategorie, die öffentliche Nachbarschaft oder Adresse und den Link zum Eintrag. Die Bewertungen selbst verdienen eine schärfere Grenze. Aggregierte Bewertungen und Bewertungsanzahlen sind Unternehmens-Level-Fakten, aber der Text einer einzelnen Bewertung und der Name der Person, die sie geschrieben hat, sind personenbezogene Daten. Behandeln Sie Bewerter-Identitäten als persönlich: Erstellen Sie keine Profile von Einzelpersonen, veröffentlichen Sie die Bewertung einer Person nicht verbunden mit ihrem Namen weiter, und wenden Sie DSGVO- oder CCPA-Verpflichtungen an, wo immer personenbezogene Daten in den Geltungsbereich fallen.

Was dieser Ansatz nicht abdeckt, ist genauso wichtig. Er berührt nichts hinter einem Login und umgeht keine Authentifizierung oder Zugangskontrolle, um gesperrte Inhalte zu erreichen; das liegt außerhalb des Rahmens und verstößt gegen die Bedingungen der Website. Respektieren Sie Yelps angegebene Rateerwartungen, halten Sie Ihr Anfragevolumen vernünftig, sodass Sie seine Server nicht belasten, und wenn Sie planen, Yelp-Daten zu speichern, anzureichern oder kommerziell weiterzuverwenden, bevorzugen Sie die Fusion API und prüfen Sie die für Sie geltenden Regeln, anstatt anzunehmen, dass öffentlich bedeutet uneingeschränkt.

Häufig gestellte Fragen

Benötige ich das normale Token oder das JS-Token für Yelp?

Das JavaScript-Token. Yelp baut seine Suchergebnis-Karten clientseitig auf, sodass ein normaler Token-Abruf oft eine HTML-Hülle ohne die enthaltenen Unternehmen zurückgibt. Das JS-Token rendert die Seite zuerst in einem echten Browser, was die Karten in das HTML setzt, das Sie parsen. Kombinieren Sie es mit den Optionen ajax_wait und page_wait, damit der Inhalt Zeit hat, sich zu setzen, bevor die Antwort zurückkommt.

Wie gehe ich mit der Paginierung bei Yelp um?

Yelp stellt den Ergebnis-Offset über einen start-URL-Parameter bereit, der in Zehnerschritten vorrückt, also durchlaufen Sie einen Bereich von Offsets (0, 10, 20 und so weiter), bauen eine URL pro Seite und führen denselben Parser auf jeder aus. Stoppen Sie, wenn eine Seite null Unternehmen zurückgibt, was das Ende des Ergebnissatzes markiert, und schlafen Sie einige Sekunden zwischen Anfragen, damit der Lauf nicht als ein Burst ankommt.

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

Höchstwahrscheinlich Yelps Markup. Die gehashten Klassennamen wie css-volmcs und css-1jq1ouh werden generiert und ändern sich ohne Vorankündigung, sodass Selektoren, die letzten Monat funktioniert haben, brechen können. Prüfen Sie eine Live-Ergebnisseite erneut in den Entwicklertools Ihres Browsers und aktualisieren Sie sie, und bevorzugen Sie die stabileren data-testid- und businessName-Hooks, wo immer möglich. Regelmäßige Selektor-Pflege ist für jeden Produktions-Scraper normal.

Ist es legal, Yelp-Bewertungen zu scrapen?

Aggregierte Bewertungen und Bewertungsanzahlen sind Unternehmens-Level-Fakten, die Sie für Analysen verwenden können, aber der Text einer einzelnen Bewertung und der Name des Bewerters sind personenbezogene Daten. Erstellen Sie keine Profile von Einzelpersonen oder veröffentlichen Sie die Bewertung einer Person verbunden mit ihrer Identität weiter, und wenden Sie die DSGVO oder den CCPA an, wo personenbezogene Daten beteiligt sind. Für Bewertungsdaten in beliebigem Umfang ist die Yelp Fusion API der von Yelp unterstützte Weg und die sicherere Wahl als das Scrapen der öffentlichen Seiten.

Wie vermeide ich, beim Scrapen von Yelp gesperrt zu werden?

Halten Sie Ihre Pro-IP-Anfragerate niedrig, takten Sie Anfragen mit einer Verzögerung und leiten Sie über rotierende Residential-IPs, sodass keine einzelne Adresse ein Rate-Limit auslöst. Die Crawling API verwaltet Rendering, Rotation und die Anti-Bot-Schicht für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, in den Sie investieren müssen. Beobachten Sie die Statuscodes und gehen Sie zurück, sobald Sie Herausforderungen sehen.

Kann ich die gescrapten Daten nach Excel exportieren?

Ja. Der Scraper erzeugt eine Liste von Wörterbüchern, die pandas in zwei Zeilen in eine Tabelle verwandelt: pd.DataFrame(rows).to_excel("yelp_businesses.xlsx", index=False). Da jeder Datensatz dieselben Schlüssel teilt, richten sich die Spalten sauber aus, und die gleiche Struktur exportiert genauso einfach nach CSV, das das Skript bereits schreibt, oder in eine Datenbanktabelle.

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.