Große Städte weltweit meldeten kürzlich einen Anstieg der Hauspreise aus verschiedenen Gründen. Immobiliendaten gehören heute zu den am häufigsten gesuchten Informationen, da immer mehr Menschen die Technologie nutzen, um diese Herausforderung zu meistern. Häuser.com ist eine nützliche Ressource im Immobiliensektor mit einer umfangreichen Datenbank mit Immobilienangeboten in den gesamten Vereinigten Staaten. Die meisten Interessenten nutzen die Website, um bequem wichtige Informationen wie Preise, Standorte und andere Einzelheiten zu sammeln.

Das Durchsuchen von Hunderten von Seiten auf Homes.com kann jedoch eine entmutigende Aufgabe sein. Deshalb ist das Scraping von homes.com eine gute Gelegenheit für Käufer, Investoren und Verkäufer, wertvolle Einblicke in die Immobilienpreise in den Vereinigten Staaten zu gewinnen.

In diesem Blog erfahren Sie, wie Sie homes.com mit Python scrapen und Crawlbase. Es werden die Grundlagen der Einrichtung Ihrer Umgebung für den Umgang mit Anti-Scraping-Maßnahmen erläutert, sodass Sie einen guten Homes.com-Scraper erstellen können.

Hier ist eine ausführliche Anleitung zum Scrapen von Immobiliendaten auf Homes.com:

Inhaltsverzeichnis

  1. Warum Immobiliendaten von homes.com scrapen?
  2. Was können wir von homes.com scrapen?
  3. Umgehen Sie die Homes.com-Blockierung mit Crawlbase
  • Überblick über die Anti-Scraping-Maßnahmen von Homes.com
  • Crawlbase verwenden Crawling API für sanftes Schaben
  1. Umgebungs-Setup für homes.com Scraping
  2. So durchsuchen Sie die Suchseiten von homes.com
  3. So scrapen Sie Immobilienseiten von homes.com
  4. Abschließende Überlegungen
  5. Häufig gestellte Fragen (FAQs)

Warum Immobiliendaten von homes.com scrapen?

Ein Bild, das die Gründe für das Scraping der Immobiliendaten von homes.com zeigt: Anpassung und Maßanfertigung, Marktanalyse, Forschung und Erkenntnisse, Wettbewerbsvorteile, Investitionsmöglichkeiten, Business Intelligence sowie Automatisierung und Effizienz

Es gibt viele Gründe, warum Sie homes.com durchsuchen möchten. Angenommen, Sie sind ein Immobilienprofi oder -analyst. In diesem Fall können Sie Daten von homes.com sammeln, um dem Markt immer einen Schritt voraus zu sein und einen guten Einblick in Immobilienwerte, Mietpreise, Nachbarschaftsstatistiken usw. zu erhalten. Diese Informationen sind für die Entscheidung über Investitionen und Marketingstrategien von entscheidender Bedeutung.

Wenn Sie Entwickler oder Datenwissenschaftler sind, können Sie mit dem Scraping von homes.com mit Python eine leistungsstarke Anwendung erstellen, die Daten als Grundlage verwendet. Durch die Erstellung eines Homes.com-Scrapers können Sie den Prozess der Erfassung und Analyse von Immobiliendaten automatisieren und so Zeit und Aufwand sparen. Darüber hinaus kann Ihnen der Zugriff auf aktuelle Immobilienangebote dabei helfen, neue Trends und Chancen auf dem Immobilienmarkt zu erkennen.

Insgesamt kann die Abschaffung von homes.com jedem in der Immobilienbranche Tätigen viele Vorteile bringen – egal, ob es sich um Investoren, Makler, Datenwissenschaftler oder Projektentwickler handelt.

Was können wir von homes.com scrapen?

Hier ist ein kleiner Einblick in das, was Sie von homes.com abrufen können:

Ein Bild, das die verschiedenen Datentypen zeigt, die von Homes.com abgerufen werden können

Ein Bild, das die verschiedenen Datentypen zeigt, die von Homes.com abgerufen werden können

  1. Property Listings: Die Immobilienangebote von Homes.com bieten Informationen zu verfügbaren Häusern, Wohnungen, Eigentumswohnungen und mehr. Durch das Scraping dieser Angebote erhalten Sie Daten zu wichtigen Merkmalen, Annehmlichkeiten und Bildern der Immobilien.
  2. Pricing Information: Die Kenntnis der Preistrends auf dem Immobilienmarkt ist der Schlüssel zu einer vorteilhaften Position. Durch das Scraping von Preisinformationen von homes.com können Sie Preisschwankungen im Laufe der Zeit und an verschiedenen Standorten analysieren.
  3. Details der Immobilie: Neben den grundlegenden Angaben stellt homes.com den Kunden auch ausführliche Informationen zur Immobilie zur Verfügung, darunter Quadratmeterzahl, Anzahl der Schlafzimmer und Badezimmer, Immobilientyp usw. Sie können alle diese Informationen abrufen, um jedes Inserat besser zu verstehen.
  4. Standortdaten: Die Lage spielt bei Immobilien eine wichtige Rolle. Das Scraping von Standortdaten von homes.com bietet Einblicke in die Annehmlichkeiten der Nachbarschaft, Schulen, Transportmöglichkeiten und mehr und hilft Ihnen dabei, die Attraktivität einer Immobilie einzuschätzen.
  5. Markt-Trends: Durch regelmäßiges Scraping von homes.com können Sie Markttrends und Schwankungen bei Angebot und Nachfrage verfolgen. Anhand dieser Daten können Sie neue Muster erkennen und zukünftige Marktbewegungen vorhersagen.
  6. Historische Daten: Historische Daten enthalten Daten über die Geschichte des Immobilienmarktes und sind nützlich, um vergangene Trends und Muster im Immobilienbereich zu untersuchen. Vorausgesetzt, Sie haben historische Angebots- und Preisdaten von homes.com abgerufen, können Sie nun Längsschnittstudien durchführen und langfristige Trends verstehen.
  7. Vergleichende Analyse: Mithilfe der Daten von Homes.com können Sie vergleichende Analysen durchführen und die Immobilien in derselben Nachbarschaft mit denen in der ganzen Stadt oder an mehreren Standorten vergleichen, an denen Sie Immobilien kaufen oder verkaufen möchten. Mit diesen Daten können Sie schnell feststellen, wer Ihre Konkurrenz ist, und sie zur Festlegung von Preisstrategien verwenden.
  8. Marktdynamik: Das Verständnis der Marktdynamik ist für die Navigation in der Immobilienlandschaft unerlässlich. Durch das Scraping von Daten von homes.com können Sie Faktoren wie Lagerbestände, Marktzeit und Inserathäufigkeit überwachen und erhalten so Einblicke in die Gesundheit und Stabilität des Marktes.

Umgehen Sie die Homes.com-Blockierung mit Crawlbase

Homes.com verwendet wie viele andere Websites JavaScript-Rendering und Anti-Scraping-Maßnahmen, um zu verhindern, dass automatisierte Bots auf die Seiten zugreifen und Daten extrahieren.

Überblick über die Anti-Scraping-Maßnahmen von Homes.com

Hier erfahren Sie, wie Homes.com versucht, Scraping zu verhindern:

  1. JS-Rendering: Homes.com verwendet wie viele andere Websites JavaScript (JS)-Rendering, um Inhalte dynamisch zu laden, was es für herkömmliche Scraping-Methoden, die ausschließlich auf HTML-Parsing basieren, schwieriger macht.
  2. IP-Blockierung: Homes.com kann den Zugriff auf seine Website von bestimmten IP-Adressen aus blockieren, wenn es automatisierte Scraping-Aktivitäten vermutet.
  3. CAPTCHAs: Um zu überprüfen, dass es sich bei den Benutzern um Menschen und nicht um Bots handelt, zeigt Homes.com möglicherweise CAPTCHAs an, die eine manuelle Interaktion erfordern, um fortzufahren.
  4. Rate Limiting: Homes.com kann die Anzahl der Anfragen, die ein Benutzer innerhalb eines bestimmten Zeitraums stellen kann, begrenzen, um eine Scraping-Überlastung zu verhindern.

Diese Maßnahmen erschweren das Scraping von Daten von Homes.com mit herkömmlichen Methoden.

Crawlbase verwenden Crawling API für sanftes Schaben

Crawlbase bietet eine zuverlässige Lösung zum Scrapen von Daten von Homes.com unter Umgehung der Sperrmechanismen. Durch die Nutzung Crawlbases Crawling APIerhalten Sie Zugriff auf einen Pool von privaten IP-Adressen, wodurch ein nahtloser Scraping-Betrieb ohne Unterbrechungen gewährleistet wird. Parameter Damit können Sie jede Art von Schabeproblem mit Leichtigkeit lösen.

Crawling API kann JavaScript-Rendering verarbeiten, wodurch Sie dynamische Inhalte abrufen können, die mit einfachen Anfragen nicht zugänglich wären. Darüber hinaus verwaltet Crawlbase die Rotation von Benutzeragenten und CAPTCHA-Lösung, wodurch der Schabvorgang weiter verbessert wird.

Crawlbase bietet eine eigene Python-Bibliothek für eine einfache Integration. Die folgenden Schritte zeigen, wie Sie die Crawlbase-Bibliothek in Ihren Python-Projekten verwenden können:

  1. Installation: Installieren Sie Crawlbase Python Bibliothek durch Ausführen des folgenden Befehls.
1
pip installieren crawlbase
  1. Authentifizierung: Erhalten Sie einen Zugriffstoken durch ein Profil erstellen auf Crawlbase. Dieses Token wird zur Authentifizierung Ihrer Anfragen verwendet. Für homes.com benötigen wir JS-Token.

Hier ist eine Beispielfunktion, die die Verwendung der Crawling API aus der Crawlbase-Bibliothek, um Anfragen zu senden:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
für Crawlbase importieren CrawlingAPI

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

# Funktion zum Stellen einer Anfrage mithilfe der Crawlbase-API
def Crawlbase-Anfrage erstellen(URL):
    # Anfrage mit der Crawlbase-API senden
    Antwort = crawling_api.get(URL)

    # Prüfen Sie, ob die Anfrage erfolgreich war
    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. Crawlbase-Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine

Note: Die ersten 1000 Anfragen über das Crawling API sind kostenlos und es ist keine Kreditkarte erforderlich. Weitere Einzelheiten finden Sie in der API-Dokumentation.

Umgebungs-Setup für homes.com Scraping

Bevor Sie mit dem Scraping von homes.com beginnen, müssen Sie Ihre Umgebung so einrichten, dass ein reibungsloser und effizienter Prozess gewährleistet ist. Hier finden Sie eine Schritt-für-Schritt-Anleitung, die Ihnen den Einstieg erleichtert:

  1. Installieren Sie Python: Stellen Sie zunächst sicher, dass Python auf Ihrem Computer installiert ist. Sie können die neueste Version von Python von der offiziellen Website.
  2. Virtuelle Umgebung: Es wird empfohlen, eine virtuelle Umgebung zu erstellen, um Projektabhängigkeiten zu verwalten und Konflikte mit anderen Python-Projekten zu vermeiden. Navigieren Sie im Terminal zu Ihrem Projektverzeichnis und führen Sie den folgenden Befehl aus, um eine virtuelle Umgebung mit dem Namen „homes_scraping_env“ zu erstellen:
1
python -m venv homes_scraping_env

Aktivieren Sie die virtuelle Umgebung, indem Sie den entsprechenden Befehl basierend auf Ihrem Betriebssystem ausführen:

  • Unter Windows:

    1
    homes_scraping_env\Scripts\aktivieren

  • Unter macOS/Linux:

    1
    Quelle homes_scraping_env/bin/aktivieren
  1. Erforderliche Bibliotheken installieren: Installieren Sie als Nächstes die erforderlichen Bibliotheken für das Web Scraping. Sie benötigen Bibliotheken wie BeautifulSoup und Crawlbase, um homes.com effizient zu scrapen. Sie können diese Bibliotheken mit pip, dem Python-Paketmanager, installieren. Öffnen Sie einfach Ihre Eingabeaufforderung oder Ihr Terminal und führen Sie die folgenden Befehle aus:
1
2
pip install beautifulsoup4
pip installieren Crawlbase

  1. Code-Editor: Wählen Sie einen Code-Editor oder eine integrierte Entwicklungsumgebung (IDE) zum Schreiben und Ausführen Ihres Python-Codes. Beliebte Optionen sind PyCharm, Visual Studio Code und Jupyter Notizbuch. Installieren Sie Ihren bevorzugten Code-Editor und stellen Sie sicher, dass er für die Arbeit mit Python konfiguriert ist.

  2. Erstellen eines Python-Skripts: Erstellen Sie in der von Ihnen gewählten IDE eine neue Python-Datei, in die Sie Ihren Scraping-Code schreiben. Sie können diese Datei etwa „homes_scraper.py“ nennen. Dieses Skript enthält den Code zum Scraping von homes.com und zum Extrahieren der gewünschten Daten.

Wenn Sie diese Schritte befolgen, verfügen Sie über eine gut konfigurierte Umgebung, um homes.com effizient zu scrapen. Mit den richtigen Tools und Techniken können Sie wertvolle Daten von homes.com sammeln, die Ihre Immobilienaktivitäten unterstützen.

So durchsuchen Sie die Suchseiten von homes.com

Durch das Scraping von Immobilienangeboten von Homes.com können Sie wertvolle Einblicke in den Wohnungsmarkt erhalten.

Suchseite von homes.com

In diesem Abschnitt zeigen wir Ihnen, wie Sie mit dem unkomplizierten Python-Ansatz die Suchseiten von Homes.com scrapen.

Bibliotheken importieren

Wir müssen die erforderlichen Bibliotheken importieren: CrawlingAPI für die Erstellung von HTTP requests und BeautifulSoup zum Parsen von HTML-Inhalten.

1
2
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe

Initialisieren Crawling API

Holen Sie sich Ihr JS-Token von Crawlbase und initialisieren Sie damit die CrawlingAPI-Klasse.

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

Definieren von Konstanten

Legen Sie die Basis-URL für die Homes.com-Suchseiten und die JSON-Ausgabedatei fest. Um das JS-Rendering-Problem zu lösen, können wir verwenden ajax_wait und Seite_warten Parameter bereitgestellt von Crawling APIWir können auch eine kundenspezifische user_agent wie in den Optionen unten. Wir legen eine Begrenzung für die Anzahl der Seiten fest, die aus der Seitennummerierung entfernt werden sollen.

1
2
3
4
5
6
7
8
9
BASE_URL = „https://www.homes.com/los-angeles-ca/homes-for-rent“
OUTPUT_FILE = „Eigenschaften.json“
MAX_PAGES = 2

Optionen = {
    'ajax_wait': "wahr",
    'Seite_warten': 10000,
    "Benutzeragent": „Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, wie Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0“
}

Schabefunktion

Erstellen Sie eine Funktion zum Scrapen von Immobilienangeboten von Homes.com. Diese Funktion durchläuft die angegebene Anzahl von Seiten, stellt Anfragen an Homes.com und analysiert den HTML-Inhalt, um Immobiliendetails zu extrahieren.

Wir müssen die Seite untersuchen und einen CSS-Selektor finden, über den wir alle Listenelemente erhalten können.

Durchsuchen Sie die Suchlisten von homes.com

Jeder Eintrag befindet sich in einem div mit Klasse for-rent-content-container.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def scrape_listings†
    Eigenschaften = []  # Liste zum Speichern der Eigenschafteninformationen

    # Durch die Seiten blättern
    
für Seite in Angebot(1, MAX_PAGES + 1):
        URL = f'{BASE_URL}/p{Seite}/'
        drucken(f"Seite scrapen {Seite} of {URL}")

        versuchen:
            html_content = make_crawlbase_request(URL)
            if HTML-Inhalt:
                Suppe = Schöne Suppe (HTML-Inhalt, 'html.parser')
                Eigenschaftenliste = soup.select(„div.zu-mieten-Inhaltscontainer“)
                Eigenschaften.erweitern(Eigenschaftenliste)
        ausgeschlossen Exception as e:
            drucken(f"Anforderung auf Seite fehlgeschlagen {Seite}: {e}")

    Rückkehr immobilien

Parsing-Datum

Um relevante Details aus dem HTML-Inhalt zu extrahieren, benötigen wir eine Funktion, die das Soup-Objekt verarbeitet und bestimmte Informationen abruft. Wir können die Seite untersuchen und die Selektoren der Elemente finden, die die benötigten Informationen enthalten.

Scrape homes.com Sucheintragstitel

Im obigen Bild sehen Sie, dass sich der Titel in einem p Element mit Klasse property-name, sodass wir diese als Selektor verwenden können, um das Titelelement anzusprechen. Auf ähnliche Weise können wir Selektoren für andere Elemente finden, die wichtige Informationen enthalten, die wir benötigen.

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
def Eigenschaftendetails analysieren(immobilien):
    Eigenschaftsliste = []
    
für Resorts in Eigenschaften:
        Titelelement = Resorts.Wähle eine(„p.Eigenschaftsname“)
        Adresselement = Resorts.Wähle eine('p.adresse')
        info_container = Resorts.Wähle eine(„ul.detaillierte-Info-Container“)
        extra_info = info_container.alles_finden('li') if Infocontainer sonst []
        Beschreibung_Element = Resorts.Wähle eine(„p.Eigenschaftsbeschreibung“)
        url_elem = Resorts.Wähle eine('A')

        Titel = Titelelement.text.strip() if Titelelement sonst 'N / A'
        Adresse = Adresselement.Text.Strip() if Adresselement sonst 'N / A'
        Preis = Zusatzinfo[0].text.strip() if zusätzliche_informationen sonst 'N / A'
        Betten = Zusatzinfo[1].text.strip() if len(zusätzliche Informationen) > 1 sonst 'N / A'
        Bäder = Zusatzinfo[2].text.strip() if len(zusätzliche Informationen) > 2 sonst 'N / A'
        Beschreibung = Beschreibung_Element.Text.Streifen() if Beschreibungselement sonst 'N / A'
        url = BASE_URL + url_elem.get('href') if URL-Element sonst 'N / A'

        Eigenschaftsdaten = {
            „Titel“: Titel,
            "Adresse": Adresse,
            "Preis": Preis,
            "Betten": Betten,
            "Bad": Bäder,
            „Beschreibung“: Beschreibung,
            "URL": URL
        }
        property_list.append(Eigenschaftsdaten)

    Rückkehr Eigenschaftenliste

Diese Funktion verarbeitet die Liste der Eigenschaftselemente und extrahiert relevante Details. Sie gibt eine Liste von Wörterbüchern zurück, die die Eigenschaftsdetails enthalten.

Daten speichern

Als Nächstes benötigen wir eine Funktion zum Speichern der analysierten Eigenschaftsdetails in einer JSON-Datei.

1
2
3
4
5
importieren JSON

def Eigenschaftsdetails als JSON speichern(Eigenschaftsliste, Dateiname):
    mit XNUMXh geöffnet(Dateiname, 'w') as json_datei:
        json.dump(Eigenschaftsliste, JSON-Datei, Einzug=4)

Diese Funktion schreibt die gesammelten Eigenschaftsdaten zur einfachen Analyse in eine JSON-Datei.

Ausführen des Skripts

Kombinieren Sie abschließend die Scraping- und Parsing-Funktionen und führen Sie das Skript aus, um mit dem Sammeln von Daten von der Homes.com-Suchseite zu beginnen.

1
2
3
4
if __name__ == '__Main__':
    Eigenschaften = Scrape_Listings()
    Eigenschaftsliste = Eigenschaftsdetails analysieren(Eigenschaften)
    save_property_details_to_json(Eigenschaftsliste, AUSGABEDATEI)

Code vervollständigen

Unten finden Sie den vollständigen Code zum Scraping von Immobilienlisten für die Suchseite von homes.com.

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
78
79
80
81
82
83
84
85
86
87
88
für bs4 importieren BeautifulSuppe
für Crawlbase importieren CrawlingAPI
importieren JSON

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

BASE_URL = „https://www.homes.com/los-angeles-ca/homes-for-rent“
OUTPUT_FILE = „Eigenschaften.json“
MAX_PAGES = 2

Optionen = {
    'ajax_wait': "wahr",
    'Seite_warten': 10000,
    "Benutzeragent": „Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, wie Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0“
}

# Funktion zum Stellen einer Anfrage mithilfe der Crawlbase-API
def Crawlbase-Anfrage erstellen(URL):
    # Anfrage mit der Crawlbase-API senden
    Antwort = crawling_api.get(URL, Optionen)
    # Prüfen Sie, ob die Anfrage erfolgreich war
    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. Crawlbase-Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine

def scrape_listings†
    Eigenschaften = []  # Liste zum Speichern der Eigenschafteninformationen

    # Durch die Seiten blättern
    
für Seite in Angebot(1, MAX_PAGES + 1):
        URL = f'{BASE_URL}/p{Seite}/'
        drucken(f"Seite scrapen {Seite} of {URL}")

        versuchen:
            html_content = make_crawlbase_request(URL)
            if HTML-Inhalt:
                Suppe = Schöne Suppe (HTML-Inhalt, 'html.parser')
                Eigenschaftenliste = soup.select(„div.zu-mieten-Inhaltscontainer“)
                Eigenschaften.erweitern(Eigenschaftenliste)
        ausgeschlossen Exception as e:
            drucken(f"Anforderung auf Seite fehlgeschlagen {Seite}: {e}")

    Rückkehr immobilien

def Eigenschaftendetails analysieren(immobilien):
    Eigenschaftsliste = []
    
für Resorts in Eigenschaften:
        Titelelement = Resorts.Wähle eine(„p.Eigenschaftsname“)
        Adresselement = Resorts.Wähle eine('p.adresse')
        info_container = Resorts.Wähle eine(„ul.detaillierte-Info-Container“)
        extra_info = info_container.alles_finden('li') if Infocontainer sonst []
        Beschreibung_Element = Resorts.Wähle eine(„p.Eigenschaftsbeschreibung“)
        url_elem = Resorts.Wähle eine('A')

        Titel = Titelelement.text.strip() if Titelelement sonst 'N / A'
        Adresse = Adresselement.Text.Strip() if Adresselement sonst 'N / A'
        Preis = Zusatzinfo[0].text.strip() if zusätzliche_informationen sonst 'N / A'
        Betten = Zusatzinfo[1].text.strip() if len(zusätzliche Informationen) > 1 sonst 'N / A'
        Bäder = Zusatzinfo[2].text.strip() if len(zusätzliche Informationen) > 2 sonst 'N / A'
        Beschreibung = Beschreibung_Element.Text.Streifen() if Beschreibungselement sonst 'N / A'
        url = BASE_URL + url_elem.get('href') if URL-Element sonst 'N / A'

        Eigenschaftsdaten = {
            „Titel“: Titel,
            "Adresse": Adresse,
            "Preis": Preis,
            "Betten": Betten,
            "Bad": Bäder,
            „Beschreibung“: Beschreibung,
            "URL": URL
        }
        property_list.append(Eigenschaftsdaten)

    Rückkehr Eigenschaftenliste

def Eigenschaftsdetails als JSON speichern(Eigenschaftsliste, Dateiname):
    mit XNUMXh geöffnet(Dateiname, 'w') as json_datei:
        json.dump(Eigenschaftsliste, JSON-Datei, Einzug=4)


if __name__ == '__Main__':
    Eigenschaften = Scrape_Listings()
    Eigenschaftsliste = Eigenschaftsdetails analysieren(Eigenschaften)
    save_property_details_to_json(Eigenschaftsliste, AUSGABEDATEI)

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
[
    {
        „Titel“: "Eigentumswohnung zu vermieten",
        "Adresse": „3824 Keystone Ave. Einheit 2, Culver City, CA 90232“,
        "Preis": „3,300 $ pro Monat“,
        "Betten": "2 Betten",
        "Bad": "1.5 Bäder",
        „Beschreibung“: „Komplett renoviertes und geräumiges Apartment mit 2 Schlafzimmern und 1.5 Badezimmern in einer fantastischen Lage in Culver City. Die Innenstadt von Culver City ist zu Fuß erreichbar und die Autobahnen 405 und 10 sind bequem zu erreichen. Offene Küche mit Frühstücksbar mit Blick auf das Wohnzimmer und den großen privaten Garten.“,
        "URL": "https://www.homes.com/los-angeles-ca/homes-for-rent/property/3824-keystone-ave-culver-city-ca-unit-2/2er2mwklw8zq6/"
    },
    {
        „Titel“: "Haus zu vermieten",
        "Adresse": „3901 Alonzo Ave, Encino, CA 91316“,
        "Preis": „17,000 $ pro Monat“,
        "Betten": "4 Betten",
        "Bad": "3.5 Bäder",
        „Beschreibung“: "Versteckt in den Hügeln von Encino in einer ruhigen Sackgasse liegt dieses modernisierte spanische Haus, das einen atemberaubenden Panoramablick auf das Tal bietet. Doppeltüren begrüßen Sie in einem offenen Grundriss, der ein geräumiges formelles Wohn- und Esszimmer sowie eine elegante, moderne Küche mit" bietet.,
        "URL": „https://www.homes.com/los-angeles-ca/homes-for-rent/property/3901-alonzo-ave-encino-ca/879negnf45nee/“
    },
    {
        „Titel“: "Haus zu vermieten",
        "Adresse": „13463 Chandler Blvd, Sherman Oaks, CA 91401“,
        "Preis": „30,000 $ pro Monat“,
        "Betten": "5 Betten",
        "Bad": "4.5 Bäder",
        „Beschreibung“: "Dieses einstöckige Prachtstück, komplett und neu renoviert, befindet sich in der äußerst begehrten Nachbarschaft Chandler Estates in Sherman Oaks. Ein großzügiger Grundriss, der alle 3,600 Quadratfuß optimal nutzt, dieses Haus mit 5 Schlafzimmern und 4.5 Bädern ist ein wahrer Ausdruck von Wärme und Schönheit, mit",
        "URL": „https://www.homes.com/los-angeles-ca/homes-for-rent/property/13463-chandler-blvd-sherman-oaks-ca/mnrh1cw3fn92b/?t=forrent“
    },
    {
        „Titel“: "Haus zu vermieten",
        "Adresse": „4919 Mammoth Ave, Sherman Oaks, CA 91423“,
        "Preis": „19,995 $ pro Monat“,
        "Betten": "5 Betten",
        "Bad": "6.5 Bäder",
        „Beschreibung“: „Wunderschönes neues Haus auf einem umzäunten Grundstück in bester Lage in Sherman Oaks, schöne Nachbarschaft! Mit 5 Schlafzimmern und 2013 Badezimmern im Haupthaus und geräumiger zusätzlicher Wohneinheit mit ca. 6.5 m². Der offene Grundriss umfasst ein Wohnzimmer mit individueller, hinterleuchteter Akzentwand sowie ein Esszimmer mit individueller Weinpräsentation und“,
        "URL": "https://www.homes.com/los-angeles-ca/homes-for-rent/property/4919-mammoth-ave-sherman-oaks-ca/yv8l136ks5f2e/"
    },
    {
        „Titel“: "Haus zu vermieten",
        "Adresse": „12207 Valleyheart Dr, Studio City, CA 91604“,
        "Preis": „29,500 $ pro Monat“,
        "Betten": "6 Betten",
        "Bad": "6.5 Bäder",
        „Beschreibung“: „Anmutiges und geräumiges modernes Bauernhaus mit atemberaubender Attraktivität, ein luxuriöser, gemütlicher Rückzugsort in einer der charmantesten Straßen des Tals. Dieses Anwesen liegt im begehrten und praktischen Studio City, besticht durch einen offenen, einladenden Grundriss und ist mit einer ADU ausgestattet, die ausreichend Platz und Raum bietet.“,
        "URL": „https://www.homes.com/los-angeles-ca/homes-for-rent/property/12207-valleyheart-dr-studio-city-ca/6104hnkegbnx3/“
    },
    ..... mehr
]

So scrapen Sie die Immobilienseiten von Homes.com

Das Scraping der Immobilienseiten von Homes.com kann detaillierte Einblicke in einzelne Inserate bieten.

In diesem Abschnitt führen wir Sie durch den Prozess des Scrapings spezifischer Eigenschaftenseiten mit Python.

Bibliotheken importieren

Wir müssen die erforderlichen Bibliotheken importieren: crawlbase für die Erstellung von HTTP requests und BeautifulSoup zum Parsen von HTML-Inhalten.

1
2
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe

Initialisieren Crawling API

Initialisieren Sie die CrawlingAPI-Klasse mit Ihrem Crawlbase JS-Token wie unten.

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

Definieren von Konstanten

Legen Sie die Ziel-URL für die Eigenschaftenseite fest, die Sie scrapen möchten, und definieren Sie die JSON-Ausgabedatei. Um das JS-Rendering-Problem zu lösen, können wir verwenden ajax_wait und Seite_warten Parameter bereitgestellt von Crawling APIWir können auch eine kundenspezifische user_agent wie in den Optionen unten.

1
2
3
4
5
6
7
8
URL = „https://www.homes.com/property/14710-greenleaf-st-sherman-oaks-ca/fylqz9clgbzd2/“
OUTPUT_FILE = 'Eigenschaftsdetails.json'

Optionen = {
    'ajax_wait': "wahr",
    'Seite_warten': 10000,
    "Benutzeragent": „Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, wie Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0“
}

Schabefunktion

Erstellen Sie eine Funktion, um die Details einer einzelnen Immobilie von Homes.com abzurufen. Diese Funktion sendet eine Anfrage an die Immobilienseite, analysiert den HTML-Inhalt und extrahiert die erforderlichen Details.

1
2
3
4
5
6
7
8
9
10
11
def Scrape_Eigenschaft(URL):
    versuchen:
        html_content = make_crawlbase_request(URL)
        if HTML-Inhalt:
            Suppe = Schöne Suppe (HTML-Inhalt, 'html.parser')
            Eigenschaftsdetails = Eigenschaftsdetails extrahieren (Soup)
            Rückkehr Objektdetails
    ausgeschlossen Exception as e:
        drucken(f"Anforderung fehlgeschlagen: {e}")

    Rückkehr Keine

Extrahieren von Eigenschaftsdetails

Erstellen Sie eine Funktion, um bestimmte Details aus der Immobilienseite zu extrahieren. Diese Funktion analysiert das HTML und extrahiert Informationen wie Titel, Adresse, Preis, Anzahl der Schlafzimmer, Badezimmer und Beschreibung.

Wir können das Tool „Untersuchen“ im Browser verwenden, um CSS-Selektoren von Elementen zu finden, die die benötigten Informationen enthalten, wie wir es im vorherigen Abschnitt getan haben.

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
def Extrahieren Sie die Eigenschaftendetails(Suppe):
    Adresselement = soup.select_one(„div.Eigenschaftsinfo-Adresse“)
    Preiselement = Suppe.Wählen Sie eins aus('Spanne#Preis')
    Betten_Element = Suppe.Wählen Sie eins(„span.property-info-feature > span.feature-Betten“)
    Bäder_Element = Suppe.Wählen Sie eins(„span.property-info-feature > span.feature-Bäder“)
    Bereichselement = soup.select_one(„span.property-info-feature.lotgröße“)
    Beschreibung_Element = soup.select_one('div#ldp-Beschreibungstext')
    agent_elem = soup.select_one(„div.Agentenname“)
    agent_phone_elem = soup.select_one(„div.agent-phone“)

    Adresse = Adresselement.Text.Strip() if Adresselement sonst 'N / A'
    Preis = Preiselement.text.strip() if Preiselement sonst 'N / A'
    Betten = Betten_elem.text.strip() if Betten_Elemente sonst 'N / A'
    Bäder = Bäder_elem.text.strip() if Bäder_Elemente sonst 'N / A'
    Bereich = Bereichselement.text.strip() if Flächenelement sonst 'N / A'
    Beschreibung = Beschreibung_Element.Text.Streifen() if Beschreibungselement sonst 'N / A'
    Agent = Agent_elem.text.strip() if agent_element sonst 'N / A'
    agent_phone = agent_phone_elem.text.strip() if agent_phone_elem sonst 'N / A'

    Eigenschaftsdaten = {
        'Adresse': Adresse,
        'Preis': Preis,
        'Betten': Betten,
        'Bad': Bäder,
        'Bereich': Bereich,
        'Bezeichnung': Beschreibung,
        'Agent': Vertreter,
        'Agententelefon': agent_phone
    }

    Rückkehr Eigenschaftsdaten

Daten speichern

Erstellen Sie eine Funktion zum Speichern der Scraped-Daten in einer JSON-Datei. Diese Funktion nimmt die extrahierten Eigenschaftsdaten und speichert sie in einer JSON-Datei.

1
2
3
4
5
importieren JSON

def Eigenschaftsdetails als JSON speichern(property_data, Dateiname):
    mit XNUMXh geöffnet(Dateiname, 'w') as json_datei:
        json.dump(Eigenschaftsdaten, JSON-Datei, Einzug=4)

Ausführen des Skripts

Kombinieren Sie die Funktionen und führen Sie das Skript aus, um mehrere Eigenschaftenseiten zu scrapen. Geben Sie die Eigenschaften-IDs, die Sie scrapen möchten, in einer Liste an.

1
2
3
4
5
if __name__ == '__Main__':
    Eigenschaftsdaten = Scrape-Eigenschaft (URL)

    if Eigenschaftsdaten:
        save_property_details_to_json(Eigenschaftsdaten, AUSGABEDATEI)

Code vervollständigen

Unten finden Sie den vollständigen Code zum Scraping von Immobilienlisten für die Immobilienseite von homes.com.

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
78
79
80
81
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe
importieren JSON

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

URL = „https://www.homes.com/property/14710-greenleaf-st-sherman-oaks-ca/fylqz9clgbzd2/“
OUTPUT_FILE = 'Eigenschaftsdetails.json'

Optionen = {
    'ajax_wait': "wahr",
    'Seite_warten': 10000,
    "Benutzeragent": „Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, wie Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0“
}

# Funktion zum Stellen einer Anfrage mithilfe der Crawlbase-API
def Crawlbase-Anfrage erstellen(URL):
    # Anfrage mit der Crawlbase-API senden
    Antwort = crawling_api.get(URL, Optionen)
    # Prüfen Sie, ob die Anfrage erfolgreich war
    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. Crawlbase-Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine

def Scrape_Eigenschaft(URL):
    versuchen:
        html_content = make_crawlbase_request(URL)
        if HTML-Inhalt:
            Suppe = Schöne Suppe (HTML-Inhalt, 'html.parser')
            Eigenschaftsdetails = Eigenschaftsdetails extrahieren (Soup)
            Rückkehr Objektdetails
    ausgeschlossen Exception as e:
        drucken(f"Anforderung fehlgeschlagen: {e}")

    Rückkehr Keine

def Extrahieren Sie die Eigenschaftendetails(Suppe):
    Adresselement = soup.select_one(„div.Eigenschaftsinfo-Adresse“)
    Preiselement = Suppe.Wählen Sie eins aus('Spanne#Preis')
    Betten_Element = Suppe.Wählen Sie eins(„span.property-info-feature > span.feature-Betten“)
    Bäder_Element = Suppe.Wählen Sie eins(„span.property-info-feature > span.feature-Bäder“)
    Bereichselement = soup.select_one(„span.property-info-feature.lotgröße“)
    Beschreibung_Element = soup.select_one('div#ldp-Beschreibungstext')
    agent_elem = soup.select_one(„div.Agentenname“)
    agent_phone_elem = soup.select_one(„div.agent-phone“)

    Adresse = Adresselement.Text.Strip() if Adresselement sonst 'N / A'
    Preis = Preiselement.text.strip() if Preiselement sonst 'N / A'
    Betten = Betten_elem.text.strip() if Betten_Elemente sonst 'N / A'
    Bäder = Bäder_elem.text.strip() if Bäder_Elemente sonst 'N / A'
    Bereich = Bereichselement.text.strip() if Flächenelement sonst 'N / A'
    Beschreibung = Beschreibung_Element.Text.Streifen() if Beschreibungselement sonst 'N / A'
    Agent = Agent_elem.text.strip() if agent_element sonst 'N / A'
    agent_phone = agent_phone_elem.text.strip() if agent_phone_elem sonst 'N / A'

    Eigenschaftsdaten = {
        'Adresse': Adresse,
        'Preis': Preis,
        'Betten': Betten,
        'Bad': Bäder,
        'Bereich': Bereich,
        'Bezeichnung': Beschreibung,
        'Agent': Vertreter,
        'Agententelefon': agent_phone
    }

    Rückkehr Eigenschaftsdaten

def Eigenschaftsdetails als JSON speichern(property_data, Dateiname):
    mit XNUMXh geöffnet(Dateiname, 'w') as json_datei:
        json.dump(Eigenschaftsdaten, JSON-Datei, Einzug=4)

if __name__ == '__Main__':
    Eigenschaftsdaten = Scrape-Eigenschaft (URL)

    if Eigenschaftsdaten:
        save_property_details_to_json(Eigenschaftsdaten, AUSGABEDATEI)

Beispielausgabe:

1
2
3
4
5
6
7
8
9
10
{
  "Adresse": „14710 Greenleaf St. Sherman Oaks, CA 91403“,
  "Preis": „11,000 $ pro Monat“,
  "Betten": "Betten",
  "Bad": "Bad",
  "Bereich": „10,744 Quadratfuß großes Grundstück“,
  „Beschreibung“: "N / A",
  "Agent": „Myles Lewis“,
  "Agententelefon": "(747) 298-7020"
}

Optimieren Sie Homes.com Scraping mit Crawlbase

Das Scraping von Daten von Homes.com ist nützlich für Marktforschung, Investitionsanalysen und Marketingstrategien. Mit Python und Bibliotheken wie BeautifulSoup oder Diensten wie Crawlbase können Sie effizient Daten aus Homes.com-Einträgen sammeln.

Crawlbases Crawling API führt Scraping-Aufgaben zuverlässig aus und stellt sicher, dass Ihre Anfragen echte Benutzerinteraktionen nachahmen. Dieser Ansatz verbessert die Scraping-Effizienz und minimiert gleichzeitig das Risiko einer Erkennung und Blockierung durch die Anti-Scraping-Maßnahmen von Homes.com.

Wenn Sie erfahren möchten, wie Sie Daten von anderen Immobilien-Websites extrahieren, sehen Sie sich unsere hilfreichen Anleitungen weiter unten an.

📜 So scrapen Sie Realtor.com
📜 So scrapen Sie Zillow
📜 Wie man Airbnb scrapt
📜 Wie man Booking.com scrapt
📜 Wie man Redfin abkratzt

Bei Fragen oder Anregungen steht Ihnen unser Support-Team steht Ihnen jederzeit zur Verfügung, um Sie bei Ihrem Web Scraping-Vorhaben zu unterstützen. Denken Sie daran, ethische Richtlinien zu befolgen und die Nutzungsbedingungen der Website zu respektieren. Viel Spaß beim Scraping!

Häufig gestellte Fragen (FAQs)

Ja, das Scraping von Daten von Homes.com ist legal, solange Sie sich an die Servicebedingungen halten und keine Aktivitäten durchführen, die gegen die Richtlinien verstoßen. Es ist wichtig, Scraping verantwortungsbewusst und ethisch zu nutzen und sicherzustellen, dass Sie der Website oder ihren Benutzern keinen Schaden zufügen oder sie stören.

F: Kann ich Homes.com scrapen, ohne blockiert zu werden?

Obwohl das Scraping von Homes.com ohne Blockierung aufgrund der Anti-Scraping-Maßnahmen eine Herausforderung sein kann, gibt es Techniken und Tools, die das Risiko einer Blockierung verringern. Die Nutzung von APIs wie Crawlbase, die Rotation von IP-Adressen und die Nachahmung menschlichen Verhaltens können Ihre Chancen auf reibungsloses Scraping verbessern, ohne Blockierungsmechanismen auszulösen.

F: Wie oft sollte ich Daten von Homes.com scrapen?

Die Häufigkeit des Scrapings von Daten von Homes.com hängt von Ihren spezifischen Anforderungen und Zielen ab. Es ist wichtig, ein Gleichgewicht zwischen dem Sammeln zeitnaher Updates und der Vermeidung einer Überlastung der Server der Website oder des Auslösens von Anti-Scraping-Maßnahmen zu finden. Die regelmäßige Überwachung von Änderungen in Angeboten, Markttrends oder anderen relevanten Daten kann dabei helfen, die optimale Scraping-Frequenz für Ihren Anwendungsfall zu bestimmen.