Bei der Reiseplanung nutzen die meisten Reisenden Google, um Hotels zu finden. Die Plattform zeigt Hotellisten, Preise, Bewertungen und Verfügbarkeit an einem Ort. Für Unternehmen, Analysten oder Reiseplattformen sind diese Daten Gold wert. Durch das Scraping von Google Hotels können Sie Preistrends verfolgen, Wettbewerber beobachten und Marktchancen in der Reisebranche analysieren.

In diesem Leitfaden zeigen wir Ihnen, wie Sie Google Hotels mit Python scrapen und Crawlbase Crawling APIMit dieser Methode können Sie Hoteldaten in großem Umfang erfassen, ohne sich um Sperren, CAPTCHAs oder IP-Sperren kümmern zu müssen. Wir decken alles ab, von der Einrichtung Ihrer Umgebung bis hin zum Schreiben eines kompletten Scrapers für Hotellisten und einzelne Hotelseiten.

Lasst uns beginnen.

Inhaltsverzeichnis

  1. Warum Google Hotels scrapen?
  2. Wichtige Daten zum Extrahieren aus Google Hotels
  3. Crawlbase Crawling API für Google Hotels Scraping
  • Crawlbase Python-Bibliothek
  1. Einrichten Ihrer Python-Umgebung
  2. Scraping der Google Hotels-Suchergebnisse
  • Überprüfen des HTML auf Selektoren
  • Schreiben des Hotels Listings Scraper
  • Umgang mit Paginierung
  • Speichern von Daten in einer JSON-Datei
  • Vollständiges Codebeispiel
  1. Extrahieren individueller Hoteldetails
  • Überprüfen des HTML-Codes auf Hoteldetails
  • Schreiben des Details Scrapers
  • Speichern von Daten in einer JSON-Datei
  • Vollständiges Codebeispiel
  1. Abschließende Überlegungen
  2. Häufig gestellte Fragen

Warum Google Hotels scrapen?

Google Hotels ist eine der meistgenutzten Plattformen zum Finden und Vergleichen von Hotelangeboten. Sie zeigt Preise, Standorte, Bewertungen und Buchungsoptionen – alles an einem Ort. Durch das Scraping von Google Hotels können Sie Daten für Preisüberwachung, Wettbewerbsanalysen und Einblicke in den Reisemarkt sammeln.

Hier sind einige häufige Anwendungsfälle für das Scraping von Google Hotels:

  • Verfolgen Sie die Hotelpreise: Sehen Sie, wie sich die Preise im Laufe der Zeit an verschiedenen Standorten und in verschiedenen Jahreszeiten ändern.
  • Wettbewerber vergleichen: Sehen Sie, wie andere Hotels bewertet, bepreist und verfügbar sind.
  • Reiseforschung: Erstellen Sie Tools, die die besten Hotelangebote, Reisemuster oder die Beliebtheit von Reisezielen anzeigen.
  • Daten für maschinelles Lernen: Verwenden Sie historische Daten, um die Hotelnachfrage oder Preistrends vorherzusagen.

Das manuelle Scraping dieser Daten ist zeitaufwändig, aber mit Python Web Scraping können Sie den Prozess automatisieren und im Handumdrehen strukturierte Hoteldaten erhalten.

Wichtige Daten zum Extrahieren aus Google Hotels

Beim Scraping von Google Hotels ist es wichtig zu wissen, welche Datenpunkte am wichtigsten sind. Diese Details sind nützlich für die Preisüberwachung, Wettbewerbsanalysen und die Entwicklung von Reisetools.

Das folgende Bild zeigt einige der wertvollsten Felder, die Sie extrahieren können:

Wichtige Daten zum Extrahieren aus Google Hotels

Crawlbase Crawling API für Google Hotels Scraping

Das Scraping von Google Hotels kann schwierig sein, da die Website JavaScript zum Laden von Hotellisten und -details verwendet. Herkömmliche Scraping-Methoden erfassen oft nicht den gesamten HTML-Inhalt. Daher Crawlbase Crawling API kommt in.

Crawlbase Crawling API macht das Scraping von Google Hotels einfach, indem es JavaScript-Rendering, rotierende IPs zur Vermeidung von Blockierungen, schnelle und zuverlässige Datenextraktion und benutzerdefinierte Anfrageoptionen zur Nachahmung echter Benutzer handhabt.

Crawlbase Python-Bibliothek

Um es noch einfacher zu machen, bietet Crawlbase eine Python-Bibliothek mit dem interagieren Crawling API. Alles, was Sie brauchen, ist ein Crawlbase-Zugriffstoken, das Sie nach der Anmeldung erhalten (wir bieten 1,000 kostenlose Anfragen ohne Kreditkarte an).

Hier ist ein einfaches Beispiel:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
von Crawlbase importieren CrawlingAPI

# Initialisieren Sie die Crawlbase-API mit Ihrem Zugriffstoken
crawling_api = CrawlingAPI({ 'Zeichen': 'IHR_CRAWLBASE_TOKEN' })

def Crawlbase-Anfrage erstellen(URL):
    Antwort = crawling_api.get(URL)

    if Antwort['Kopfzeilen']['pc_status'] == '200':
        html_content = Antwort['Körper'].dekodieren('utf-8')
        Rückkehr HTML-Inhalt
    sonst:
        drucken(f"Seite konnte nicht abgerufen werden. Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Non

Mit dieser Einrichtung können Sie mit der Extraktion von Hoteleinträgen und -details aus Google Hotels beginnen. Im nächsten Abschnitt richten wir die Python-Umgebung für das Scraping ein.

Einrichten Ihrer Python-Umgebung

Bevor Sie Google Hotels scrapen, müssen Sie Ihre Python-Umgebung vorbereiten. Dazu gehört die Installation von Python selbst und einiger wichtiger Bibliotheken zum Senden von Anfragen und Extrahieren von Daten.

🐍 Python installieren

Wenn Sie Python noch nicht installiert haben, laden Sie die neueste Version von der offizielle Python-Website. Achten Sie bei der Installation darauf, das Kontrollkästchen „Python zu PATH hinzufügen„ – damit können Sie Python von der Befehlszeile aus ausführen.

Um zu überprüfen, ob Python installiert ist, führen Sie Folgendes in Ihrem Terminal oder Ihrer Eingabeaufforderung aus:

1
Python --Version

Sie sollten die installierte Versionsnummer sehen.

✅ Installieren Sie die erforderlichen Bibliotheken

Zum Scrapen von Google Hotels verwenden wir:

  • carwlbase – Um HTTP-Anfragen zu senden, verwenden Sie Crawlbase Crawling API.
  • beautifulsoup4 – zum Analysieren und Extrahieren von Inhalten aus HTML.

Installieren Sie sie mit pip:

1
2
Pip Installationsanforderungen
pip install beautifulsoup4

📝 Erstellen Sie Ihre Python-Datei

Erstellen Sie neue Dateien, in die Sie Ihren Scraping-Code schreiben, zum Beispiel:

1
2
aufnehmen google_hotels_listing_scraper.py
aufnehmen google_hotel_details_scraper.py

Oder erstellen Sie sie einfach manuell in Ihrem bevorzugten Code-Editor.

🔑 Holen Sie sich Ihr Crawlbase-Token

Falls Sie es noch nicht getan haben, melden Sie sich an unter Crawlbase und erhalten Sie Ihr API-Token. Sie benötigen dieses Token zur Authentifizierung Ihrer Scraping-Anfragen.

1
2
3
4
von Crawlbase importieren CrawlingAPI

# Ersetzen Sie CRAWLBSE_JS_TOKEN durch Ihr tatsächliches Token.
crawling_api = CrawlingAPI({ 'Zeichen': 'CRAWLBASE_JS_TOKEN' })

Hinweis: Crawlbase bietet zwei Arten von Token an: einen normalen Token für statische Websites und einen JS-Token für JS-gerenderte Websites. Für das Scraping von Google Hotels benötigen wir einen JS-Token. Siehe die Dokumentation für mehr.

Damit ist Ihre Einrichtung abgeschlossen. Als Nächstes überprüfen wir die HTML-Struktur von Google Hotels und beginnen mit der Erstellung des Scrapers.

Scraping der Google Hotels-Suchergebnisse

In diesem Abschnitt werden wir Hotellisten von Google Hotels mit Python, BeautifulSoup und der Crawlbase scrapen. Crawling API. Sie erfahren, wie Sie Hoteldetails extrahieren, die Paginierung handhaben und Daten in einer JSON-Datei speichern.

🧩 Überprüfen des HTML auf Selektoren

Zuerst öffnen Google Hotels Suchen Sie in Ihrem Browser nach einem Ort (z. B. „New York“) und überprüfen Sie die Seite.

Screenshot der HTML-Prüfung der Scraping-Suchergebnisse von Google Hotels

Hier sind einige wichtige CSS-Klassen, die in den Hotellisten verwendet werden:

  • Hotelkarte:div.BcKagd
  • Hotelname: h2.BgYkof
  • Preis: span.qQOQpe.prxS3d
  • Rating: span.KFi5wf.lA0BZ

Wir werden diese Selektoren in unserem Scraper verwenden.

🧪 Schreiben des Hotels Listings Scraper

Schreiben wir nun eine Funktion zum Extrahieren von Hoteldaten mit Crawlbase und BeautifulSoup.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
von Crawlbase importieren CrawlingAPI
von bs4 importieren BeautifulSuppe
importieren JSON

crawling_api = CrawlingAPI({ 'Zeichen': 'CRAWLBASE_JS_TOKEN' })

def Crawlbase-Anfrage erstellen(URL):
    Antwort = crawling_api.get(URL)
    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    Rückkehr Non

def parse_hotel_listings(html):
    Suppe = Schöne Suppe (html, "html.parser")
    hotel_data = []

    Hotels = Suppe.find_all("div", Klasse_="BcKagd")
    für  Hotels in Hotels:
        Name = Hotel.find("h2", Klasse_="BgYkof")
        Preis = Hotel.find("Spanne", Klasse_=„qQOQpe prxS3d“)
        Bewertung = Hotel.find("Spanne", Klasse_=„KFi5wf lA0BZ“)
        Link = Hotel.Finden("ein", Klasse_="PVOOXe")

        hotel_data.append({
            "Name": Name.Text if Name sonst "N / A",
            "Preis": Preis.Text if Preis  sonst "N / A",
            "Bewertung": Bewertungstext if Wertung sonst "N / A",
            "Verknüpfung": "https://www.google.com" + Link["href"] if Link sonst "N / A"
        })

    Rückkehr hotel_data

🔁 Handhabung der Paginierung

Google Hotels lädt mehr Ergebnisse über mehrere Seiten hinweg. Mit der Crawlbase Crawling APIkönnen wir Tastenklicks simulieren mit dem css_click_selector Parameter. Wir können auch den ajax_wait Parameter, um sicherzustellen, dass der Inhalt nach dem Klick vollständig geladen wird. Dadurch wird sichergestellt, Crawling API Gibt das vollständige HTML der nächsten Seite zurück, nachdem auf die Schaltfläche geklickt und der Inhalt gerendert wurde.

Lassen Sie uns unsere aktualisieren make_crawlbase_request Funktion zum Einschließen dieser Parameter und Hinzufügen einer Ausnahmebehandlung für eine bessere Zuverlässigkeit:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def Crawlbase-Anfrage erstellen(URL, CSS_Click_Element =Non):
    versuchen:
        Optionen = {}

        if css_click_element:
            Optionen['css_click_selector'] = CSS-Klickelement
            Optionen['ajax_wait'] = "wahr"

        Antwort = crawling_api.get(URL, Optionen)
        if Antwort['Kopfzeilen'].erhalten('pc_status') == '200':
            Rückkehr Antwort['Körper'].dekodieren('utf-8')

        Rückkehr Antwort

    ausgeschlossen Exception as e:
        drucken(f"Fehler bei der Crawlbase-Anfrage: {e}")
        Rückkehr {}

💾 Speichern von Daten in einer JSON-Datei

Nachdem Sie alle Hoteldaten erfasst haben, speichern Sie sie in einer JSON-Datei:

1
2
3
def in JSON speichern(Daten, Dateiname="google_hotels.json"):
    mit XNUMXh geöffnet(Dateiname, "w", Kodierung="utf-8") as f:
        json.dump(Daten, f, Ensure_ASCII=falsch, Einzug=2)

✅ Vollständiges Codebeispiel

Hier ist der vollständige Code, der alle oben genannten Schritte kombiniert:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
von Crawlbase importieren CrawlingAPI
von bs4 importieren BeautifulSuppe
importieren JSON

crawling_api = CrawlingAPI({ 'Zeichen': 'CRAWLBASE_JS_TOKEN' })

def Crawlbase-Anfrage erstellen(URL, CSS_Click_Element =Non):
    versuchen:
        Optionen = {}

        if css_click_element:
            Optionen['css_click_selector'] = CSS-Klickelement
            Optionen['ajax_wait'] = "wahr"

        Antwort = crawling_api.get(URL, Optionen)
        if Antwort['Kopfzeilen'].erhalten('pc_status') == '200':
            Rückkehr Antwort['Körper'].dekodieren('utf-8')

        Rückkehr Antwort

    ausgeschlossen Exception as e:
        drucken(f"Fehler bei der Crawlbase-Anfrage: {e}")
        Rückkehr {}

def parse_hotel_listings(html):
    Suppe = Schöne Suppe (html, "html.parser")
    hotel_data = []

    Hotels = Suppe.find_all("div", Klasse_="BcKagd")
    für  Hotels in Hotels:
        Name = Hotel.find("h2", Klasse_="BgYkof")
        Preis = Hotel.find("Spanne", Klasse_=„qQOQpe prxS3d“)
        Bewertung = Hotel.find("Spanne", Klasse_=„KFi5wf lA0BZ“)
        Link = Hotel.Finden("ein", Klasse_="PVOOXe")

        hotel_data.append({
            "Name": Name.Text if Name sonst "N / A",
            "Preis": Preis.Text if Preis  sonst "N / A",
            "Bewertung": Bewertungstext if Wertung sonst "N / A",
            "Verknüpfung": "https://www.google.com" + Link["href"] if Link sonst "N / A"
        })

    Rückkehr hotel_data

def in JSON speichern(Daten, Dateiname="google_hotels.json"):
    mit XNUMXh geöffnet(Dateiname, "w", Kodierung="utf-8") as f:
        json.dump(Daten, f, Ensure_ASCII=falsch, Einzug=2)

def Haupt-†
    URL = „https://www.google.com/travel/hotels/New-York?q=New+York¤cy=USD“
    alle_hotels = []
    max_pages = 2
    Seitenanzahl = 0

    während Seitenanzahl < max. Seiten:
        html = ''

        if Seitenanzahl == 0:
            # Für die 1. Seite
            html = make_crawlbase_request(URL)
        sonst:
            # Für die nächsten Seiten
            html = make_crawlbase_request(URL, 'button[jsname="OCpkoe"]')

        if nicht html:
            brechen

        Hotels = parse_hotel_listings(html)
        all_hotels.extend(Hotels)

        Seitenanzahl += 1

    save_to_json(alle_Hotels)
    drucken(f"Gekratzt {len(alle_hotels)} Hotels und in google_hotels.json gespeichert")

if __name__ == "__hauptsächlich__":
    Main()

Beispielausgabe:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
[
  {
    "Name": "31 Street Broadway Hotel",
    "Preis": "$ 59",
    "Bewertung": "2.5",
    "Verknüpfung": "https://www.google.com/travel/search?q=New%20York&qs=MihDaG9JeFBLSXpvWDR6SWZMQVJvTkwyY3ZNVEZ3ZDJnMU4yYzFOUkFCOAA&currency=USD&ved=2ahUKEwiY1rucg9CMAxUIAPkAHXyaE5EQyvcEegQIAxA-&ap=KigKEgm4tF8JXhxEQBF5jsg3iI5SwBISCfZ7hYTLm0RAEXmOyLfKcVLA&ts=CAESCgoCCAMKAggDEAAaXAo-EjwKCS9tLzAyXzI4NjIlMHg4OWMyNGZhNWQzM2YwODNiOjB4YzgwYjhmMDZlMTc3ZmU2MjoITmV3IFlvcmsSGhIUCgcI6Q8QBBgQEgcI6Q8QBBgRGAEyAhAAKgcKBToDVVNE"
  },
  {
    "Name": "Das One Boutique Hotel",
    "Preis": "$ 90",
    "Bewertung": "3.3",
    "Verknüpfung": "https://www.google.com/travel/search?q=New%20York&qs=MidDaGtJZ0t6dDBjdkZ6dG1jQVJvTUwyY3ZNWEUxWW14eWF6a3pFQUU4AA&currency=USD&ved=2ahUKEwiY1rucg9CMAxUIAPkAHXyaE5EQyvcEegQIAxBV&ap=KigKEgm4tF8JXhxEQBF5jsg3iI5SwBISCfZ7hYTLm0RAEXmOyLfKcVLA&ts=CAESCgoCCAMKAggDEAAaXAo-EjwKCS9tLzAyXzI4NjIlMHg4OWMyNGZhNWQzM2YwODNiOjB4YzgwYjhmMDZlMTc3ZmU2MjoITmV3IFlvcmsSGhIUCgcI6Q8QBBgQEgcI6Q8QBBgRGAEyAhAAKgcKBToDVVNE"
  },
  {
    "Name": "Ly New York Hotel",
    "Preis": "$ 153",
    "Bewertung": "4.4",
    "Verknüpfung": "https://www.google.com/travel/search?q=New%20York&qs=MihDaG9JbU9UeXpldUN6cnlrQVJvTkwyY3ZNVEYyY0d3MGJuSXpZaEFCOAA&currency=USD&ved=2ahUKEwiY1rucg9CMAxUIAPkAHXyaE5EQyvcEegQIAxBu&ap=KigKEgm4tF8JXhxEQBF5jsg3iI5SwBISCfZ7hYTLm0RAEXmOyLfKcVLA&ts=CAESCgoCCAMKAggDEAAaXAo-EjwKCS9tLzAyXzI4NjIlMHg4OWMyNGZhNWQzM2YwODNiOjB4YzgwYjhmMDZlMTc3ZmU2MjoITmV3IFlvcmsSGhIUCgcI6Q8QBBgQEgcI6Q8QBBgRGAEyAhAAKgcKBToDVVNE"
  },
  {
    "Name": "King Hotel Brooklyn Sunset Park",
    "Preis": "$ 75",
    "Bewertung": "3.4",
    "Verknüpfung": "https://www.google.com/travel/search?q=New%20York&qs=MihDaG9JbllMLW1iTG5uLTNDQVJvTkwyY3ZNVEZ5ZDNKNWQyUXdiQkFCOAA&currency=USD&ved=2ahUKEwiY1rucg9CMAxUIAPkAHXyaE5EQyvcEegUIAxCJAQ&ap=KigKEgm4tF8JXhxEQBF5jsg3iI5SwBISCfZ7hYTLm0RAEXmOyLfKcVLA&ts=CAESCgoCCAMKAggDEAAaXAo-EjwKCS9tLzAyXzI4NjIlMHg4OWMyNGZhNWQzM2YwODNiOjB4YzgwYjhmMDZlMTc3ZmU2MjoITmV3IFlvcmsSGhIUCgcI6Q8QBBgQEgcI6Q8QBBgRGAEyAhAAKgcKBToDVVNE"
  },
  {
    "Name": "Ein Mann in New York",
    "Preis": "$ 2,200",
    "Bewertung": "4.4",
    "Verknüpfung": "https://www.google.com/travel/search?q=New%20York&qs=MidDaGtJc3Q3dF80YmhzWW9ZR2cwdlp5OHhNV1kyTW1Sd2VIbHNFQUU4AA&currency=USD&ved=2ahUKEwiY1rucg9CMAxUIAPkAHXyaE5EQyvcEegUIAxCiAQ&ap=KigKEgm4tF8JXhxEQBF5jsg3iI5SwBISCfZ7hYTLm0RAEXmOyLfKcVLA&ts=CAESCgoCCAMKAggDEAAaXAo-EjwKCS9tLzAyXzI4NjIlMHg4OWMyNGZhNWQzM2YwODNiOjB4YzgwYjhmMDZlMTc3ZmU2MjoITmV3IFlvcmsSGhIUCgcI6Q8QBBgQEgcI6Q8QBBgRGAEyAhAAKgcKBToDVVNE"
  },
  .... mehr
]

Nachdem wir nun die Hoteleinträge aus den Suchergebnissen extrahiert haben, besteht der nächste Schritt darin, Details aus den einzelnen Hotelseiten zu extrahieren.

Extrahieren individueller Hoteldetails

Sobald wir eine Liste mit Hotellinks aus den Suchergebnissen haben, können wir die jeweilige Hotelseite besuchen, um weitere Informationen wie die vollständige Adresse, Telefonnummer und zusätzliche Hotelmerkmale abzurufen. Dies verschafft uns ein tieferes Verständnis der Unterkunft und ist nützlich für Wettbewerbsanalysen, Preisverfolgung oder die Entwicklung von Reise-Apps.

🔍 Überprüfen des HTML-Codes auf Hoteldetails

Öffnen Sie einen Hotellink in Ihrem Browser und verwenden Sie das Prüftool Ihres Browsers, um Selektoren für wichtige Felder zu finden:

Screenshot der Scraping-HTML-Inspektion für individuelle Hoteldetails von Google
  • Hotelname: Gefunden in einem <h1> Tag mit Klasse FNkAEc.
  • Preis: Befindet sich in einem <span> Tag mit Klassen qQOQpe prxS3d.
  • Bewertung: Auszug aus einer <span> mit Klassen KFi5wf lA0BZ.
  • Anzahl der Bewertungen: Gefunden in einem <span> mit Klassen jdzyld XLC8M, neben der Bewertung.
  • Hoteltyp: Gefunden in einem <span> mit Klasse CFH2De.
  • Adresse und Kontakt: Befindet sich in einem div mit Klasse K4nuhf, woher:
  • spans[0] gibt die Adresse
  • spans[2] gibt die Kontaktinformationen

Hinweis: Diese Selektoren können sich je nach Standort und Layout ändern. Überprüfen Sie sie vor dem Scraping immer in Ihrem eigenen Browser.

🧰 Schreiben des Details Scrapers

Erstellen wir mithilfe der identifizierten CSS-Selektoren einen Google Hotel Details Scraper mit BeautifulSoup.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
von Crawlbase importieren CrawlingAPI
von bs4 importieren BeautifulSuppe
importieren JSON

crawling_api = CrawlingAPI({ 'Zeichen': 'CRAWLBASE_JS_TOKEN' })

def Crawlbase-Anfrage erstellen(URL):
    Antwort = crawling_api.get(URL)
    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    Rückkehr Non

def parse_hotel_details(hotel_url):
    html = make_crawlbase_request(Hotel-URL)
    if nicht html:
        Rückkehr Non

    Suppe = Schöne Suppe (html, "html.parser")

    Name = Suppe.find("h1", Klasse_="FNkAEc")
    Preis = Suppe.find("Spanne", Klasse_=„qQOQpe prxS3d“)
    Bewertung = Suppe.find("Spanne", Klasse_=„KFi5wf lA0BZ“)
    Bewertungen = Suppe.find("Spanne", Klasse_="jdzyld XLC8M")
    hotel_type = soup.find("Spanne", Klasse_="CFH2De")

    Adresse = "N / A"
    Kontakt = "N / A"

    Standortabschnitt = soup.find_all("div", Klasse_="K4nuhf")
    if Standortabschnitt:
        Spannweiten = Standortabschnitt[0].find_all("Spanne")
        if len(Spannweiten) >= 3:
            Adresse = Spannen[0].Text
            Kontakt = Spannen[2].Text

    Rückkehr {
        "Name": Name.Text if Name sonst "N / A",
        "Preis": Preis.Text if Preis  sonst "N / A",
        "Bewertung": Bewertungstext if Wertung sonst "N / A",
        "Anzahl_der_Bewertungen": Bewertungen.text if Rezensionen sonst "N / A",
        "Hoteltyp": hotel_type.text if Hoteltyp sonst "N / A",
        "Adresse": Adresse,
        "Kontakt": Kontakt,
        "Verknüpfung": hotel_url
    }

💾 Hoteldetails in JSON speichern

Sie können Hoteldetaildaten in einer Liste sammeln und diese wie die Einträge speichern.

1
2
3
def Detaillierte Daten speichern(hotel_details, Dateiname="google_hotel_details.json"):
    mit XNUMXh geöffnet(Dateiname, "w", Kodierung="utf-8") as f:
        json.dump(hotel_details, f, ensure_ascii=falsch, Einzug=2)

🧩 Vollständiges Codebeispiel

So können Sie die Liste der Hotellinks durchlaufen und für jeden Link alle Details extrahieren:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
von Crawlbase importieren CrawlingAPI
von bs4 importieren BeautifulSuppe
importieren JSON

crawling_api = CrawlingAPI({ 'Zeichen': 'CRAWLBASE_JS_TOKEN' })

def Crawlbase-Anfrage erstellen(URL):
    Antwort = crawling_api.get(URL)
    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    Rückkehr Non

def parse_hotel_details(hotel_url):
    html = make_crawlbase_request(Hotel-URL)
    if nicht html:
        Rückkehr Non

    Suppe = Schöne Suppe (html, "html.parser")

    Name = Suppe.find("h1", Klasse_="FNkAEc")
    Preis = Suppe.find("Spanne", Klasse_=„qQOQpe prxS3d“)
    Bewertung = Suppe.find("Spanne", Klasse_=„KFi5wf lA0BZ“)
    Bewertungen = Suppe.find("Spanne", Klasse_="jdzyld XLC8M")
    hotel_type = soup.find("Spanne", Klasse_="CFH2De")

    Adresse = "N / A"
    Kontakt = "N / A"

    Standortabschnitt = soup.find_all("div", Klasse_="K4nuhf")
    if Standortabschnitt:
        Spannweiten = Standortabschnitt[0].find_all("Spanne")
        if len(Spannweiten) >= 3:
            Adresse = Spannen[0].Text
            Kontakt = Spannen[2].Text

    Rückkehr {
        "Name": Name.Text if Name sonst "N / A",
        "Preis": Preis.Text if Preis  sonst "N / A",
        "Bewertung": Bewertungstext if Wertung sonst "N / A",
        "Anzahl_der_Bewertungen": Bewertungen.text if Rezensionen sonst "N / A",
        "Hoteltyp": hotel_type.text if Hoteltyp sonst "N / A",
        "Adresse": Adresse,
        "Kontakt": Kontakt,
        "Verknüpfung": hotel_url
    }

def Detaillierte Daten speichern(hotel_details, Dateiname="google_hotel_details.json"):
    mit XNUMXh geöffnet(Dateiname, "w", Kodierung="utf-8") as f:
        json.dump(hotel_details, f, ensure_ascii=falsch, Einzug=2)

def Haupt-†
    # Beispiel-Eingabeliste vom Listings Scraper
    hotel_links = [
        "https://www.google.com/travel/search?q=New%20York&qs=MihDaG9JeFBLSXpvWDR6SWZMQVJvTkwyY3ZNVEZ3ZDJnMU4yYzFOUkFCOAA&currency=USD&ved=2ahUKEwiY1rucg9CMAxUIAPkAHXyaE5EQyvcEegQIAxA-&ap=KigKEgm4tF8JXhxEQBF5jsg3iI5SwBISCfZ7hYTLm0RAEXmOyLfKcVLA&ts=CAESCgoCCAMKAggDEAAaXAo-EjwKCS9tLzAyXzI4NjIlMHg4OWMyNGZhNWQzM2YwODNiOjB4YzgwYjhmMDZlMTc3ZmU2MjoITmV3IFlvcmsSGhIUCgcI6Q8QBBgQEgcI6Q8QBBgRGAEyAhAAKgcKBToDVVNE",
        "https://www.google.com/travel/search?q=New%20York&qs=MidDaGtJZ0t6dDBjdkZ6dG1jQVJvTUwyY3ZNWEUxWW14eWF6a3pFQUU4AA&currency=USD&ved=2ahUKEwiY1rucg9CMAxUIAPkAHXyaE5EQyvcEegQIAxBV&ap=KigKEgm4tF8JXhxEQBF5jsg3iI5SwBISCfZ7hYTLm0RAEXmOyLfKcVLA&ts=CAESCgoCCAMKAggDEAAaXAo-EjwKCS9tLzAyXzI4NjIlMHg4OWMyNGZhNWQzM2YwODNiOjB4YzgwYjhmMDZlMTc3ZmU2MjoITmV3IFlvcmsSGhIUCgcI6Q8QBBgQEgcI6Q8QBBgRGAEyAhAAKgcKBToDVVNE"
    ]

    detaillierte_hotels = []

    für  URL in hotel_links:
        Daten = parse_hotel_details(URL)
        if Daten:
            detailed_hotels.append(Daten)

    save_detailed_data(detaillierte_Hotels)
    drucken(f"Gespeicherte Daten von {len(detaillierte_Hotels)} Hotels zu google_hotel_details.json")

if __name__ == "__hauptsächlich__":
    Main()

Beispielausgabe:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
[
  {
    "Name": "31 Street Broadway Hotel",
    "Preis": "$ 59",
    "Bewertung": "3.8",
    "Anzahl_der_Bewertungen": " (461)",
    "Hoteltyp": "2-Sterne-Hotel",
    "Adresse": „38 W 31st St #110, New York, NY 10001“,
    "Kontakt": "(516) 770-8751",
    "Verknüpfung": "https://www.google.com/travel/search?q=New%20York&qs=MihDaG9JeFBLSXpvWDR6SWZMQVJvTkwyY3ZNVEZ3ZDJnMU4yYzFOUkFCOAA&currency=USD&ved=2ahUKEwiY1rucg9CMAxUIAPkAHXyaE5EQyvcEegQIAxA-&ap=KigKEgm4tF8JXhxEQBF5jsg3iI5SwBISCfZ7hYTLm0RAEXmOyLfKcVLA&ts=CAESCgoCCAMKAggDEAAaXAo-EjwKCS9tLzAyXzI4NjIlMHg4OWMyNGZhNWQzM2YwODNiOjB4YzgwYjhmMDZlMTc3ZmU2MjoITmV3IFlvcmsSGhIUCgcI6Q8QBBgQEgcI6Q8QBBgRGAEyAhAAKgcKBToDVVNE"
  },
  {
    "Name": "Das One Boutique Hotel",
    "Preis": "$ 90",
    "Bewertung": "4.5",
    "Anzahl_der_Bewertungen": " (1.2 KB)",
    "Hoteltyp": "3-Sterne-Hotel",
    "Adresse": „137-72 Northern Blvd, Flushing, NY 11354“,
    "Kontakt": "(718) 886-3555",
    "Verknüpfung": "https://www.google.com/travel/search?q=New%20York&qs=MidDaGtJZ0t6dDBjdkZ6dG1jQVJvTUwyY3ZNWEUxWW14eWF6a3pFQUU4AA&currency=USD&ved=2ahUKEwiY1rucg9CMAxUIAPkAHXyaE5EQyvcEegQIAxBV&ap=KigKEgm4tF8JXhxEQBF5jsg3iI5SwBISCfZ7hYTLm0RAEXmOyLfKcVLA&ts=CAESCgoCCAMKAggDEAAaXAo-EjwKCS9tLzAyXzI4NjIlMHg4OWMyNGZhNWQzM2YwODNiOjB4YzgwYjhmMDZlMTc3ZmU2MjoITmV3IFlvcmsSGhIUCgcI6Q8QBBgQEgcI6Q8QBBgRGAEyAhAAKgcKBToDVVNE"
  }
]

Abschließende Überlegungen

Durch das Scraping von Google Hotels sammeln Sie wertvolle Daten wie Hotelnamen, Preise, Bewertungen, Bewertungen, Adressen und Kontaktinformationen. Diese Daten sind wertvoll für die Reiserecherche, den Aufbau von Hotelvergleichstools oder die Beobachtung von Markttrends.

Verwendung der Crawlbase Crawling API Erleichtert das Scrapen dynamischer Inhalte und vermeidet Blockaden oder CAPTCHAs. In Kombination mit BeautifulSoup zum Parsen und JSON zum Speichern von Daten können Sie einen einfachen, aber leistungsstarken Scraper in Python erstellen.

Befolgen Sie beim Scraping von Hoteldaten stets die ethischen und rechtlichen Best Practices, um die Sicherheit und Konformität Ihrer Projekte zu gewährleisten.

Möchten Sie weitere Plattformen scrapen? Schauen Sie sich unsere anderen Scraping-Anleitungen an:

📘 So scrapen Sie Google Finance
📘 So scrapen Sie Google News
📘 So scrapen Sie Google Scholar-Ergebnisse
📘 So kratzen Sie die Google-Suchergebnisse
📘 So scrapen Sie Google Shopping

Wenn Sie Fragen oder Ideen haben oder Hilfe benötigen, ist unser Team für Sie da. Vielen Dank fürs Lesen und viel Spaß beim Scrappen!

Häufig gestellte Fragen

Das Scraping öffentlicher Daten von Websites wie Google Hotels kann legal sein, sofern es ethisch korrekt und im Rahmen der Nutzungsbedingungen der Website erfolgt. Vermeiden Sie stets das Scraping personenbezogener Daten und halten Sie die lokalen Datenschutzgesetze und Scraping-Vorschriften ein.

F. Warum Crawlbase verwenden? Crawling API zum Scrapen von Google Hotels?

Die Inhalte von Google Hotels werden dynamisch mithilfe von JavaScript geladen, was mit herkömmlichen Tools schwierig zu erfassen sein kann. Die Crawlbase Crawling API lädt vollständiges HTML wie ein echter Browser und verarbeitet JavaScript, Paginierung, CAPTCHAs und IP-Rotation – wodurch Ihr Scraping schneller, einfacher und zuverlässiger wird.

F: Welche Daten kann ich aus Google Hotels extrahieren?

Sie können Hotelname, Preis, Adresse, Bewertung, Anzahl der Bewertungen, Hoteltyp und Kontaktdaten extrahieren. Diese Informationen sind nützlich für Hotelanalysen, Preisüberwachung, Marktforschung und reisebezogene Apps.