Yellow Pages scrapenein öffentliches Branchenverzeichnis

Yellow Pages ist eines der ältesten Branchenverzeichnisse im Web und ist nach wie vor eine dichte Quelle für Daten zu lokalen Unternehmen: Name, öffentliche Telefonnummer, Straßenadresse, die Kategorien, unter denen ein Unternehmen geführt wird, und ein Link zu seiner eigenen Website. Für Vertriebsakquise, Markterfassung oder den Aufbau eines regionalen Datensatzes von Dienstleistern sind diese öffentlichen Einträge genau die strukturierten Informationen, die Sie suchen. Die Hürde ist operativer, nicht konzeptioneller Natur: Yellow Pages beobachtet scraperförmigen Traffic und wird eine naive Schleife schnell drosseln oder herausfordern.

Diese Anleitung zeigt Ihnen, wie Sie Yellow Pages-Unternehmenseinträge mit Python auf zuverlässige Weise scrapen. Sie rufen gerenderte Suchergebnis-Seiten über die Crawling API ab, analysieren jedes Ergebnis mit BeautifulSoup, um Name, Telefon, Adresse, Kategorie und Website zu extrahieren, und durchlaufen dann die Paginierung, um einen vollständigen Ergebnissatz abzudecken. Alles hier ist auf öffentliche Branchenverzeichnis-Daten beschränkt, und der Abschnitt zur Rechtmäßigkeit am Ende ist kein Boilerplate, also lesen Sie ihn, bevor Sie dies auf reales Volumen anwenden.

Was Sie bauen werden

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

• Unternehmensname die primäre Kennung für den Eintrag.
• Telefon die auf der Karte angezeigte öffentliche Kontaktnummer.
• Adresse die öffentliche Straßenadresse, die für geografische Analysen verwendet wird.
• Kategorie die Unternehmenskategorien, unter denen der Eintrag geführt wird.
• Website der Link zur eigenen Website des Unternehmens, wenn einer angegeben ist.

Wie Yellow Pages-Suchseiten strukturiert sind

Eine Yellow Pages-Suche wird durch zwei URL-Parameter gesteuert: search_terms für die Abfrage und geo_location_terms für den Standort. Eine Suche führt Sie auf eine Ergebnisseite, auf der jedes Unternehmen eine eigenständige Karte ist. Die Karte trägt den Namen als Überschriften-Link, Telefon und Adresse in eigenen Blöcken, die Kategorien als Liste und, für Unternehmen, die den Eintrag bezahlt oder beansprucht haben, einen ausgehenden Website-Link.

Ergebnisse erstrecken sich über mehrere Seiten. Yellow Pages verwendet einen page-URL-Parameter zum Wechseln zwischen ihnen, was die Paginierung zu einer Frage des Inkrementierens einer ganzen Zahl macht, statt dynamisches "Mehr laden"-Verhalten zu verfolgen. Diese Vorhersagbarkeit ermöglicht es, denselben Parser auf jeder Seite auszuführen, ohne Änderungen, sobald er auf einer Seite funktioniert.

Warum ein einfacher Abruf schwierig ist

Sie können eine Yellow Pages-Such-URL mit der requests-Bibliothek anfordern und an einem guten Tag HTML zurückerhalten. Das Problem zeigt sich im Volumen. Yellow Pages setzt Anti-Scraping-Abwehrmaßnahmen ein: es begrenzt Raten nach IP, dient CAPTCHAs für Traffic, der automatisiert aussieht, und blockiert Datacenter-Adressen, die Seiten in einem engen, maschinell geformten Muster anfordern. 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 Anfragen, die als echter Besucher von einer vertrauenswürdigen IP wirken. Sie können das selbst mit einem Pool von rotierenden Residential-Proxies und der Infrastruktur, um diese gesund zu halten, 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 leitet die Anfrage über Residential-IPs serverseitig weiter und verarbeitet die Anti-Bot-Schicht, und gibt das 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 normales Token von der Konto-Dokumentationsseite. Die ersten 1.000 Anfragen sind kostenlos 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 zwei Bibliotheken, die der Scraper benötigt.

python --version

python -m venv yellowpages_env
source yellowpages_env/bin/activate

pip install crawlbase beautifulsoup4

Unter Windows aktivieren Sie die Umgebung mit yellowpages_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 analysiert das zurückgegebene HTML, sodass Sie jedes Feld per CSS-Selektor extrahieren können.

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 an. 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, page=1):
    base = "https://www.yellowpages.com/search?"
    params = {"search_terms": query, "geo_location_terms": location, "page": page}
    return base + urlencode(params)

def crawl(page_url):
    response = api.get(page_url)
    if response["headers"]["pc_status"] == "200":
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['headers']['pc_status']}")
    return None

if __name__ == "__main__":
    url = build_url("Information Technology", "Los Angeles, CA")
    html = crawl(url)
    print(html[:500] if html else "No HTML returned")

Beachten Sie, dass die Statusprüfung pc_status aus den Antwort-Headern liest, was der Crawlbase-Status für die Anfrage ist, distinct vom upstream HTTP-Code. Führen Sie das Skript mit python scraper.py aus und Sie sollten echtes Ergebnis-Markup anstelle einer Herausforderungsseite sehen. Das bestätigt, dass der Abrufpfad funktioniert, bevor Sie einen einzigen Selektor schreiben.

Schritt 2: Die Einträge mit BeautifulSoup parsen

Mit einer Ergebnisseite zur Hand laden Sie sie in BeautifulSoup und durchlaufen die Ergebniskarten. Jede Karte sitzt unter einem vorhersagbaren Container, und darin werden Name, Telefon, Adresse, Kategorien und Website 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

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

def extract_listings(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select("div.search-results.organic div.result")
    listings = []

    for card in cards:
        name = card.select_one("a.business-name")
        phone = card.select_one("div.phone")
        address = card.select_one("div.adr")
        category = card.select_one("div.categories")
        website = card.select_one("a.track-visit-website")

        listings.append({
            "name": text_of(name),
            "phone": text_of(phone),
            "address": text_of(address),
            "category": text_of(category),
            "website": website["href"] if website else None,
        })

    return listings

Der Helfer text_of fragt einen Knoten ab und gibt None zurück, wenn er fehlt, anstatt bei einem .get_text()-Aufruf auf nichts zu werfen. Das hält die Extraktion belastbar: Nicht jeder Eintrag hat einen Website-Link oder einen sauberen Telefon-Block, und ein fehlendes Feld sollte ein None im Datensatz hinterlassen, anstatt die Schleife zu stoppen. Die Website wird aus dem href des Ankers statt aus seinem Text gelesen und daher separat behandelt.

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 HTML ab, übergeben Sie es an den Parser und geben Sie die strukturierten Datensätze aus.

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

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

def build_url(query, location, page=1):
    base = "https://www.yellowpages.com/search?"
    params = {"search_terms": query, "geo_location_terms": location, "page": page}
    return base + urlencode(params)

def crawl(page_url):
    response = api.get(page_url)
    if response["headers"]["pc_status"] == "200":
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['headers']['pc_status']}")
    return None

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

def extract_listings(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select("div.search-results.organic div.result")
    listings = []

    for card in cards:
        website = card.select_one("a.track-visit-website")
        listings.append({
            "name": text_of(card.select_one("a.business-name")),
            "phone": text_of(card.select_one("div.phone")),
            "address": text_of(card.select_one("div.adr")),
            "category": text_of(card.select_one("div.categories")),
            "website": website["href"] if website else None,
        })

    return listings

def main():
    url = build_url("Information Technology", "Los Angeles, CA")
    html = crawl(url)
    if not html:
        return
    data = extract_listings(html)
    print(json.dumps(data, indent=2))

if __name__ == "__main__":
    main()

Wie die Ausgabe aussieht

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

[
  {
    "name": "L. A. Computer Works",
    "phone": "(310) 277-9799",
    "address": "2355 Westwood Blvd, Los Angeles, CA 90064",
    "category": "Computer Technical Assistance and Support Services",
    "website": "http://lacomputerworks.com"
  },
  {
    "name": "Desktop Conquest",
    "phone": "(213) 321-1869",
    "address": "Los Angeles, CA 90057",
    "category": "Computer System Designers and Consultants",
    "website": null
  }
]

Einträge ohne beanspruchte Website kommen mit "website": 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.

Schritt 4: Paginierung über Ergebnisseiten handhaben

Eine Seite ist eine Demo; ein echter Auftrag deckt den vollständigen Ergebnissatz ab. Da Yellow Pages die Ergebnisseite über den page-URL-Parameter bereitstellt, ist das Durchlaufen der Seiten eine Schleife über einen Integer-Bereich. Die gleichen Funktionen build_url und extract_listings werden ohne Änderungen übernommen, also ist die Paginierung nur eine äußere Schleife, die sich zwischen Anfragen selbst taktet.

import time

def scrape_all_pages(query, location, max_pages):
    all_listings = []
    for page in range(1, max_pages + 1):
        url = build_url(query, location, page)
        html = crawl(url)
        if not html:
            print(f"Stopping at page {page}: no HTML")
            break
        listings = extract_listings(html)
        if not listings:
            print(f"No results on page {page}; reached the end")
            break
        all_listings.extend(listings)
        print(f"Page {page}: {len(listings)} listings")
        time.sleep(2)
    return all_listings

if __name__ == "__main__":
    rows = scrape_all_pages("Information Technology", "Los Angeles, CA", max_pages=5)
    with open("yellow_pages.json", "w") as f:
        json.dump(rows, f, indent=2)
    print(f"Saved {len(rows)} listings")

Zwei Details machen diese Schleife produktionstauglich. Sie stoppt früh, wenn eine Seite keine Einträge 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. 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 die IP-Rotation und die Anti-Bot-Schicht übernimmt, halten einige Gewohnheiten einen Lauf gesund, und sie gelten für jedes 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. Den tieferen Hintergrund finden Sie im Leitfaden zum Rotieren von IP-Adressen.
• 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 und den tieferen Einblick in wie man CAPTCHAs beim Web Scraping umgeht. Wenn Sie dies auf viele Abfragen und Standorte skalieren, behandeln die Muster in großvolumigem Web Scraping Warteschlangen und Speicherung. Wenn Sie Ihren eigenen Traffic lieber über einen rotierenden Pool als über die verwaltete API leiten möchten, gibt Ihnen der Smart AI Proxy dieselbe Residential-Rotation als Drop-in-Proxy-Endpunkt.

Ist es legal, Yellow Pages zu scrapen?

Ob das Scrapen von Yellow Pages 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 die Yellow Pages-Nutzungsbedingungen und seine robots.txt und behandeln Sie beides als Grenze für das, was Sie sammeln und wie schnell.

Einige Grundsätze, an die es sich zu halten lohnt. Sammeln Sie nur öffentliche Branchenverzeichnis-Daten: den Unternehmensnamen, die öffentliche Telefonnummer, die öffentliche Adresse und die Kategorie, die jeder ohne Anmeldung sehen kann. Respektieren Sie die angegebenen Rateerwartungen der Website und halten Sie Ihr Anfragevolumen vernünftig, sodass Sie ihre Server nicht belasten. Dieser Leitfaden ist bewusst auf diese öffentliche Oberfläche beschränkt, weil das die Linie ist, die die Arbeit vertretbar hält.

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. Und beachten Sie, dass das Aggregieren von Unternehmenskontaktdaten je nach Ihrer Jurisdiktion separate rechtliche Verpflichtungen mit sich bringen kann, selbst wenn jedes einzelne Feld öffentlich ist. Wenn Sie also vorhaben, einen Kontaktdatensatz zu speichern, anzureichern oder kommerziell weiterzuverwenden, 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 Yellow Pages?

Das normale Token. Yellow Pages stellt seine Eintrags-Daten im anfänglichen HTML bereit, sodass ein normaler Token-Abruf parsbares Markup zurückgibt und jede Anfrage günstiger hält. Das JS-Token rendert die Seite zuerst in einem echten Browser, was Sie nur benötigen, wenn ein Ziel seine Einträge clientseitig nach dem Seitenaufruf lädt. Beginnen Sie mit dem normalen Token und wechseln Sie nur, wenn Felder überall leer zurückkommen.

Wie gehe ich mit der Paginierung bei Yellow Pages um?

Yellow Pages stellt die Ergebnisseite über einen page-URL-Parameter bereit, also durchlaufen Sie einen Integer-Bereich, bauen eine URL pro Seite und führen denselben Parser auf jeder aus. Stoppen Sie, wenn eine Seite null Einträge 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 das Yellow Pages-Markup. Klassennamen wie result, business-name und track-visit-website ä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 die Selektoren. Regelmäßige Selektor-Pflege ist für jeden Produktions-Scraper normal, kein Zeichen, dass etwas kaputt ist.

Warum haben einige Einträge keine Website?

Nicht jedes Unternehmen beansprucht oder verlinkt seine eigene Website bei Yellow Pages, sodass der Website-Anker bei diesen Karten einfach fehlt. Der Parser liest das Feld defensiv und speichert None, anstatt zu werfen, sodass eine fehlende Website ein sauberes null im Datensatz hinterlässt und die Schleife mit dem nächsten Eintrag fortfährt.

Wie vermeide ich, beim Scrapen von Yellow Pages gesperrt zu werden?

Halten Sie Ihre IP-Rate 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 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("yellow_pages.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 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.