Wie man Redfin scrappt: Python-Leitfaden für Immobiliendaten

Redfin ist eine der größten Immobilienplattformen in den Vereinigten Staaten und umfasst Millionen von Wohnimmobilienangeboten in praktisch jedem Ballungsraum. Wenn Sie Redfin für Marktanalysen, Investitionsrecherchen oder den Aufbau einer Immobiliendatenbank scrapen müssen, arbeitet die interne Architektur der Plattform tatsächlich zu Ihrem Vorteil. Im Gegensatz zu Websites, die alles serverseitig rendern, ruft das Frontend von Redfin Daten von versteckten API-Endpunkten ab, die gut strukturiertes JSON zurückgeben. Das bedeutet, dass Sie Immobiliendaten programmgesteuert extrahieren können, ohne sich mit CSS-Selektoren herumschlagen zu müssen, die bei jeder Layoutaktualisierung der Website versagen.

In diesem Tutorial erstellen Sie einen Python-basierten Redfin-Scraper von Grund auf. Wir behandeln drei verschiedene Scraping-Ziele (Mietangebote, zum Verkauf stehende Immobilien und Suchergebnisse), zeigen Ihnen, wie Sie neu gelistete Immobilien über Redfins XML-Sitemaps überwachen können, und führen Sie durch den Export Ihrer Daten sowohl in CSV als auch in JSON. Dabei gehen wir auf Ratenbegrenzung, Anti-Bot-Schutzmaßnahmen und die rechtlichen Aspekte ein, die Sie beachten sollten, bevor Sie ein Immobilien-Web-Scraping-Projekt in großem Maßstab durchführen.

Bevor Sie mit dem Programmieren beginnen, ist es hilfreich zu wissen, welche Daten Redfin tatsächlich bereitstellt. Die Plattform organisiert Immobilieninformationen in verschiedenen Kategorien, und die Kenntnis der verfügbaren Datenfelder hilft Ihnen bei der Planung, welche Endpunkte Sie ansprechen sollten und wie Ihr Ausgabeschema aussehen sollte.

Hier finden Sie eine Übersicht über die wichtigsten Scraping-Ziele und die Felder, die Sie erwarten können:

Die Endpunkte für Vermietung und Verkauf geben unterschiedliche JSON-Schemas zurück, was bei der Gestaltung Ihrer Datenpipeline eine Rolle spielt. Verkaufsangebote enthalten Felder wie Verkaufshistorie und Marktleistungskennzahlen, die in den Antworten zu Vermietungen nicht vorkommen, während Mietdaten mietvertragsbezogene Felder wie Haustierrichtlinien und Kautionsanforderungen enthalten.

Für dieses Projekt benötigen Sie Python 3.8 oder höher. Wir werden auf zwei Kernbibliotheken zurückgreifen: httpx für die Erstellung von HTTP-Anfragen (es verarbeitet Asynchronität gut und verfügt über eine übersichtliche API) und parsel zum Parsen von HTML- oder XML-Antworten, insbesondere bei der Arbeit mit Sitemaps.

Erstellen Sie ein Projektverzeichnis und installieren Sie die Abhängigkeiten:

mkdir redfin-scraper && cd redfin-scraper
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install httpx parsel

Fügen Sie optional pandas hinzu, wenn Sie eine erweiterte Datenbereinigung während des Exports wünschen:

pip install pandas

Dein requirements.txt sollte so aussehen:

httpx>=0.27.0
parsel>=1.9.0
pandas>=2.0.0

Das ist alles, was Sie für den Start benötigen. Keine Browser-Automatisierungsbibliotheken, kein Selenium, kein Playwright. Da wir direkt auf die versteckten API-Endpunkte von Redfin abzielen, reicht ein einfacher HTTP-Client aus.

Wenn Sie eine Redfin-Immobilienseite in Ihrem Browser laden, ist der sichtbare HTML-Code meist nur eine Hülle. Die eigentlichen Immobiliendaten werden asynchron von internen API-Endpunkten abgerufen. Sie können diese Endpunkte selbst entdecken, indem Sie die DevTools Ihres Browsers (F12) öffnen, zur Registerkarte „Netzwerk“ navigieren und beim Laden einer Angebotsseite nach „XHR“- oder „Fetch“-Anfragen filtern.

Sie sehen dann eine Reihe von Anfragen an URLs wie https://www.redfin.com/stingray/api/home/details/... , die strukturierte Daten zurückgeben. Die Antworten beginnen in der Regel mit einem Kommentarpräfix (etwa {}&&{), gefolgt von gültigem JSON. Dieses Präfix dient als Schutz vor Cross-Site-Scripting, daher müssen Sie es vor dem Parsen entfernen.

Dieser API-first-Ansatz zum Scraping von Redfin bietet erhebliche Vorteile gegenüber dem herkömmlichen HTML-Parsing:

• Stabilität: JSON-Feldnamen ändern sich selten, während sich CSS-Klassennamen bei jedem Deploy verschieben können.
• Vollständigkeit: Die API-Antwort enthält oft mehr Daten als das, was auf der sichtbaren Seite dargestellt wird.
• Geschwindigkeit: Sie senden eine Anfrage pro Inserat, anstatt eine vollständige Seite mit Bildern, Skripten und Stylesheets zu laden.
• Einfachheit: Es ist keine Browser-Automatisierung erforderlich. Ein Standard-HTTP-Client erledigt alles.

Um den richtigen Endpunkt für einen beliebigen Listing-Typ zu finden, laden Sie die Seite, beobachten Sie die Netzwerkanfragen und suchen Sie nach derjenigen, die den Großteil der Immobiliendaten in ihrer JSON-Antwort enthält. Das URL-Muster enthält Kennungen wie die Immobilien-ID oder eine URL-kodierte Adresse.

Beginnen wir mit Mietangeboten. Redfin stellt Mietdaten über einen speziellen API-Pfad bereit, der sich vom Endpunkt für Verkaufsobjekte unterscheidet. Wenn Sie eine Seite mit Mietobjekten aufrufen, sendet der Browser eine Anfrage an einen Endpunkt, der die vollständigen Mietdetails als JSON zurückgibt.

Hier ist ein vollständiges, funktionierendes Beispiel, das ein Mietangebot abruft:

import httpx
import json

HEADERS = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                   "AppleWebKit/537.36 (KHTML, like Gecko) "
                   "Chrome/125.0.0.0 Safari/537.36",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    "Accept-Language": "en-US,en;q=0.9",
    "Referer": "https://www.redfin.com/",
}

def clean_json_response(text: str) -> dict:
    """Strip Redfin's XSS prefix and parse JSON."""
    start = text.find("{")
    if start == -1:
        raise ValueError("No JSON object found in response")
    return json.loads(text[start:])

def scrape_rental(url: str) -> dict:
    """Fetch rental property data from Redfin's internal API."""
    with httpx.Client(headers=HEADERS, follow_redirects=True) as client:
        resp = client.get(url)
        resp.raise_for_status()
        data = clean_json_response(resp.text)

    payload = data.get("payload", {})
    rental_info = {
        "address": payload.get("streetAddress", {}).get("assembledAddress"),
        "rent_price": payload.get("listingPrice"),
        "beds": payload.get("beds"),
        "baths": payload.get("baths"),
        "sqft": payload.get("sqFt"),
        "pet_policy": payload.get("petPolicy"),
        "amenities": payload.get("amenities", []),
        "photos": [p.get("photoUrl") for p in payload.get("photos", [])],
        "listing_agent": payload.get("listingAgent", {}).get("name"),
    }
    return rental_info

# Example usage
listing_url = "https://www.redfin.com/stingray/api/home/details/rental/..."
# result = scrape_rental(listing_url)
# print(json.dumps(result, indent=2))

Ein paar Dinge sind bei diesem Code zu beachten. Die clean_json_response Funktion verarbeitet das XSS-Präfix, das Redfin den API-Antworten voranstellt. Die Header ahmen eine echte Browsersitzung nach, was wichtig ist, da Redfin Anfragen ablehnt, die so aussehen, als kämen sie von einem reinen Skript. Die Antwortstruktur verschachtelt die meisten nützlichen Felder unter einem payload Schlüssel, wobei die genaue Verschachtelung je nach Art des Angebots variieren kann. Mietobjektspezifische Felder wie petPolicy und amenities erscheinen nicht in Antworten zu Verkaufsangeboten.

Der Endpunkt für Verkaufsobjekte folgt einem ähnlichen Muster, aber das JSON-Schema enthält zusätzliche Felder, die nur bei Kaufangeboten vorkommen. Verkaufsobjekte umfassen historische Preisdaten, Marktwettbewerbswerte und Steuerbewertungsdaten, über die Mietangebote einfach nicht verfügen.

def scrape_for_sale(url: str) -> dict:
    """Fetch for-sale property data from Redfin's internal API."""
    with httpx.Client(headers=HEADERS, follow_redirects=True) as client:
        resp = client.get(url)
        resp.raise_for_status()
        data = clean_json_response(resp.text)

    payload = data.get("payload", {})
    property_info = {
        "address": payload.get("streetAddress", {}).get("assembledAddress"),
        "list_price": payload.get("listingPrice"),
        "price_per_sqft": payload.get("pricePerSqFt"),
        "beds": payload.get("beds"),
        "baths": payload.get("baths"),
        "sqft": payload.get("sqFt"),
        "year_built": payload.get("yearBuilt"),
        "lot_size": payload.get("lotSize"),
        "hoa_dues": payload.get("hoaDues"),
        "property_type": payload.get("propertyType"),
        "mls_number": payload.get("mlsId"),
        "sale_history": payload.get("priceHistory", []),
        "tax_history": payload.get("taxHistory", []),
        "listing_agent": payload.get("listingAgent", {}).get("name"),
    }
    return property_info

Die wesentlichen Unterschiede zum Scraper für Mietobjekte liegen in den Feldern, die Sie extrahieren. Das priceHistory Array liefert Ihnen eine chronologische Aufzeichnung aller Preisänderungen seit Veröffentlichung des Angebots, einschließlich der Ereignisse „Angebot“, „in Bearbeitung“ und „verkauft“. Das taxHistory Feld liefert die im Laufe der Zeit ermittelten Werte, was für die Investitionsanalyse nützlich ist. Felder wie hoaDues und lotSize erscheinen nur in Verkaufsangeboten.

Wenn Sie Verkaufsdaten von Redfin scrapen, achten Sie auf das propertyType Feld. Es gibt an, ob es sich um ein Einfamilienhaus, eine Eigentumswohnung, ein Reihenhaus oder eine Mehrfamilienwohnung handelt, und diese Unterscheidung ist wichtig, wenn Sie die Ergebnisse nach einem bestimmten Marktsegment filtern.

Einzelne Angebote sind nützlich, aber die meisten Immobilien-Datenprojekte erfordern eine Massenauswertung. Die Suchfunktion von Redfin läuft ebenfalls über eine interne API und liefert paginierte Ergebnisse für einen bestimmten Standort oder eine Reihe von Filtern.

Der Such-Endpunkt akzeptiert Parameter wie Regions-ID, Immobilientyp, Preisspanne und Paginierungs-Offset. So erstellen Sie einen Such-Scraper:

import time

def scrape_search_results(region_id: str, max_pages: int = 5) -> list:
    """Scrape paginated Redfin search results for a region."""
    all_listings = []

    with httpx.Client(headers=HEADERS, follow_redirects=True) as client:
        for page in range(1, max_pages + 1):
            search_url = (
                f"https://www.redfin.com/stingray/api/gis?"
                f"region_id={region_id}&region_type=6"
                f"&num_homes=350&page={page}"
            )
            resp = client.get(search_url)
            resp.raise_for_status()
            data = clean_json_response(resp.text)

            homes = data.get("payload", {}).get("homes", [])
            if not homes:
                break

            for home in homes:
                listing = {
                    "address": home.get("streetLine", {}).get("value"),
                    "city": home.get("city"),
                    "state": home.get("state"),
                    "price": home.get("price", {}).get("value"),
                    "beds": home.get("beds"),
                    "baths": home.get("baths"),
                    "sqft": home.get("sqFt", {}).get("value"),
                    "status": home.get("listingType"),
                    "days_on_market": home.get("dom"),
                    "latitude": home.get("latLong", {}).get("latitude"),
                    "longitude": home.get("latLong", {}).get("longitude"),
                    "url": home.get("url"),
                }
                all_listings.append(listing)

            # Respectful delay between pages
            time.sleep(2)

    return all_listings

Sie benötigen die region_id für Ihr Zielgebiet, das Sie finden, indem Sie die Netzwerkanfragen überprüfen, wenn Sie eine Suche auf der Redfin-Website durchführen. Der region_type=6 Parameter gibt eine Suche auf Stadtebene an. Die Paginierung wird durch Inkrementieren des page Parameters, und die Schleife bricht ab, wenn die API ein leeres homes Array zurückgibt.

Beachten Sie den time.sleep(2) Pausen zwischen den Anfragen. Dies ist unverzichtbar, wenn Ihr Scraper länger als ein paar Minuten laufen soll. Wir werden die Ratenbegrenzung im Abschnitt „Anti-Bot“ noch ausführlicher behandeln, aber das Einplanen von Pausen zwischen Ihren Anfragen ist die wichtigste Maßnahme, die Sie ergreifen können, um Redfin-Suchergebnisse zuverlässig zu scrapen.

Sobald Sie Immobiliendaten gesammelt haben, müssen Sie diese in ein nutzbares Format bringen. Sowohl CSV als auch JSON haben ihre Berechtigung: CSV eignet sich besser für die Analyse in Tabellenkalkulationen und den Import in Datenbanken, während JSON verschachtelte Strukturen wie Arrays mit Verkaufsverläufen beibehält.

import csv

def export_to_csv(listings: list, filename: str = "redfin_data.csv"):
    """Export flat listing data to CSV with basic cleaning."""
    if not listings:
        return

    # Normalize price fields: strip $ and commas
    for item in listings:
        if isinstance(item.get("price"), str):
            item["price"] = item["price"].replace("$", "").replace(",", "")

    keys = listings[0].keys()
    with open(filename, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=keys)
        writer.writeheader()
        writer.writerows(listings)

def export_to_json(listings: list, filename: str = "redfin_data.json"):
    """Export listing data to JSON with indentation."""
    with open(filename, "w", encoding="utf-8") as f:
        json.dump(listings, f, indent=2, ensure_ascii=False)

Für den produktiven Einsatz sollten Sie vor dem Export einige Schritte zur Datenbereinigung in Betracht ziehen. Standardisieren Sie Datumsangaben im ISO 8601-Format (YYYY-MM-DD). Konvertieren Sie Preiszeichenfolgen in Ganzzahlen oder Gleitkommazahlen, damit nachgelagerte Tools nicht an Währungssymbolen scheitern. Wenn Sie es mit verschachtelten Feldern wie sale_history, glätten Sie diese für CSV in separate Spalten oder behalten Sie die verschachtelte Struktur in JSON bei. Verwenden Sie pandas mit json_normalize() kann diesen Vereinfachungsschritt bei großen Datensätzen trivial machen.

Die meisten Redfin-Scraping-Tutorials beschränken sich darauf, einzelne Seiten abzurufen. Wenn Sie jedoch eine Pipeline zur Immobilienüberwachung aufbauen, benötigen Sie eine Möglichkeit, neue und kürzlich aktualisierte Angebote automatisch zu erkennen, ohne die gesamte Website erneut zu crawlen.

Redfin veröffentlicht XML-Sitemaps, die dieses Problem lösen. Zum Zeitpunkt der Erstellung dieses Artikels umfassen die relevanten Feeds:

• https://www.redfin.com/newest_listings.xml für kürzlich hinzugefügte Immobilien
• https://www.redfin.com/sitemap_com_latest_updates.xml für kürzlich geänderte Angebote

So analysieren Sie diese Sitemaps und speisen die URLs in Ihren Scraper ein:

from parsel import Selector

def parse_sitemap(sitemap_url: str) -> list:
    """Extract property URLs and last-modified dates from a Redfin sitemap."""
    with httpx.Client(headers=HEADERS) as client:
        resp = client.get(sitemap_url)
        resp.raise_for_status()

    sel = Selector(text=resp.text, type="xml")
    sel.remove_namespaces()

    entries = []
    for url_tag in sel.css("url"):
        loc = url_tag.css("loc::text").get()
        lastmod = url_tag.css("lastmod::text").get()
        entries.append({"url": loc, "last_modified": lastmod})

    return entries

# Example: get newest listings
# new_listings = parse_sitemap("https://www.redfin.com/newest_listings.xml")
# for listing in new_listings[:10]:
#     print(listing["url"], listing["last_modified"])

Die Strategie ist hier ganz einfach: Abrufen der Sitemap nach einem Zeitplan (täglich oder stündlich, je nach Bedarf), Vergleichen der URLs und Zeitstempel mit Ihrer bestehenden Datenbank und Scrapen nur der neuen oder aktualisierten Einträge. Dieser Ansatz ist deutlich effizienter als das Crawlen nach dem Brute-Force-Prinzip, da Sie sich von Redfin mitteilen lassen, was sich geändert hat, anstatt zu raten. Wenn Sie daran interessiert sind, Website-Sitemaps allgemeiner zu scrapen, gilt dieselbe XML-Parsing-Technik für fast jede Website, die dem Sitemap-Protokoll folgt.

Redfin setzt mehrere Schutzebenen gegen automatisierten Zugriff ein. Wenn Ihr Redfin-Scraper 403-Fehler oder CAPTCHA-Seiten zurückgibt, sollten Sie Folgendes überprüfen und so vorgehen.

Browserähnliche Header sind unverzichtbar. Setzen Sie mindestens einen aktuellen User-Agent, Accept, Accept-Languageund Referer Header fest. Unsere Code-Beispiele enthalten diese Header bereits. Wechseln Sie Ihre User-Agent-Zeichenfolge regelmäßig, da ein einziger statischer Wert über Tausende von Anfragen hinweg ein Warnsignal darstellt. Das Verständnis, wie man HTTP-Header einrichtet, ist die Grundlage für jedes Scraping-Projekt.

Der Abstand zwischen den Anfragen ist wichtiger als Proxys. Bevor Sie in eine Proxy-Infrastruktur investieren, versuchen Sie es mit einer Verlangsamung. Eine Verzögerung von 2 bis 5 Sekunden zwischen den Anfragen hält Sie unter den meisten Rate-Limit-Schwellenwerten. Implementieren Sie exponentielles Backoff bei Wiederholungsversuchen: Wenn Sie einen 429- oder 403-Fehler erhalten, warten Sie 30 Sekunden, dann 60, dann 120, bevor Sie aufgeben.

import random

def polite_delay(base: float = 2.0, jitter: float = 1.5):
    """Sleep with randomized jitter to avoid request pattern detection."""
    time.sleep(base + random.uniform(0, jitter))

Bei großem Umfang wird Proxy-Rotation notwendig. Wenn Sie Tausende von Angeboten sammeln müssen, lässt die Rotation durch einen Pool von Residential-Proxys Ihre Anfragen so aussehen, als kämen sie von verschiedenen Nutzern. IP-Adressen von Rechenzentren werden auf Immobilien-Websites tendenziell schnell markiert.

Auch das Sitzungsmanagement ist hilfreich. Redfin verfolgt Cookies über mehrere Anfragen hinweg, sodass die Aufrechterhaltung einer Sitzung (die Wiederverwendung derselben httpx.Client Instanz) kann im Vergleich zum Absenden zustandsloser Anfragen tatsächlich den Verdacht verringern. Achten Sie nur darauf, regelmäßig eine neue Sitzung zu starten.

Bei Projekten mit hohem Datenaufkommen können dedizierte Scraping-APIs Anti-Detection, Proxy-Rotation und CAPTCHA-Lösung hinter einem einzigen Endpunkt abwickeln, sodass Sie sich auf die Parsing-Logik konzentrieren können. Tipps zur Vermeidung von IP-Sperren beim Web-Scraping gelten allgemein für alle Immobilienplattformen, nicht nur für Redfin.

Bevor Sie einen Redfin-Scraper in nennenswertem Umfang einsetzen, müssen Sie die rechtlichen Rahmenbedingungen verstehen. Das Scraping öffentlich zugänglicher Daten von Websites ist in den Vereinigten Staaten generell zulässig, es gibt jedoch wichtige Nuancen.

Was den Datenschutz betrifft, können Immobilienanzeigen personenbezogene Daten enthalten: Namen von Verkäufern, Kontaktdaten von Maklern und manchmal Telefonnummern. Wenn Sie diese Daten speichern oder verarbeiten und Nutzer in der EU bedienen, gelten die DSGVO-Verpflichtungen unabhängig davon, wo sich Ihre Server befinden. Beschränken Sie die Erfassung personenbezogener Daten auf das für Ihren Anwendungsfall erforderliche Minimum und implementieren Sie Aufbewahrungsrichtlinien.

Überlegen Sie schließlich, ob das Scraping für Ihren Anwendungsfall überhaupt notwendig ist. Redfin bietet ein Datenzentrum an, das aggregierte Daten zum Wohnungsmarkt (mittlere Verkaufspreise, Bestandsmengen, Vermarktungsdauer) als kostenlos herunterladbare CSV-Dateien bereitstellt. Wenn Sie eher Trends auf Marktniveau als einzelne Angebote benötigen, könnten die offiziellen Daten ausreichend sein.

• Verwenden Sie die versteckten API-Endpunkte von Redfin, anstatt HTML zu parsen. Die JSON-Antworten sind stabiler, vollständiger und schneller zu verarbeiten als das Scraping gerenderter Seiten.
• Behandeln Sie Miet- und Verkaufsangebote als separate Datenmodelle. Ihre API-Antworten enthalten unterschiedliche Felder, daher sollten Ihre Extraktionslogik und Ihre Ausgabeschemata beide berücksichtigen.
• Überwachen Sie Sitemaps auf neue Angebote, anstatt die gesamte Website erneut zu crawlen. Das newest_listings.xml nach einem Zeitplan ist wesentlich effizienter.
• Beachten Sie zuerst die Ratenbeschränkungen, fügen Sie Proxys erst danach hinzu. Eine Verzögerung von 2 bis 5 Sekunden zwischen den Anfragen verhindert die meisten Sperrungen. Proxys dienen der Skalierung, nicht dem Ersatz grundlegender Höflichkeit.
• Prüfen Sie Redfins offizielle Datenangebote, bevor Sie einen Scraper erstellen. Das Data Center verfügt möglicherweise bereits über die von Ihnen benötigten aggregierten Kennzahlen.

Nein. Redfin bietet keine dokumentierte öffentliche API für Drittentwickler an. Die in diesem Leitfaden verwendeten Endpunkte sind interne APIs, die die Redfin-Website aufruft, um ihre eigenen Seiten zu füllen. Sie sind undokumentiert und können sich ohne Vorankündigung ändern. Sie sollten Ihren Scraper daher mit einer Fehlerbehandlung erstellen, die Schemaänderungen berücksichtigt.

Das Scrapen öffentlich zugänglicher Daten ist in den USA im Allgemeinen legal, befindet sich jedoch in einer Grauzone. Gerichte haben entschieden, dass der Zugriff auf öffentliche Webdaten nicht gegen den Computer Fraud and Abuse Act verstößt, doch ein Verstoß gegen die Nutzungsbedingungen einer Website könnte eine Haftung wegen Vertragsbruchs nach sich ziehen. Konsultieren Sie bei kommerziellen Anwendungsfällen stets einen Rechtsbeistand und scrapen Sie niemals Daten hinter Login-Barrieren ohne Genehmigung.

Beginnen Sie mit realistischen Browser-Headern und fügen Sie eine Verzögerung von 2 bis 5 Sekunden zwischen den Anfragen ein. Variieren Sie Ihre Timings, um vorhersehbare Muster zu vermeiden. Wechseln Sie die User-Agent-Strings und verwenden Sie bei groß angelegten Datenerhebungen Residential-Proxys. Implementieren Sie einen exponentiellen Backoff, wenn Sie 403- oder 429-Antworten erhalten. Die Aufrechterhaltung persistenter Sitzungen mit Cookies verringert zudem das Risiko, entdeckt zu werden.

Zillow, Realtor.com und Trulia sind hinsichtlich der Abdeckung von Immobilienangeboten die am ehesten vergleichbaren Plattformen. Der MLS (Multiple Listing Service) ist die maßgebliche Datenquelle, erfordert jedoch einen lizenzierten Zugang. Für aggregierte Marktstatistiken veröffentlichen das US Census Bureau und die Federal Housing Finance Agency kostenlose Datensätze. Jede Quelle weist unterschiedliche Abdeckung, Aktualisierungshäufigkeit und Zugriffsbeschränkungen auf.

Sie verfügen nun über ein funktionsfähiges Python-Toolkit zum Scraping von Redfin für drei wichtige Datentypen: Mietangebote, zum Verkauf stehende Immobilien und Suchergebnisse. Der Ansatz mit versteckter API liefert Ihnen sauberes, strukturiertes JSON ohne die Anfälligkeit des HTML-Parsings, und die Sitemap-Überwachungstechnik ermöglicht es Ihnen, neue Angebote zu verfolgen, ohne verschwenderische Crawls der gesamten Website durchführen zu müssen.

Von hier aus sind natürliche Erweiterungen unter anderem die Planung Ihres Scrapers mit Cron oder einer Aufgabenwarteschlange, die Speicherung der Ergebnisse in einer Datenbank wie PostgreSQL für historische Analysen und die Erweiterung Ihrer Pipeline auf andere Immobilien-Datenquellen. Wenn Sie feststellen, dass Sie mehr Zeit damit verbringen, Anti-Bot-Schutzmaßnahmen zu umgehen, als Parsing-Logik zu schreiben, kann eine dedizierte Scraping-API wie die Scraper-API von WebScrapingAPI die Proxy-Rotation und das Request-Management für Sie übernehmen, sodass Sie sich auf die Daten selbst konzentrieren können.