Daten von Google Maps scrapenUnternehmensangebote und Ortsdetails

Google Maps ist eine der reichhaltigsten Quellen für lokale Unternehmensinformationen im offenen Web. Suchen Sie eine Kategorie in einer Stadt und Sie erhalten eine sortierte Liste von Orten, jeder mit einem Namen, einer Adresse, einer Telefonnummer, einer Kategorie, einer Sternebewertung und einer Anzahl von Rezensionen. Für lokale Lead-Generierung, Marktforschung und Wettbewerbsanalyse sind diese öffentlichen Angebotsdaten Gold: Sie verraten Ihnen, wer in einem Gebiet tätig ist, wie sie bewertet sind und wie Sie sie erreichen können.

Diese Anleitung zeigt Ihnen, wie Sie mit Python Daten von Google Maps scrapen - zuverlässig. Sie erstellen einen kleinen, lauffähigen Scraper, der eine gerenderte Google Maps-Ergebnisseite über die Crawling API abruft, jede Ortskarte mit BeautifulSoup analysiert, die wichtigsten Unternehmensfelder sammelt, mehrere Ergebnisse verwaltet und die Daten in JSON und CSV exportiert. Die gesamte Anleitung beschränkt sich auf öffentliche Unternehmensangebote, die jeder ohne Konto auf der Karte sehen kann, und der Rechtsabschnitt am Ende ist kein Boilerplate, also lesen Sie ihn, bevor Sie dies auf größere Mengen anwenden.

Was Sie erstellen werden

Ein Python-Skript, das eine öffentliche Google Maps-Such-URL entgegennimmt, das gerenderte HTML über die Crawling API abruft und für jeden Ort im Ergebnisbereich einen strukturierten Datensatz extrahiert. Als laufendes Beispiel verwenden wir "restaurants in New York", dasselbe Ziel wie die ursprüngliche Version dieses Tutorials, und lesen diese Felder aus jedem Angebot:

• Name der Unternehmensname, wie er auf der Ortskarte angezeigt wird.
• Address die Straßenadresse oder das Gebiets-Label des Ortes.
• Phone die Kontaktnummer, wenn das Angebot sie anzeigt.
• Category das Unternehmenstyp-Label, zum Beispiel "Italian restaurant".
• Rating die durchschnittliche Sternebewertung als Zahl.
• Review count wie viele Rezensionen dieser Bewertung zugrunde liegen.

Am Ende haben Sie diese Datensätze für jeden Ort auf der Seite, geschrieben sowohl in maps_results.json als auch in maps_results.csv, bereit für ein CRM, eine Tabellenkalkulation oder eine Datenbank.

Warum eine einfache Anfrage bei Google Maps scheitert

Wenn Sie eine nackte HTTP-Anfrage an eine Google Maps-URL aus einem Skript senden, erhalten Sie nicht die ordentliche Liste von Orten, die Sie in Ihrem Browser sehen. Das Ergebnisbereich wird von JavaScript erstellt, nachdem die erste Seite geladen wurde: Das rohe HTML, das von einem einfachen requests.get zurückkommt, ist größtenteils eine leere Hülle, wobei die eigentlichen Ortskarten von Skripten eingefügt werden, die in einem echten Browser laufen. Analysieren Sie diese Hülle und Sie finden keines der gesuchten Felder.

Darüber hinaus beobachtet Google automatisierten Traffic genau. Anfragen, die nicht wie ein echter Browser aussehen oder in Bursts von einer Datacenter-IP ankommen, werden mit einem CAPTCHA herausgefordert, mit einer Einwilligungsseite konfrontiert oder direkt blockiert, bevor sie irgendwelche Angebote erreichen. Die ursprüngliche Version dieses Tutorials verwendete einen internen JSON-Endpunkt, um das Rendering zu umgehen, aber diese privaten URLs ändern sich ohne Vorankündigung und brechen zusammen, sobald Google sie umstrukturiert. Der dauerhafte Ansatz ist, die öffentliche Seite so zu rendern, wie es ein Browser tut.

Ein funktionierender Google Maps-Scraper benötigt also zwei Dinge in einer einzigen Anfrage: eine IP, die die Plattform als echten Besucher erkennt, und einen Browser, der das JavaScript der Seite ausführt, sodass die Ortskarten tatsächlich erscheinen. Sie können das selbst mit einem Headless Browser plus einem Pool von rotierenden Residential Proxies zusammenstellen, aber die Pflege dieses Stacks ist der Hauptaufwand. Die Crawling API kombiniert beides in einem einzigen Aufruf: Sie senden ihr die URL, sie ruft von einer vertrauenswürdigen Residential-IP ab und rendert die Seite, und sie gibt fertiges HTML zum Analysieren zurück.

Voraussetzungen

Bevor Sie mit dem Schreiben von Code beginnen, müssen einige Dinge bereitstehen. Keines davon nimmt lange in Anspruch.

Python-Grundkenntnisse. Sie sollten in der Lage sein, ein Python-Skript zu schreiben, auszuführen und Pakete mit pip zu installieren. Falls BeautifulSoup neu für Sie ist, behandelt unsere Anleitung zur Verwendung von BeautifulSoup in Python die Parsing-Grundlagen, die dieses Tutorial voraussetzt.

Python 3.8 oder neuer. Prüfen Sie Ihre Version mit python --version. Falls nicht vorhanden, installieren Sie es von python.org oder über eine Distribution wie Anaconda.

Ein Crawlbase-Konto und Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihr Anfrage-Token von der Konto-Docs-Seite. Sie erhalten bis zu 20.000 kostenlose Anfragen, keine Kreditkarte erforderlich. Google Maps benötigt JavaScript-Rendering, also verwenden Sie Ihr JavaScript-Token für diese Anfragen. Behandeln Sie das Token wie ein Passwort: Es authentifiziert Ihre Anfragen, also halten Sie es aus der Versionsverwaltung heraus.

Das Projekt einrichten

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

python --version

python -m venv maps_env
source maps_env/bin/activate

pip install requests beautifulsoup4

Unter Windows aktivieren Sie die Umgebung mit maps_env\Scripts\activate anstelle der source-Zeile. Zwei Abhängigkeiten erledigen die Arbeit: requests sendet den HTTP-Aufruf an die Crawling API, und beautifulsoup4 analysiert das zurückgegebene HTML, sodass Sie einzelne Felder per CSS-Selektor extrahieren können.

Schritt 1: Die Such-URL abrufen

Öffnen Sie Google Maps in Ihrem Browser und suchen Sie nach "restaurants in New York". Die Orte erscheinen im scrollbaren Bereich auf der linken Seite, und die URL in Ihrer Adressleiste wird aktualisiert, um die Abfrage zu kodieren. Kopieren Sie diese URL. Das ist dieselbe Adresse, die Sie dem Scraper übergeben, sodass das, was Sie im Browser sehen, das ist, was die API rendert.

https://www.google.com/maps/search/restaurants+in+New+York

Der Pfad /maps/search/ ist der stabile, öffentliche Einstiegspunkt für eine Kategoriesuche, wobei die Abfrage durch +-Zeichen verbunden wird. Sie können jede Kategorie und jeden Ort einsetzen, zum Beispiel plumbers+in+Chicago oder coffee+shops+in+Austin, und der Rest des Scrapers bleibt gleich. Vermeiden Sie die langen internen URLs mit pb=-Parametern, die der Browser manchmal generiert; diese sind privat und brechen ohne Vorankündigung zusammen.

Schritt 2: Die gerenderte Seite über die Crawling API abrufen

Beginnen Sie damit, das HTML zu erhalten. Schreiben Sie eine kleine crawl()-Funktion, die Ihre Ziel-URL mit Ihrem JavaScript-Token an die Crawling API sendet, sie auffordert, die Seite zu rendern, überprüft, dass die zugrunde liegende Seite mit einem 200-Status zurückgekehrt ist, und den HTML-Body zurückgibt. Die Überprüfung des Status vor dem Parsen sorgt dafür, dass Fehler auffällig und nicht still auftreten.

import json
import requests

API_TOKEN = "YOUR_CRAWLBASE_TOKEN"  # use your JavaScript token
API_ENDPOINT = "https://api.crawlbase.com/"

def crawl(url):
    params = {
        "token": API_TOKEN,
        "url": url,
        "page_wait": 4000,
    }
    response = requests.get(API_ENDPOINT, params=params)
    response.raise_for_status()

    data = json.loads(response.text)
    if data["original_status"] != 200:
        raise Exception(f"Unable to crawl '{url}'")

    return data["body"]

if __name__ == "__main__":
    url = "https://www.google.com/maps/search/restaurants+in+New+York"
    html = crawl(url)
    print(html[:500])

Die API gibt einen JSON-Umschlag zurück, also laden Sie die Antwort mit json.loads und lesen zwei Felder: original_status ist der Status, den Google selbst zurückgegeben hat, und body ist das gerenderte Seiten-HTML. Der Parameter page_wait weist den Renderer an, einige Sekunden nach dem Laden zu warten, damit die Ortskarten Zeit haben, sich zu füllen, bevor das HTML aufgezeichnet wird. Das Absichern mit original_status bedeutet, dass eine Einwilligungsseite oder eine Sperre als Ausnahme erscheint, anstatt eine leere Hülle in den Parser zu speisen. Führen Sie das Skript mit python crawling.py aus und Sie sollten echtes Karten-Markup in den ersten 500 Zeichen sehen, was bestätigt, dass Abruf und Rendering funktionieren, bevor Sie einen einzigen Selektor schreiben.

Schritt 3: Jede Ortskarte mit BeautifulSoup analysieren

Mit dem gerenderten HTML laden Sie es in BeautifulSoup und extrahieren jedes Ergebnis über seinen Selektor. Google Maps umschließt jeden Ort im Ergebnisbereich in ein Artikel-Element, und jedes Feld befindet sich an einer vorhersehbaren Stelle innerhalb dieser Karte. Untersuchen Sie die Live-Seite in den Dev-Tools Ihres Browsers (klicken Sie mit der rechten Maustaste auf eine Ortskarte, dann Untersuchen), um die aktuellen Klassen- und Attributnamen zu bestätigen; die unten stehenden Selektoren entsprechen dem Layout zum Zeitpunkt der Erstellung.

import re
from bs4 import BeautifulSoup

def parse_place(card):
    name_el = card.select_one("div.qBF1Pd")
    rating_el = card.select_one("span.MW4etd")
    reviews_el = card.select_one("span.UY7F9")
    info_rows = card.select("div.W4Efsd > div.W4Efsd")

    category, address, phone = None, None, None
    for row in info_rows:
        text = row.get_text(" ", strip=True)
        phone_match = re.search(r"(\(?\d[\d\-\s\(\)]{7,}\d)", text)
        if phone_match and not phone:
            phone = phone_match.group(1).strip()
        elif "·" in text and not category:
            parts = [p.strip() for p in text.split("·")]
            category = parts[0]
            address = parts[-1] if len(parts) > 1 else None

    return {
        "name": name_el.get_text(strip=True) if name_el else None,
        "category": category,
        "address": address,
        "phone": phone,
        "rating": float(rating_el.get_text(strip=True)) if rating_el else None,
        "reviews": parse_reviews(reviews_el),
    }

def parse_reviews(el):
    if not el:
        return 0
    digits = re.sub(r"[^\d]", "", el.get_text(strip=True))
    return int(digits) if digits else 0

def scrape_html(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select("div[role='article']")
    return [parse_place(card) for card in cards if card.select_one("div.qBF1Pd")]

Der Selektor div[role='article'] trifft jede Ortskarte im Ergebnisbereich, und der Helfer liest die benannten Felder aus ihr. Der Unternehmensname befindet sich in div.qBF1Pd, die Sternebewertung in span.MW4etd und die Rezensionsanzahl in span.UY7F9 als Text wie "(1.234)", den parse_reviews auf eine Ganzzahl reduziert. Kategorie, Adresse und Telefonnummer teilen sich die sekundären Info-Zeilen unter div.W4Efsd, getrennt durch einen Mittelpunkt, also teilen wir nach "·", um Kategorie und Adresse zu extrahieren, und verwenden einen kleinen regulären Ausdruck, um eine Telefonnummer zu erkennen. Jedes Feld defensiv lesen, mit einem None-Fallback, bedeutet, dass ein Angebot, das eine Telefonnummer oder eine Bewertung weglässt, trotzdem einen sauberen Datensatz erzeugt, anstatt die Schleife zum Absturz zu bringen.

Schritt 4: Mehrere Ergebnisse verwalten und das Skript zusammensetzen

Das Ergebnisbereich enthält viele Orte, und der Parser gibt bereits einen Datensatz pro Karte zurück, sodass die Verwaltung mehrerer Ergebnisse eingebaut ist. Verbinden Sie jetzt das Abrufen und das Parsen in einem einzigen lauffähigen Skript und exportieren Sie die Datensätze sowohl in JSON als auch CSV. Das CSV-Format ist das, das die meisten Lead-Gen- und Recherche-Workflows wollen, da es direkt in eine Tabellenkalkulation oder einen CRM-Import eingefügt werden kann.

import csv
import json
import re
import requests
from bs4 import BeautifulSoup

API_TOKEN = "YOUR_CRAWLBASE_TOKEN"
API_ENDPOINT = "https://api.crawlbase.com/"
FIELDS = ["name", "category", "address", "phone", "rating", "reviews"]

def crawl(url):
    params = {"token": API_TOKEN, "url": url, "page_wait": 4000}
    response = requests.get(API_ENDPOINT, params=params)
    response.raise_for_status()
    data = json.loads(response.text)
    if data["original_status"] != 200:
        raise Exception(f"Unable to crawl '{url}'")
    return data["body"]

def parse_reviews(el):
    if not el:
        return 0
    digits = re.sub(r"[^\d]", "", el.get_text(strip=True))
    return int(digits) if digits else 0

def parse_place(card):
    name_el = card.select_one("div.qBF1Pd")
    rating_el = card.select_one("span.MW4etd")
    reviews_el = card.select_one("span.UY7F9")
    info_rows = card.select("div.W4Efsd > div.W4Efsd")

    category, address, phone = None, None, None
    for row in info_rows:
        text = row.get_text(" ", strip=True)
        phone_match = re.search(r"(\(?\d[\d\-\s\(\)]{7,}\d)", text)
        if phone_match and not phone:
            phone = phone_match.group(1).strip()
        elif "·" in text and not category:
            parts = [p.strip() for p in text.split("·")]
            category = parts[0]
            address = parts[-1] if len(parts) > 1 else None

    return {
        "name": name_el.get_text(strip=True) if name_el else None,
        "category": category,
        "address": address,
        "phone": phone,
        "rating": float(rating_el.get_text(strip=True)) if rating_el else None,
        "reviews": parse_reviews(reviews_el),
    }

def scrape_html(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select("div[role='article']")
    return [parse_place(c) for c in cards if c.select_one("div.qBF1Pd")]

def main():
    url = "https://www.google.com/maps/search/restaurants+in+New+York"
    html = crawl(url)
    places = scrape_html(html)

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

    with open("maps_results.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=FIELDS)
        writer.writeheader()
        writer.writerows(places)

    print(f"Saved {len(places)} places to JSON and CSV")

if __name__ == "__main__":
    main()

Führen Sie das vollständige Skript mit python main.py aus. Es ruft die gerenderte Ergebnisseite für "restaurants in New York" ab, extrahiert einen Datensatz für jede Ortskarte und schreibt alles in maps_results.json und maps_results.csv. Der DictWriter verwendet dieselbe FIELDS-Liste sowohl als CSV-Header als auch für die Spaltenreihenfolge, sodass die beiden Ausgaben synchron bleiben. Tauschen Sie die Abfrage in der URL aus und der Parser verarbeitet alles, was zurückkommt.

So sieht die Ausgabe aus

Sie erhalten eine saubere Liste von Ortsdatensätzen, jeder mit den sechs Feldern, bereit zum Schreiben in JSON, CSV oder eine Datenbank. Hier ist ein gekürztes JSON-Beispiel.

[
  {
    "name": "Carmine's Italian Restaurant",
    "category": "Italian restaurant",
    "address": "200 W 44th St",
    "phone": "(212) 221-3800",
    "rating": 4.5,
    "reviews": 12873
  },
  {
    "name": "Katz's Delicatessen",
    "category": "Deli",
    "address": "205 E Houston St",
    "phone": "(212) 254-2246",
    "rating": 4.6,
    "reviews": 48091
  }
]

Die CSV enthält dieselben Daten mit einem Ort pro Zeile und den Spalten in der Reihenfolge von FIELDS: name,category,address,phone,rating,reviews. Dieses Format importiert sauber in eine Tabellenkalkulation zur Deduplizierung oder in ein CRM als Ausgangspunkt einer lokalen Interessentenliste.

Über mehrere Städte und Abfragen skalieren

Eine Suche in einer Stadt ist ein Demo; ein echtes Projekt führt denselben Scraper über viele Kategorie- und Standortpaare aus. Die URL ist das Einzige, was sich ändert, also erstellen Sie eine Liste von Abfragen und iterieren Sie über sie, wobei Sie jede mit derselben Funktion analysieren. Die eine Gewohnheit, die einen langen Durchlauf gesund hält, ist das Takten: Machen Sie eine Pause zwischen den Anfragen, anstatt sie in einer engen Schleife abzufeuern.

import time
from urllib.parse import quote_plus

queries = [
    "restaurants in New York",
    "coffee shops in Austin",
    "plumbers in Chicago",
]

all_places = []
for q in queries:
    url = f"https://www.google.com/maps/search/{quote_plus(q)}"
    html = crawl(url)
    all_places.extend(scrape_html(html))
    time.sleep(3)

print(f"Collected {len(all_places)} places across {len(queries)} queries")

Crawlbase bedient standardmäßig bis zu 20 Anfragen pro Sekunde, was für einen Scraper, der sich selbst taktet, mehr als ausreichend ist; wenn Sie wirklich mehr benötigen, kann der Support es erhöhen. Jede 5XX-Antwort der API ist kostenlos, also kostet ein erneuter Versuch bei einer blockierten oder nicht verfügbaren URL nichts. Das Ergebnisbereich lädt einen ersten Batch von Orten und zeigt mehr, während Sie scrollen, sodass ein einzelner Abruf die Top-Ergebnisse für eine Abfrage zurückgibt; für tiefere Abdeckung grenzen Sie die Abfrage nach Stadtteil ein, anstatt zu versuchen, eine unendliche Liste in einer Anfrage zu scrollen. Mehr zu diesem Muster finden Sie in unserem Leitfaden zum Scrapen lokaler Unternehmensangebote.

Entsperrt bleiben

Auch mit einer vertrauenswürdigen IP und gehandhabtem Rendering beobachtet Google Scraper-ähnlichen Traffic. Einige Gewohnheiten halten einen Durchlauf gesund.

• Anfragen takten. Maps in einer engen Schleife zu belasten ist der schnellste Weg, herausgefordert zu werden. Verteilen Sie Anfragen und variieren Sie Ihre Abfragen, anstatt einen Begriff mit voller Geschwindigkeit zu paginieren.
• Auf Rotation setzen. Ein Pool von Residential IPs verteilt Anfragen auf viele echte Benutzeradressen, sodass keine einzelne ein Limit auslöst. Die Crawling API erledigt das für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist dies der Teil, den Sie richtig machen müssen.
• Statuscodes lesen. Ein Durchlauf, der beginnt, Einwilligungsseiten oder CAPTCHAs zurückzugeben, signalisiert, dass die aktuelle Rate oder IP-Ebene nicht mehr ausreicht. Behandeln Sie das als Signal zum Verlangsamen, nicht als Lärm, den Sie ignorieren.
• Bei leeren Feldern erneut untersuchen. Google ändert sein Markup regelmäßig. Wenn Ortskarten nicht mehr analysiert werden, öffnen Sie eine Live-Seite in den Dev-Tools und aktualisieren Sie die Selektoren.

Das umfassendere Handbuch finden Sie unter So scrapen Sie Websites ohne Blockiert zu werden. Da das Maps-Bereich JavaScript-gerendert ist, erklärt unsere Anleitung zu JavaScript-Websites crawlen, warum Rendering wichtig ist und wie man es aktiviert. Wenn Ihr Projekt auch die reguläre Suchergebnisseite betrifft, behandelt unsere Anleitung zum Scrapen von Google-Suchseiten diese Oberfläche.

Ist es legal, Google Maps zu scrapen?

Ob das Scrapen von Google Maps erlaubt ist, hängt von Googles Nutzungsbedingungen, Ihrer Gerichtsbarkeit und dem Verwendungszweck der Daten ab. Googles Nutzungsbedingungen setzen Grenzen für den automatisierten Zugriff auf seine Produkte, sodass das Scrapen unabhängig davon, wie sorgfältig Ihr Tooling ist, gegen diese Bedingungen verstoßen kann. Keiner der hier vorgestellten Code ändert das; er macht lediglich den technischen Teil funktionsfähig. Lesen Sie Googles Nutzungsbedingungen und seine robots.txt, und behandeln Sie beides als Grenze für das, was Sie sammeln.

Einige Grenzen, die es einzuhalten gilt. Sammeln Sie nur öffentliche Unternehmensangebotsdaten: Namen, Adressen, Telefonnummern, Kategorien, Bewertungen und Rezensionsanzahlen, die jeder Besucher ohne Konto auf der Karte sehen kann. Das sind Geschäftsinformationen, die veröffentlicht werden, damit Kunden einen Ort finden. Scrapen Sie keine Inhalte einzelner Rezensionen, Rezensenten-Namen oder -Profile oder andere personenbezogene Daten, und verbreiten Sie keine Fotos oder anderes urheberrechtlich geschütztes Medium aus Angeboten. Halten Sie Ihr Anfragevolumen niedrig genug, dass Sie Googles Server nicht belasten, und takten Sie Ihren Crawl, anstatt ihn mit voller Geschwindigkeit zu betreiben.

Wenn Sie Ortsdaten in großem Maßstab oder mit vertraglicher Garantie benötigen, bietet Google die offizielle Places API an, die der sanktionierte Weg ist, um Unternehmensdetails abzufragen, und der richtige Weg für alles jenseits leichter, öffentlicher Recherche. Diese Anleitung ist bewusst auf öffentliche Angebotsfelder beschränkt, die im Ergebnisbereich sichtbar sind, da das die Grenze ist, die die Arbeit vertretbar hält. Nur öffentliche Unternehmensdaten. Wenn Ihr Projekt mehr benötigt, ist die offizielle API oder eine Datenvereinbarung der richtige Weg und kein clevererer Scraper.

Häufig gestellte Fragen

Warum gibt eine einfache Anfrage keine Orte von Google Maps zurück?

Das Ergebnisbereich wird von JavaScript erstellt, nachdem die Seite geladen wurde, also kommt ein nacktes requests.get mit einer größtenteils leeren Hülle und keiner der Ortskarten zurück, die Sie in Ihrem Browser sehen. Google fordert auch Traffic heraus, der nicht wie ein echter Browser aussieht. Das Abrufen über die Crawling API mit aktiviertem Rendering führt die Skripte der Seite von einer vertrauenswürdigen Residential-IP aus, sodass die Ortskarten im zurückgegebenen HTML erscheinen.

Kann ich Google Maps mit Python scrapen?

Ja. Mit requests und BeautifulSoup können Sie eine gerenderte Ergebnisseite abrufen und Name, Adresse, Telefon, Kategorie, Bewertung und Rezensionsanzahl für jeden Ort extrahieren. Die Crawling API fungiert als Brücke, die Ihre Anfrage von einer vertrauenswürdigen IP zu Google bringt und das JavaScript rendert, sodass Anfragen reibungslos verarbeitet werden, anstatt blockiert zu werden. Für eine umfassendere Python-Einführung lesen Sie unsere Anleitung zum Scrapen von Websites mit Python.

Welche Unternehmensfelder kann ich aus einem Google Maps-Angebot extrahieren?

Dieses Tutorial liest sechs Felder aus jeder Ortskarte: den Unternehmensnamen, die Kategorie, die Adresse, die Telefonnummer, die Sternebewertung und die Rezensionsanzahl. Das sind öffentliche Angebotsfelder, die jeder Besucher auf der Karte sehen kann. Bleiben Sie innerhalb dieser öffentlichen Daten und vermeiden Sie Rezensionsinhalte, Rezensenten-Profile oder alles andere, das personenbezogen ist.

Benötige ich JavaScript-Rendering, um Google Maps zu scrapen?

Ja. Im Gegensatz zu einer einfachen Suchergebnisseite existiert das Maps-Ergebnisbereich nicht im anfänglichen HTML; es wird von Skripten im Browser gerendert. Verwenden Sie Ihr Crawlbase JavaScript-Token, damit die Crawling API die Seite rendert, bevor sie aufgezeichnet wird. Unsere Anleitung zum Scrapen von JavaScript-Seiten mit Python erklärt, wann Rendering notwendig ist.

Wie scrape ich Google Maps über viele Städte?

Erstellen Sie eine Liste von Kategorie- und Standortabfragen, wandeln Sie jede in eine /maps/search/-URL um und iterieren Sie über sie, rufen Sie jede über die Crawling API ab und analysieren Sie sie mit derselben Funktion. Machen Sie einige Sekunden Pause zwischen den Anfragen, damit Sie den Crawl takten, anstatt ihn zu belasten, und sammeln Sie die Datensätze in einer kombinierten Liste, bevor Sie exportieren.

Gibt es eine offizielle Alternative zum Scrapen von Google Maps?

Ja. Googles offizielle Places API ist der sanktionierte Weg, um Unternehmensdetails wie Name, Adresse, Telefon, Bewertung und Rezensionen abzufragen, mit einem Vertrag und Quoten dahinter. Für alles jenseits leichter öffentlicher Recherche oder für Produktionsvolumen ist die offizielle API der richtige Weg; das Scrapen des öffentlichen Bereichs sollte auf kleine, respektvolle Jobs mit Daten beschränkt bleiben, die jeder auf der Karte sehen kann.

AO

Alfrick Opidi

Entwickler und technischer Redakteur

Freiberuflicher Entwickler und technischer Redakteur, der Anleitungen zu Web Scraping und Crawling zum Crawlbase-Blog beigetragen hat.