Realtor.com scrapenImmobilien-Listings und Preise

Realtor.com ist eines der größten Immobilienportale in den Vereinigten Staaten, und seine Listingseiten enthalten genau die strukturierten Daten, die Preisverfolgung, Marktforschung und Investitionsanalyse antreiben: den Listenpreis, Schlafzimmer, Badezimmer, Wohnfläche, die Straßenadresse und einen Link zurück zu jedem Listing. Diese öffentlichen Daten sind das Rohmaterial hinter jedem ernsthaften Einblick in einen lokalen Immobilienmarkt, aber die Seiten rendern clientseitig und die Website verteidigt sich stark gegen automatisierten Traffic, sodass eine einfache HTTP-Anfrage Ihnen eine dünne Hülle statt der gesuchten Listings liefert.

Diese Anleitung zeigt Ihnen, wie Sie Realtor.com scrapen mit Python auf zuverlässige Weise. Sie bauen einen kleinen, lauffähigen Scraper, der eine gerenderte Suchseite über die Crawling API abruft, die Listingdaten liest, die Realtor.com in ein verborgenes __NEXT_DATA__-Skript einbettet, die gewünschten Felder extrahiert, die Paginierung verwaltet und saubere JSON- und CSV-Dateien exportiert. Wir halten die gesamte Anleitung auf öffentliche Listingdaten beschränkt, und der Rechtsabschnitt am Ende ist kein Standardtext, also lesen Sie ihn, bevor Sie diesen Scraper auf echtes Volumen anwenden.

Was Sie bauen werden

Ein Python-Skript, das eine öffentliche Realtor.com-Such-URL für eine Stadt und einen Bundesstaat entgegennimmt, das gerenderte HTML über die Crawling API abruft, den eingebetteten Listingdatensatz parst und einen strukturierten Datensatz pro Immobilie schreibt. Wir verwenden eine einzelne Stadt als laufendes Beispiel und extrahieren folgende Felder:

• Price der auf dem Listing angegebene Listenpreis.
• Beds die Anzahl der Schlafzimmer.
• Baths die konsolidierte Badezimmeranzahl.
• Sqft die Innen-Wohnfläche des Hauses.
• Address die Straße, Stadt, Bundesstaat und Postleitzahl.
• Link die kanonische URL des Listings, aus seinem Permalink rekonstruiert.

Warum eine einfache Anfrage bei Realtor.com fehlschlägt

Wenn Sie eine Realtor.com-Such-URL mit einem einfachen HTTP-Client anfordern, erhalten Sie eine Antwort mit Status 200 und fast keine der Listingdaten im sichtbaren Markup. Zwei Faktoren wirken gegen Sie. Erstens ist Realtor.com eine Next.js-Anwendung, die ihre Listings im Browser hydriert, also leben die Daten in einem JSON-Blob in einem verborgenen <script id="__NEXT_DATA__">-Tag anstatt in gerenderten HTML-Elementen, die Sie direkt lesen können. Zweitens kennzeichnet die Website automatisierten Traffic schnell: Datacenter-IPs und Anfragemuster, die nicht wie ein echter Browser aussehen, werden herausgefordert oder erhalten eine CAPTCHA-Anzeige, bevor sie jemals eine vollständige Seite erreichen.

Ein funktionierender Realtor.com-Scraper benötigt daher zwei Dinge in einer Anfrage: einen Browser, der die Seite tatsächlich rendert, und eine IP, die die Plattform als echten Besucher liest. Sie können das selbst mit einem Headless-Browser plus einem Pool rotierender Residential-Proxies aufbauen, aber deren Zusammenstellung und Wartung ist der Großteil der Arbeit. Die Crawling API vereint beides in einem einzigen Aufruf: Sie senden die URL mit einem JavaScript-Token, sie rendert die Seite hinter einer vertrauenswürdigen IP und gibt fertiges HTML zurück, mit dem __NEXT_DATA__-Payload intakt zum Parsen.

Voraussetzungen

Sie benötigen einige Dinge, bevor Sie Code schreiben. Keines davon nimmt viel Zeit in Anspruch.

Grundlegende Python-Kenntnisse. Sie sollten sich damit auskennen, ein Python-Skript zu schreiben und auszuführen sowie Pakete mit pip zu installieren. Wenn Sie neu in der Sprache sind, deckt die Python-Web-Scraping-Anleitung das Grundwerk ab, das dieses Tutorial voraussetzt.

Python 3.8 oder höher. Bestätigen 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 JS-Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihr JavaScript (JS) Token. Sie erhalten bis zu 20.000 kostenlose Anfragen und keine Kreditkarte ist erforderlich. Behandeln Sie das Token wie ein Passwort: Es authentifiziert Ihre Anfragen, also halten Sie es aus der Versionskontrolle heraus.

Projekt einrichten

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

python --version

python -m venv realtor_env
source realtor_env/bin/activate

pip install crawlbase

Aktivieren Sie unter Windows die Umgebung mit realtor_env\Scripts\activate anstatt der source-Zeile. Wir benötigen hier nur eine Drittanbieter-Abhängigkeit: crawlbase ist der offizielle Client für die Crawling API. Da die Listingdaten als JSON im __NEXT_DATA__-Skript ankommen, verarbeiten Pythons eingebaute json- und re-Module das Parsen ohne eine separate HTML-Bibliothek.

Schritt 1: Die gerenderte Suchseite abrufen

Beginnen Sie damit, die fertige Seite zu erhalten. Importieren Sie die CrawlingAPI-Klasse, initialisieren Sie sie mit Ihrem JS-Token und fordern Sie eine Realtor.com-Such-URL an. Durch die Überprüfung des Statuscodes vor dem Parsen bleiben Fehler sichtbar statt still.

from crawlbase import CrawlingAPI

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

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 5000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

if __name__ == "__main__":
    search_url = "https://www.realtor.com/realestateandhomes-search/Los-Angeles_CA/pg-1"
    html = crawl(search_url)
    print(html[:500] if html else "No HTML returned")

Die zwei Wait-Optionen sind für ein clientseitig gerendertes Next.js-Ziel wie dieses wichtig. ajax_wait weist die API an, auf den Abschluss asynchroner Inhalte zu warten, und page_wait hält für eine feste Anzahl von Millisekunden nach dem Laden an, damit die hydrierten Daten vorhanden sind, bevor die Seite erfasst wird. Fünf Sekunden sind ein vernünftiger Ausgangspunkt; erhöhen Sie es, wenn der Datensatz leer zurückkommt. Führen Sie das Skript mit python realtor_scraper.py aus, und Sie sollten echtes Seiten-Markup sehen, das das __NEXT_DATA__-Skript enthält, nicht die leere Hülle, die ein einfacher Abruf zurückgibt. Das bestätigt, dass das Rendering funktioniert, bevor Sie eine einzige Parsing-Zeile schreiben.

Schritt 2: Den eingebetteten Listingdatensatz extrahieren

Mit fertigem HTML in der Hand extrahieren Sie das JSON aus dem __NEXT_DATA__-Skript und navigieren zum Teil, der die Suchergebnisse enthält. Realtor.com verschachtelt seine Ergebnisse unter props.pageProps, mit einem Fallback-Pfad unter searchResults.home_search für Seiten, die die alternative Form verwenden. Umschließen Sie die Nachschlageoperationen, damit ein fehlender Schlüssel None zurückgibt statt den Lauf abstürzen zu lassen.

import re
import json

def extract_next_data(html):
    # The listing dataset lives in a hidden __NEXT_DATA__ script.
    match = re.search(
        r'<script id="__NEXT_DATA__" type="application/json">(.*?)</script>',
        html,
        re.DOTALL,
    )
    if not match:
        print("No hidden web data found.")
        return None
    return json.loads(match.group(1))

def get_results(data):
    # Prefer the pageProps path, fall back to the home_search shape.
    page_props = data.get("props", {}).get("pageProps", {})
    results = page_props.get("properties")
    if results:
        return results
    search = data.get("searchResults", {}).get("home_search", {})
    return search.get("results", [])

Die extract_next_data-Funktion verwendet einen einzelnen regulären Ausdruck, um den Inhalt des __NEXT_DATA__-Skripts zu greifen und ihn als JSON zu parsen, wodurch das Einbinden eines HTML-Parsers nur zum Lesen eines JSON-Blobs vermieden wird. Der get_results-Helfer versucht dann zuerst das properties-Array unter pageProps und fällt auf home_search.results zurück, weil Realtor.com je nach dem Weg, wie die Seite erreicht wurde, beide Formen verwendet. Jede Nachschlage-Operation verwendet dict.get mit einem Standard, sodass eine Seite, die ihre Struktur ändert, eine leere Liste zurückgibt statt einen KeyError zu werfen.

Schritt 3: Jede Immobilie in einen flachen Datensatz parsen

Jedes Element im Ergebnisarray enthält einen description-Block (Schlafzimmer, Badezimmer, Wohnfläche), einen location.address-Block, den list_price und einen permalink, den Sie in eine vollständige Listing-URL umwandeln können. Bilden Sie diese in ein flaches Dictionary ab, damit die Ausgabe leicht in JSON oder CSV geschrieben werden kann.

def parse_property(item):
    description = item.get("description") or {}
    location = item.get("location") or {}
    address = location.get("address") or {}

    parts = [
        address.get("line"),
        address.get("city"),
        address.get("state_code"),
        address.get("postal_code"),
    ]
    full_address = ", ".join(p for p in parts if p)

    permalink = item.get("permalink")
    link = (
        f"https://www.realtor.com/realestateandhomes-detail/{permalink}"
        if permalink
        else None
    )

    return {
        "price": item.get("list_price"),
        "beds": description.get("beds"),
        "baths": description.get("baths_consolidated"),
        "sqft": description.get("sqft"),
        "address": full_address or None,
        "link": link,
    }

Die or {}-Wächter sind wichtig, weil Realtor.com einige dieser verschachtelten Objekte bei Listings, denen die Daten fehlen, auf null setzt, und der Aufruf von .get auf None würde einen Fehler werfen. Schlafzimmer, Badezimmer und Wohnfläche kommen direkt aus dem description-Block, wo baths_consolidated das Feld ist, das Realtor.com verwendet, um volle und halbe Badezimmer in einer Zahl zusammenzufassen. Die Adresse wird durch die Verbindung von Straßenzeile, Stadt, Bundesstaatscode und Postleitzahl aufgebaut, wobei fehlende Teile übersprungen werden, und der Link wird aus dem permalink rekonstruiert, den Realtor.com jeder Immobilie zuweist. Das Ergebnis ist ein flacher Datensatz pro Listing, die Form, die Sie für den Export möchten.

Schritt 4: Alles mit Paginierung zusammenfügen

Eine Seite ist eine Demo; ein echter Job läuft über den vollständigen Ergebnissatz einer Stadt. Realtor.com paginiert seine Suche mit einem sauberen /pg-<PAGE>-Suffix, also bauen Sie die URL für jede Seite aus einer Stadt und einem Bundesstaat, crawlen Sie sie, extrahieren Sie den Datensatz und parsen Sie jede Immobilie. Ein kurzer Schlaf zwischen den Seiten drosselt den Lauf.

import re
import json
import time
from crawlbase import CrawlingAPI

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

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 5000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

def find_properties(city, state, max_pages=1):
    listings = []
    for page in range(1, max_pages + 1):
        url = (
            "https://www.realtor.com/realestateandhomes-search/"
            f"{city}_{state.upper()}/pg-{page}"
        )
        html = crawl(url)
        if not html:
            continue
        data = extract_next_data(html)
        if not data:
            continue
        for item in get_results(data):
            listings.append(parse_property(item))
        print(f"Page {page}: {len(listings)} listings so far")
        time.sleep(2)
    return listings

def main():
    listings = find_properties("Los-Angeles", "CA", max_pages=3)
    print(json.dumps(listings, indent=2))

if __name__ == "__main__":
    main()

Die find_properties-Funktion spiegelt den ursprünglichen Ansatz wider: Eine Schleife geht den Seitenbereich durch, erstellt die {city}_{state}/pg-{page}-URL für jede und hängt jede geparste Immobilie an eine laufende Liste an. Das time.sleep(2) zwischen den Seiten ist beabsichtigt, es drosselt den Lauf, damit Sie die Website nicht bombardieren, was die wirksamste Einzelgewohnheit ist, um unblockiert zu bleiben. Fügen Sie die extract_next_data-, get_results- und parse_property-Funktionen aus den vorherigen Schritten ein, und dies ist ein vollständiger, lauffähiger Scraper.

Wie die Ausgabe aussieht

Führen Sie das vollständige Skript mit python realtor_scraper.py aus, und Sie erhalten eine saubere Liste strukturierter Datensätze, einen pro Listing.

[
  {
    "price": 139000000,
    "beds": 12,
    "baths": "17",
    "sqft": null,
    "address": "1200 Bel Air Rd, Los Angeles, CA, 90077",
    "link": "https://www.realtor.com/realestateandhomes-detail/1200-Bel-Air-Rd_Los-Angeles_CA_90077_M17839-35941"
  }
]

Nach JSON und CSV exportieren

Sobald jedes Listing ein flaches Dictionary ist, ist der Export zwei kurze Funktionen. JSON behält die vollständige verschachtelungsfreundliche Form; CSV flacht es in eine tabellenkalkulationsbereite Tabelle mit einer Spalte pro Feld ab.

import csv
import json

def save_json(listings, path="realtor_listings.json"):
    with open(path, "w", encoding="utf-8") as f:
        json.dump(listings, f, indent=2)

def save_csv(listings, path="realtor_listings.csv"):
    if not listings:
        return
    fields = ["price", "beds", "baths", "sqft", "address", "link"]
    with open(path, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fields)
        writer.writeheader()
        writer.writerows(listings)

Rufen Sie save_json(listings) und save_csv(listings) am Ende von main auf, und Sie haben beide Formate auf der Festplatte. Die explizite fields-Liste hält die CSV-Spaltenreihenfolge über Läufe stabil, was wichtig ist, wenn Sie Ergebnisse in dieselbe Datei anhängen oder sie in ein Tool laden, das einen festen Header erwartet. Von hier aus sind die Daten bereit für ein Notebook, eine Datenbank oder ein Preismodell.

Unblockiert bleiben bei Skalierung

Selbst wenn das Rendering verwaltet wird, überwacht Realtor.com Traffic, der nach Scrapern aussieht, und sein Layout und seine Abwehrmechanismen ändern sich im Laufe der Zeit. Ein paar Gewohnheiten halten einen längeren Lauf gesund, und sie gelten für jedes schwer zu scrapende kommerzielle Ziel.

• Drosseln Sie Ihre Anfragen. Seiten in einer engen Schleife zu bombardieren ist der schnellste Weg, gedrosselt oder mit einer CAPTCHA-Anzeige konfrontiert zu werden. Behalten Sie das sleep zwischen den Seiten bei und vermeiden Sie das Crawlen einer Stadt mit voller Geschwindigkeit.
• Setzen Sie auf Rotation. Ein Pool von Residential-IPs verteilt Anfragen auf viele echte Nutzeradressen, sodass keine einzelne ein Ratenlimit auslöst. Die Crawling API übernimmt das für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, den Sie richtig hinbekommen müssen.
• Lesen Sie die Statuscodes. Ein Lauf, der beginnt, Herausforderungen oder Fehler zurückzugeben, signalisiert Ihnen, dass die aktuelle Rate oder IP-Ebene nicht mehr ausreicht. Behandeln Sie das als Signal zum Zurückschalten, nicht als Rauschen, das ignoriert werden soll.
• Erwarten Sie Strukturänderungen. Realtor.com aktualisiert seine Website regelmäßig, also überprüfen Sie erneut die __NEXT_DATA__-Schlüssel, wenn Felder leer werden, anstatt anzunehmen, der Scraper sei kaputt.

Für das umfassendere Playbook lesen Sie wie man Websites ohne Blockierung scrapt und die Anleitung zum Crawlen von JavaScript-Websites. Für eine Skalierung über eine einzelne Stadt hinaus bündeln Sie Ihre Such-URLs und leiten Sie sie durch dieselbe find_properties-Schleife.

Ist es legal, Realtor.com zu scrapen?

Ob das Scrapen von Realtor.com erlaubt ist, hängt von Realtor.coms Nutzungsbedingungen, Ihrer Gerichtsbarkeit und dem ab, was Sie mit den Daten tun. Die Bedingungen schränken automatisierten Zugang ein, sodass Scraping gegen diese Bedingungen verstoßen kann, unabhängig davon, wie sorgfältig Ihre Werkzeuge sind. Keiner der hier gezeigten Codes ändert das; er bringt nur den technischen Teil zum Laufen. Lesen Sie Realtor.coms Nutzungsbedingungen und seine robots.txt, respektieren Sie alle angegebenen Ratenlimits und behandeln Sie beides als Grenze für das, was Sie sammeln.

Einige Grundsätze, die es wert sind, sie einzuhalten. Sammeln Sie nur öffentliche Listingdaten: den Listenpreis, Schlafzimmer, Badezimmer, Wohnfläche, Adresse und Listing-Link, den jeder ohne Konto sehen kann. Ein großer Teil der zugrunde liegenden Daten von Realtor.com stammt aus MLS-Feeds, die lizenziert und nicht frei wiederverwendbar sind, daher kann ein Immobiliendatensatz Nutzungseinschränkungen tragen, selbst wenn die Seite öffentlich ist; behandeln Sie MLS-bezogene Felder als lizenzierte Inhalte statt als offene Daten. Vermeiden Sie alles, was mit identifizierbaren Personen verbunden ist, einschließlich der Namen und Kontaktdaten von Maklern, Brokern oder Eigentümern, die auf einer Seite angezeigt werden, die persönliche Daten unter Regimen wie der DSGVO und dem CCPA sind. Wenn Sie die Daten kommerziell oder in großem Umfang wiederverwenden möchten, holen Sie die Genehmigung oder einen lizenzierten Feed ein, anstatt Schweigen als Zustimmung zu interpretieren.

Diese Anleitung beschränkt sich absichtlich auf öffentliche Listingseiten, weil das die Grenze ist, die die Arbeit vertretbar hält. Sie deckt nichts hinter einem Login ab, keine gespeicherten Such- oder Kontodaten, keine persönlichen oder Kontaktdaten von Maklern und Eigentümern und keinen Versuch, eine Authentifizierung zu umgehen. Nur öffentliche Listingdaten. Wenn Ihr Projekt mehr als das benötigt, bieten Realtor.com und die dahinterliegenden MLS-Systeme offizielle Datenpartnerschaften und lizenzierte Feeds an, die der richtige Weg für Produktionsvolumen sind, kein ausgefeilterer Scraper.

Häufig gestellte Fragen

Warum gibt eine einfache Anfrage keine Listings von Realtor.com zurück?

Weil Realtor.com eine Next.js-App ist, die ihre Listings im Browser hydriert. Die Daten befinden sich nicht in den statischen HTML-Elementen, die eine rohe Anfrage zurückgibt; sie sitzen in einem verborgenen __NEXT_DATA__-JSON-Skript, das erst erscheint, wenn die Seite rendert. Um es zu erhalten, müssen Sie die Seite zuerst rendern, was das JS-Token der Crawling API übernimmt, und dann das JSON aus diesem Skript lesen.

Was ist das __NEXT_DATA__-Skript und warum sollte man es scrapen?

Es ist der JSON-Payload, den Next.js-Websites einbetten, damit die Seite im Browser hydrieren kann. Auf Realtor.com enthält es den vollständigen Suchergebnisdatensatz, einschließlich Preis, Schlafzimmer, Badezimmer, Wohnfläche, Adresse und den Permalink für jedes Listing. Es zu lesen ist stabiler als sichtbares HTML zu parsen, weil sich die JSON-Schlüssel weniger oft ändern als die CSS-Klassennamen darum herum.

Brauche ich das normale Token oder das JS-Token für Realtor.com?

Das JS-Token. Das normale Token ruft statisches HTML ab, das auf Realtor.com nicht den hydrierten __NEXT_DATA__-Inhalt enthält, den Sie benötigen. Das JS-Token rendert die Seite zuerst in einem echten Browser, sodass der eingebettete Datensatz vorhanden ist, wenn Sie ihn extrahieren und parsen.

Wie verwalte ich die Paginierung über die Listings einer Stadt?

Realtor.com verwendet ein /pg-<PAGE>-Suffix für seine Such-URLs, also bauen Sie {city}_{state}/pg-{page} für jede Seite und schleifen Sie die Seitenzahl. Die obige find_properties-Funktion macht genau das: Sie crawlt jede Seite, extrahiert den Datensatz, parst jede Immobilie und pausiert zwischen den Seiten, damit Sie eine höfliche Anfragerate einhalten.

Welche Felder kann ich aus einem Realtor.com-Listing extrahieren?

Öffentliche Listingfelder: den Listenpreis, die Anzahl der Schlafzimmer und Badezimmer, die Wohnfläche, die vollständige Adresse und den Listing-Link aus dem Permalink rekonstruiert. Bleiben Sie bei Daten, die für jeden Besucher ohne Konto sichtbar sind, behandeln Sie MLS-bezogene Felder als lizenzierte Inhalte und vermeiden Sie die persönlichen Daten von Maklern, Brokern oder Eigentümern, die außerhalb des Umfangs der öffentlichen Listings liegen, den diese Anleitung abdeckt.

Kann ich Preis- und Listingänderungen im Laufe der Zeit verfolgen?

Ja. Führen Sie den Scraper planmäßig aus, schlüsseln Sie jedes Listing nach seinem Permalink und vergleichen Sie die Preis- und Statusfelder zwischen den Läufen, um neue Listings, Preissenkungen und verkaufte Immobilien zu erfassen. Halten Sie die Anfragerate gering und speichern Sie nur die öffentlichen Listingfelder, die Sie benötigen. Für verwandte Immobilienziele lesen Sie die Anleitungen zum Scrapen von Zillow und zum Scrapen von Redfin.

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.