Redfin-Immobiliendaten scrapenListings, Preise und Details

Redfin listet Häuser zum Verkauf und zur Miete in den Vereinigten Staaten und Kanada auf, und jede Listing-Seite enthält genau die strukturierten Daten, die Preisverfolgung, Marktforschung und Immobilienanalyse antreiben: den Angebotspreis, Schlafzimmer, Badezimmer, Quadratmeter, die Straßenadresse und den Link zurück zum Listing. Ziehen Sie das über eine Stadt oder Region und Sie haben einen Datensatz, den Sie vergleichen, aufzeichnen und im Laufe der Zeit beobachten können.

Diese Anleitung zeigt Ihnen, wie Sie Redfin-Immobiliendaten scrapen können, mit Python auf zuverlässige Weise. Sie bauen einen kleinen, lauffähigen Scraper, der ein gerendertes Redfin-Listing über die Crawling API abruft, die gewünschten Felder mit BeautifulSoup parst, durch Such-Paginierung navigiert und das Ergebnis als JSON und CSV exportiert. Die gesamte Anleitung beschränkt sich auf öffentliche Listing-Daten, und der Abschnitt zur Rechtslage am Ende ist kein Boilerplate, also lesen Sie ihn, bevor Sie dies auf ein echtes Volumen anwenden.

Was Sie bauen werden

Ein Python-Skript, das eine öffentliche Redfin-Listing-URL nimmt, das gerenderte HTML über die Crawling API abruft und einen strukturierten Datensatz für die Immobilie extrahiert. Wir verwenden ein einzelnes Verkaufslisting als laufendes Beispiel und extrahieren diese Felder:

• Preis der aufgelistete Verkaufspreis, der auf der Immobilienseite angezeigt wird.
• Schlafzimmer die Anzahl der Schlafzimmer.
• Badezimmer die Anzahl der Badezimmer.
• Quadratmeter die fertige Wohnfläche des Hauses.
• Adresse die Straßenadresse, Stadt, Bundesstaat und Postleitzahl.
• Link die kanonische URL des Listings selbst.

Warum eine einfache Anfrage bei Redfin scheitert

Wenn Sie eine Redfin-Listing-URL mit einem einfachen HTTP-Client anfordern, erhalten Sie normalerweise eines von zwei enttäuschenden Ergebnissen: eine dünne HTML-Shell, bei der die Preis-, Schlafzimmer- und Badezimmerfelder noch leer sind, oder eine Blockseite, bevor Sie das Listing überhaupt erreichen. Zwei Dinge arbeiten gegen Sie. Erstens rendert Redfin einen Großteil seiner Listing-Details im Browser mit JavaScript, sodass das anfängliche HTML, das ein einfacher Abruf sieht, noch keine gesuchten Zahlen enthält. Zweitens betreibt Redfin Anti-Scraping-Maßnahmen, einschließlich IP-Ratenbegrenzung, CAPTCHAs und User-Agent-Erkennung, sodass Datacenter-IPs und Anfragemuster, die nicht wie ein echter Browser aussehen, schnell herausgefordert werden.

Ein funktionierender Redfin-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 von rotierenden residentiellen Proxys zusammenstellen, aber das Zusammenführen und Gesundhalten davon ist der größte Teil der Arbeit. Die Crawling API faltet beides in einen einzigen Aufruf: Sie senden ihr die URL mit einem JavaScript-Token, sie rendert die Seite hinter einer vertrauenswürdigen IP und gibt fertiges HTML zurück, das Sie parsen können.

Voraussetzungen

Vor dem Schreiben von Code müssen einige Dinge eingerichtet sein. Keines davon dauert lange.

Grundlegendes Python. Sie sollten damit vertraut sein, ein Python-Skript zu schreiben und auszuführen sowie Pakete mit pip zu installieren. Wenn Sie neu in der Sprache sind, deckt der Python-Web-Scraping-Leitfaden die Grundlagen ab, die dieses Tutorial voraussetzt.

Python 3.8 oder höher. Bestätigen Sie Ihre Version mit python --version. Falls Sie es nicht haben, 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 Crawling API-Anfragen und keine Kreditkarte erforderlich. Behandeln Sie das Token wie ein Passwort: Es authentifiziert Ihre Anfragen, halten Sie es daher 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 redfin_env
source redfin_env/bin/activate

pip install crawlbase beautifulsoup4

Aktivieren Sie unter Windows die Umgebung mit redfin_env\Scripts\activate anstelle der source-Zeile. Zwei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Client für die Crawling API, und beautifulsoup4 parst das zurückgegebene HTML, sodass Sie einzelne Felder per CSS-Selektor herausziehen können. Wenn Sie den Parser noch nicht verwendet haben, ist der BeautifulSoup-Leitfaden eine gute Ergänzung zu diesem Tutorial.

Schritt 1: Das gerenderte Listing abrufen

Beginnen Sie damit, die fertige Seite zu holen. Importieren Sie die Klasse CrawlingAPI, initialisieren Sie sie mit Ihrem JS-Token und fordern Sie die Listing-URL an. Die Statusprüfung vor dem Parsen sorgt dafür, dass Fehler laut statt still bleiben.

from crawlbase import CrawlingAPI

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

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 5000}
    response = crawling_api.get(page_url, options)
    if response["headers"]["cb_status"] == "200":
        return response["body"].decode("utf-8")
    print(f"Failed to fetch the page. Crawlbase status: {response['headers']['cb_status']}")
    return None

if __name__ == "__main__":
    listing_url = "https://www.redfin.com/CA/North-Hollywood/6225-Coldwater-Canyon-Ave-91606/unit-106/home/5104172"
    html = crawl(listing_url)
    print(html[:500] if html else "No HTML returned")

Die beiden Warteoptionen sind bei einem clientseitig gerenderten Ziel wie diesem wichtig. ajax_wait weist die API an, auf das Fertigladen asynchroner Inhalte zu warten, und page_wait hält eine festgelegte Anzahl von Millisekunden nach dem Laden an, damit spät rendernde Elemente erscheinen, bevor die Seite erfasst wird. Fünf Sekunden sind ein vernünftiger Ausgangspunkt; erhöhen Sie den Wert, wenn der Preis oder die Detailfelder leer zurückkommen. Die Crawlbase-Bibliothek gibt den Status unter response["headers"]["cb_status"] zurück; ein Wert von "200" bedeutet, dass die Seite abgerufen und gerendert wurde. Führen Sie das Skript aus, und Sie sollten echtes Listing-Markup sehen, keine Blockseite, was bestätigt, dass das Rendering funktioniert, bevor Sie einen einzigen Selektor schreiben.

Schritt 2: Die Listing-Felder mit BeautifulSoup parsen

Mit gerendertem HTML laden Sie es in BeautifulSoup und ziehen jedes Feld per Selektor heraus. Redfin legt die wichtigsten Listing-Details in einer vorhersehbaren Struktur aus, sodass Sie Preis, Adresse und die wichtigsten Fakten einzelnen Selektoren zuordnen können. Redfin hat keine öffentliche API für Verkaufsseiten, also ist das XPath-und-CSS-Selektor-Arbeit: Der Preis befindet sich in einem data-rf-test-id="abp-price"-Block, die Adresse teilt sich auf .street-address und .bp-cityStateZip auf, und die Überschriften-Fakten (Schlafzimmer, Badezimmer, Quadratmeter) leben in den .keyDetails-value-Zeilen. Wickeln Sie die Extraktion in einen Helfer, der None zurückgibt, wenn ein Element fehlt, damit ein fehlendes Feld den Lauf nicht zum Absturz bringt.

from bs4 import BeautifulSoup

def text_of(soup, selector):
    el = soup.select_one(selector)
    return el.get_text(strip=True) if el else None

def find_detail(details, keyword):
    for value in details:
        if keyword in value.lower():
            return value
    return None

def parse_property(html, listing_url):
    soup = BeautifulSoup(html, "html.parser")

    price = text_of(soup, 'div[data-rf-test-id="abp-price"] div')

    street = text_of(soup, ".street-address")
    city_state_zip = text_of(soup, ".bp-cityStateZip")
    address = " ".join(filter(None, [street, city_state_zip]))

    details = [d.get_text(strip=True) for d in soup.select(".keyDetails-value")]

    return {
        "address": address or None,
        "price": price,
        "beds": find_detail(details, "bed"),
        "baths": find_detail(details, "bath"),
        "sqft": find_detail(details, "sq ft"),
        "link": listing_url,
    }

Der text_of-Helfer fragt ein Element ab und gibt None zurück, wenn es fehlt, anstatt bei einem Aufruf auf nichts zu werfen. Die Adresse wird aus den zwei Teilen, die Redfin separat rendert, der Straßenzeile und der Stadt/Bundesstaat/PLZ-Zeile, zusammengesetzt und mit einem Leerzeichen verbunden. Die Überschriften-Fakten kommen als flache Liste von .keyDetails-value-Zeichenketten zurück; find_detail wählt die Einträge für Schlafzimmer, Badezimmer und Quadratmeter per Schlüsselwort aus, anstatt sich auf eine feste Position zu verlassen, was kleine Neuanordnungen im Layout überlebt. Diese Struktur hält die Extraktion belastbar, wenn ein Feld bei einem bestimmten Listing fehlt.

Schritt 3: Alles zusammenfügen

Verbinden Sie nun den Abruf und das Parsen zu einem einzigen lauffähigen Skript. Holen Sie das gerenderte HTML, übergeben Sie es an den Parser und drucken Sie den strukturierten Datensatz.

import json
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

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

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 5000}
    response = crawling_api.get(page_url, options)
    if response["headers"]["cb_status"] == "200":
        return response["body"].decode("utf-8")
    print(f"Failed to fetch the page. Crawlbase status: {response['headers']['cb_status']}")
    return None

def text_of(soup, selector):
    el = soup.select_one(selector)
    return el.get_text(strip=True) if el else None

def find_detail(details, keyword):
    for value in details:
        if keyword in value.lower():
            return value
    return None

def parse_property(html, listing_url):
    soup = BeautifulSoup(html, "html.parser")
    price = text_of(soup, 'div[data-rf-test-id="abp-price"] div')
    street = text_of(soup, ".street-address")
    city_state_zip = text_of(soup, ".bp-cityStateZip")
    address = " ".join(filter(None, [street, city_state_zip]))
    details = [d.get_text(strip=True) for d in soup.select(".keyDetails-value")]
    return {
        "address": address or None,
        "price": price,
        "beds": find_detail(details, "bed"),
        "baths": find_detail(details, "bath"),
        "sqft": find_detail(details, "sq ft"),
        "link": listing_url,
    }

def main():
    listing_url = "https://www.redfin.com/CA/North-Hollywood/6225-Coldwater-Canyon-Ave-91606/unit-106/home/5104172"
    html = crawl(listing_url)
    if not html:
        return
    data = parse_property(html, listing_url)
    print(json.dumps(data, indent=2))

if __name__ == "__main__":
    main()

Wie die Ausgabe aussieht

Führen Sie das vollständige Skript aus, und Sie erhalten einen sauberen strukturierten Datensatz für das Listing, bereit zum Schreiben in JSON, CSV oder eine Datenbank.

{
  "address": "6225 Coldwater Canyon Ave #106 Valley Glen, CA 91606",
  "price": "$627,000",
  "beds": "2 beds",
  "baths": "2 baths",
  "sqft": "1,209 sq ft",
  "link": "https://www.redfin.com/CA/North-Hollywood/6225-Coldwater-Canyon-Ave-91606/unit-106/home/5104172"
}

Über Suchseiten und Paginierung skalieren

Ein Listing ist eine Demo; ein echter Job läuft über eine gesamte Suche. Redfin paginiert seine Suchergebnisse, und jede Stadt oder Region hat einen Ergebnispfad, an den Sie eine Seitennummer anhängen können, wie /page-2. Das Muster besteht aus zwei Schichten: Crawlen Sie jede Suchergebnisseite, um die Listing-URLs zu sammeln, und holen Sie dann jedes Listing über dieselbe Funktion parse_property, die Sie bereits geschrieben haben. Listing-Karten auf einer Redfin-Suchseite stellen ihre URL über einen Anker mit dem .bp-Homecard__Photo--image-Wrapper oder dem Link-Element der Karte bereit, sodass Sie die Hrefs sammeln und gegen die Redfin-Domain auflösen können.

import time
from urllib.parse import urljoin

BASE = "https://www.redfin.com"

def collect_listing_urls(search_html):
    soup = BeautifulSoup(search_html, "html.parser")
    cards = soup.select("a.bp-Homecard")
    urls = [urljoin(BASE, a["href"]) for a in cards if a.get("href")]
    return list(dict.fromkeys(urls))

def scrape_search(search_url, pages):
    listings = []
    for page in range(1, pages + 1):
        page_url = search_url if page == 1 else f"{search_url}/page-{page}"
        search_html = crawl(page_url)
        if not search_html:
            continue
        for url in collect_listing_urls(search_html):
            html = crawl(url)
            if html:
                listings.append(parse_property(html, url))
            time.sleep(2)
    print(f"Scraped {len(listings)} listings")
    return listings

Der dict.fromkeys-Schritt entfernt doppelte URLs, die erscheinen, wenn eine Karte mehr als einmal auf dasselbe Listing verweist. Das time.sleep(2) zwischen Listing-Abrufen ist absichtlich: Es verteilt den Lauf, damit Sie Redfin nicht bombardieren, was die wirksamste Einzelgewohnheit ist, um nicht blockiert zu werden. Passen Sie die Seitenanzahl und den Such-Slug an Ihre Zielregion an.

Als JSON und CSV exportieren

Sobald Sie eine Liste von Datensätzen haben, ist das Schreiben in zwei kurzen Funktionen erledigt. JSON behält die vollständige Struktur für nachgelagerten Code; CSV ist das Format, das jede Tabellenkalkulation und jedes BI-Tool liest.

import csv

def save_json(records, path="redfin_listings.json"):
    with open(path, "w", encoding="utf-8") as f:
        json.dump(records, f, indent=2, ensure_ascii=False)

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

if __name__ == "__main__":
    results = scrape_search("https://www.redfin.com/city/11203/CA/Los-Angeles", pages=3)
    save_json(results)
    save_csv(results)

Der CSV-Writer setzt eine explizite Spaltenreihenfolge fest, damit der Header über Läufe hinweg stabil ist, und beide Writer verwenden UTF-8, damit Adressen mit Akzentzeichen den Round-Trip überstehen. Mit JSON und CSV auf der Festplatte können Sie die Daten direkt in ein Notebook, ein Dashboard oder einen Datenbank-Load einspeisen.

Nicht blockiert bleiben

Auch wenn das Rendering übernommen wurde, überwacht Redfin Datenverkehr mit Scraper-förmigen Mustern durch IP-Ratenbegrenzung, CAPTCHAs und User-Agent-Prüfungen. Einige Gewohnheiten halten einen Lauf gesund, die für jedes schwere kommerzielle Ziel gelten.

• Verteilen Sie Ihre Anfragen. Listings in einer engen Schleife zu bombardieren, ist der schnellste Weg, gedrosselt zu werden oder ein CAPTCHA serviert zu bekommen. Verteilen Sie Anfragen, wie das obige sleep es tut, und variieren Sie Ihre Ziele anstatt einen Pfad mit voller Geschwindigkeit zu crawlen.
• Setzen Sie auf Rotation. Ein Pool residentieller IPs verteilt Anfragen auf viele echte Benutzeradressen, sodass keine einzelne ein Ratenlimit auslöst. Die Crawling API kümmert sich darum; wenn Sie Ihren eigenen Stack betreiben, ist das der Teil, den Sie richtig hinbekommen müssen.
• Lesen Sie die Statuscodes. Ein Lauf, der beginnt, Herausforderungen oder Nicht-200-cb_status (legacy pc_status)-Werte zurückzugeben, teilt Ihnen mit, dass die aktuelle Rate oder IP-Ebene nicht mehr ausreicht. Behandeln Sie das als Signal zum Zurückziehen, nicht als Rauschen, das Sie ignorieren.

Das breite Playbook finden Sie unter wie man Websites scrapt, ohne blockiert zu werden. Wenn Sie Ihren eigenen Datenverkehr lieber durch einen rotierenden Pool leiten möchten, bietet der Smart AI Proxy dieselbe residentielle IP-Rotation als Drop-in-Proxy-Endpunkt. Arbeiten Sie als nächstes an anderen Immobilienportalen? Dasselbe Render-dann-Parse-Muster überträgt sich auf Zillow scrapen und Realtor.com scrapen, nur die Selektoren ändern sich.

Ist es legal, Redfin zu scrapen?

Ob das Scrapen von Redfin erlaubt ist, hängt von den Nutzungsbedingungen von Redfin, Ihrer Rechtsordnung und dem ab, was Sie mit den Daten tun. Die Bedingungen von Redfin beschränken den automatisierten Zugriff, daher kann das Scrapen gegen diese Bedingungen verstoßen, unabhängig davon, wie sorgfältig Ihr Tooling ist. Keiner der hier gezeigten Codes ändert das; er macht nur den technischen Teil funktionstüchtig. Lesen Sie die Nutzungsbedingungen von Redfin und seine robots.txt, respektieren Sie die damit implizierten Ratenerwartungen und behandeln Sie beide als Grenze für das, was Sie sammeln.

Einige Grundsätze, an die Sie sich halten sollten. Sammeln Sie nur öffentliche Listing-Daten: den Preis, die Schlafzimmer, Badezimmer, Quadratmeter, die Adresse und den Listing-Link, die jeder ohne ein Konto sehen kann. Halten Sie Ihr Anfragevolumen niedrig genug, dass Sie die Server von Redfin nicht belasten. Bleiben Sie weg von allem, was mit identifizierbaren Personen verbunden ist, einschließlich der Namen und Kontaktdaten von Listing-Agenten oder Eigentümern, die auf einer Seite erscheinen; ein öffentliches Immobilien-Listing ist keine Lizenz zum Erstellen von Profilen der daran beteiligten Personen. Ein Großteil der zugrundeliegenden Immobiliendaten auf Immobilienportalen stammt aus MLS-Feeds, die unter spezifischen Bedingungen lizenziert sind, sodass das Republizieren oder Weiterverkaufen im Großen und Ganzen auf Lizenzierungsbeschränkungen stoßen kann, auch wenn die Seite selbst öffentlich ist.

Diese Anleitung ist bewusst auf öffentliche Listing-Seiten beschränkt, weil das die Grenze ist, die die Arbeit vertretbar macht. Sie deckt nichts hinter einem Login, gespeicherte Such- oder Kontodaten, persönliche Daten von Agenten oder Eigentümern oder Versuche ab, die Authentifizierung zu umgehen. Nur öffentliche Immobiliendaten. Wenn Ihr Projekt einen stetigen, sanktionierten Feed benötigt, bieten Redfin und andere Portale Datenpartnerschaften an, und lizenzierte MLS-Feeds existieren genau für diesen Zweck; eine Lizenzierungsvereinbarung oder ein Immobiliendatenanbieter ist der richtige Weg für Produktionsvolumen und kein ausgefeilterer Scraper.

Häufig gestellte Fragen

Warum gibt eine einfache Anfrage keine Daten von Redfin zurück?

Weil Redfin einen Großteil seiner Listing-Details clientseitig mit JavaScript rendert und automatisierten Datenverkehr herausfordert. Eine einfache HTTP-Anfrage gibt oft eine dünne Shell mit leeren Preis-, Schlafzimmer- und Badezimmerfeldern oder eine Blockseite zurück, bevor das Listing überhaupt geladen wird. Um echte Daten zu erhalten, müssen Sie die Seite hinter einer vertrauenswürdigen IP rendern, was das JS-Token der Crawling API für Sie übernimmt.

Brauche ich das normale Token oder das JS-Token für Redfin?

Das JS-Token. Das normale Token ruft statisches HTML ab, was bei Redfin dieselbe partielle Shell zurückgibt, die auch ein einfacher Abruf liefert. Das JS-Token rendert die Seite in einem echten Browser, bevor es das HTML zurückgibt, sodass die Listing-Felder vorhanden sind, wenn BeautifulSoup sie parst.

Welche Daten kann ich von einem Redfin-Listing scrapen?

Öffentliche Listing-Felder: den Preis, die Anzahl der Schlafzimmer und Badezimmer, die Quadratmeter, die Straßenadresse und den Listing-Link. Bleiben Sie bei Daten, die für jeden Besucher ohne Konto sichtbar sind, und vermeiden Sie die Namen und Kontaktdaten von Agenten oder Eigentümern, die außerhalb des öffentlichen Listing-Umfangs liegen, den diese Anleitung abdeckt.

Meine Selektoren geben None zurück. Was hat sich geändert?

Höchstwahrscheinlich das Markup von Redfin. Der abp-price-Block, die .street-address- und .bp-cityStateZip-Elemente und die .keyDetails-value-Zeilen ändern sich ohne Ankündigung, sodass Selektoren, die letzten Monat funktioniert haben, brechen können. Untersuchen Sie ein Live-Listing in den Entwicklertools Ihres Browsers und aktualisieren Sie die Selektoren. Regelmäßige Selektor-Wartung ist bei jedem Produktionsscraper normal.

Wie verwalte ich die Paginierung über eine Redfin-Suche hinweg?

Redfin hängt ein Seitensegment wie /page-2 an den Suchpfad einer Region an, also crawlen Sie jede Ergebnisseite der Reihe nach, sammeln Sie die Listing-Links aus den Karten darauf und holen Sie jedes Listing mit demselben Parser. Halten Sie einen kurzen Sleep zwischen Anfragen ein und stoppen Sie, wenn eine Seite keine neuen Karten zurückgibt. Die obige Funktion scrape_search zeigt die vollständige Schleife.

Kann ich Redfin-Miet- und Verkaufsseiten mit demselben Ansatz scrapen?

Ja. Das Render-dann-Parse-Muster ist für beide gleich; nur die Selektoren unterscheiden sich, da Miet- und Verkaufsseiten ihre Felder unterschiedlich anordnen. Holen Sie das gerenderte HTML über die Crawling API und richten Sie dann BeautifulSoup auf die Selektoren, die dem Seitentyp entsprechen, den Sie scrapen. Für andere Portale überträgt sich derselbe Ablauf auf Trulia scrapen und andere Immobilien-Sites.

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.