Comment récupérer les données de Redfin : Guide Python des données immobilières

Redfin est l'une des plus grandes plateformes immobilières aux États-Unis, couvrant des millions d'annonces résidentielles dans pratiquement toutes les zones métropolitaines. Si vous avez besoin de scraper Redfin pour une analyse de marché, une étude d'investissement ou la création d'une base de données immobilière, l'architecture interne de la plateforme joue en fait en votre faveur. Contrairement aux sites qui affichent tout côté serveur, le front-end de Redfin extrait les données à partir de points de terminaison API cachés qui renvoient du JSON bien structuré. Cela signifie que vous pouvez extraire les données immobilières par programmation sans avoir à vous battre avec des sélecteurs CSS qui ne fonctionnent plus à chaque fois que le site met à jour sa mise en page.

Dans ce tutoriel, vous allez créer de zéro un scraper Redfin basé sur Python. Nous aborderons trois cibles de scraping distinctes (annonces de location, biens à vendre et résultats de recherche), nous vous montrerons comment surveiller les nouveaux biens mis en vente via les sitemaps XML de Redfin, et nous vous guiderons à travers l'exportation de vos données au format CSV et JSON. Au cours de ce tutoriel, nous aborderons la limitation de débit, les protections anti-bot et les considérations juridiques à garder à l'esprit avant de lancer un projet de scraping immobilier à grande échelle.

Avant d'écrire le moindre code, il est utile de savoir ce que Redfin expose réellement. La plateforme organise les informations sur les biens immobiliers en plusieurs catégories, et connaître les champs de données disponibles vous aidera à planifier les points de terminaison à cibler et à définir la structure de votre schéma de sortie.

Voici une référence des principales cibles de scraping et des champs auxquels vous pouvez vous attendre :

Les points de terminaison de location et de vente renvoient des schémas JSON différents, ce qui est important lors de la conception de votre pipeline de données. Les annonces de vente comprennent des champs tels que l'historique des ventes et les indicateurs de performance du marché qui n'apparaissent pas dans les réponses de location, tandis que les données de location contiennent des champs spécifiques aux baux, tels que la politique relative aux animaux de compagnie et les exigences en matière de caution.

Vous aurez besoin de Python 3.8 ou d'une version ultérieure pour ce projet. Nous nous appuierons sur deux bibliothèques principales : httpx pour effectuer des requêtes HTTP (elle gère bien l'asynchronisme et dispose d'une API épurée) et parsel pour analyser les réponses HTML ou XML, en particulier lors de l'utilisation de plans de site.

Créez un répertoire de projet et installez les dépendances :

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

Vous pouvez également ajouter pandas si vous souhaitez un nettoyage des données plus avancé lors de l'exportation :

pip install pandas

Votre requirements.txt devrait ressembler à ceci :

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

C'est tout ce dont vous avez besoin pour commencer. Pas de bibliothèques d'automatisation de navigateur, pas de Selenium, pas de Playwright. Comme nous ciblons directement les points de terminaison API cachés de Redfin, un simple client HTTP suffit.

Lorsque vous chargez une page de propriété Redfin dans votre navigateur, le code HTML visible n'est pour l'essentiel qu'une coquille vide. Les données réelles relatives à la propriété sont récupérées de manière asynchrone à partir de points de terminaison API internes. Vous pouvez découvrir ces points de terminaison par vous-même en ouvrant les DevTools de votre navigateur (F12), en accédant à l'onglet Réseau et en filtrant les requêtes « XHR » ou « Fetch » pendant le chargement d'une page d'annonce.

Vous verrez alors une série de requêtes vers des URL telles que https://www.redfin.com/stingray/api/home/details/... qui renvoient des données structurées. Les réponses commencent généralement par un préfixe de commentaire (du type {}&&{) suivi d'un JSON valide. Ce préfixe est un mécanisme de protection contre les scripts intersites ; vous devrez donc le supprimer avant l'analyse.

Cette approche « API-first » pour le scraping de Redfin présente des avantages significatifs par rapport à l'analyse HTML traditionnelle :

• Stabilité : les noms de champs JSON changent rarement, tandis que les noms de classes CSS peuvent varier à chaque déploiement.
• Exhaustivité : la réponse de l'API contient souvent plus de données que ce qui est affiché sur la page visible.
• Rapidité : vous effectuez une seule requête par annonce au lieu de charger une page complète avec des images, des scripts et des feuilles de style.
• Simplicité : pas besoin d'automatisation du navigateur. Un client HTTP standard gère tout.

Pour trouver le bon point de terminaison pour n'importe quel type d'annonce, chargez la page, observez les requêtes réseau et recherchez celle qui contient l'essentiel des données immobilières dans sa réponse JSON. Le modèle d'URL comprendra des identifiants tels que l'ID de la propriété ou une adresse encodée en URL.

Commençons par les annonces de location. Redfin fournit des données sur les locations via un chemin API dédié qui diffère du point de terminaison des annonces de vente. Lorsque vous visitez la page d'une annonce de location, le navigateur envoie une requête à un point de terminaison qui renvoie tous les détails de la location au format JSON.

Voici un exemple complet et fonctionnel qui récupère une annonce de location :

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))

Quelques remarques concernant ce code. La clean_json_response fonction gère le préfixe XSS que Redfin ajoute en tête des réponses API. Les en-têtes imitent une véritable session de navigateur, ce qui est important car Redfin rejette les requêtes qui semblent provenir d’un simple script. La structure de la réponse imbrique les champs les plus utiles sous une payload clé, bien que l'imbrication exacte puisse varier en fonction du type d'annonce. Les champs spécifiques à la location, tels que petPolicy et amenities n'apparaîtront pas dans les réponses concernant les biens à vendre.

Le point de terminaison « à vendre » suit un modèle similaire, mais le schéma JSON comporte des champs supplémentaires propres aux annonces de vente. Les propriétés à vendre incluent des données historiques sur les prix, des scores de compétitivité sur le marché et des dossiers d'évaluation fiscale que les annonces de location ne possèdent tout simplement pas.

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

Les principales différences par rapport au scraper de location résident dans les champs que vous extrayez. Le priceHistory tableau vous fournit un historique chronologique de chaque changement de prix depuis la mise en ligne de l'annonce, y compris les événements de mise en vente, de vente en cours et de vente conclue. Le taxHistory champ fournit les valeurs d'évaluation au fil du temps, ce qui est utile pour l'analyse d'investissement. Des champs tels que hoaDues et lotSize n'apparaissent que dans les annonces de vente.

Lorsque vous récupérez les données de vente de Redfin, prêtez attention au propertyType champ . Il vous indique s'il s'agit d'une maison individuelle, d'un appartement, d'une maison mitoyenne ou d'un immeuble collectif, et cette distinction est importante si vous filtrez les résultats pour un segment de marché spécifique.

Les annonces individuelles sont utiles, mais la plupart des projets de données immobilières nécessitent une extraction en masse. La fonctionnalité de recherche de Redfin s'exécute également via une API interne, renvoyant des résultats paginés pour un emplacement donné ou un ensemble de filtres.

Le point de terminaison de recherche accepte des paramètres tels que l'identifiant de la région, le type de bien, la fourchette de prix et le décalage de pagination. Voici comment créer un scraper de recherche :

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

Vous aurez besoin de l' region_id pour votre zone cible, que vous pouvez trouver en inspectant les requêtes réseau lorsque vous effectuez une recherche sur le site web de Redfin. Le region_type=6 indique une recherche au niveau de la ville. La pagination est gérée en incrémentant le page , et la boucle s'arrête lorsque l'API renvoie un homes .

Notez l' time.sleep(2) intervalle entre les requêtes. Ce n’est pas facultatif si vous voulez que votre scraper fonctionne plus de quelques minutes. Nous aborderons la limitation de débit plus en détail dans la section anti-bot, mais espacer vos requêtes est la chose la plus importante que vous puissiez faire pour extraire de manière fiable les résultats de recherche de Redfin.

Une fois que vous avez collecté les données immobilières, vous devez les mettre dans un format utilisable. Les formats CSV et JSON ont chacun leur utilité : le CSV est mieux adapté à l'analyse sur tableur et à l'importation dans des bases de données, tandis que le JSON préserve les structures imbriquées telles que les tableaux d'historique des ventes.

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)

Pour une utilisation en production, envisagez quelques étapes de nettoyage des données avant l'exportation. Standardisez les chaînes de date au format ISO 8601 (YYYY-MM-DD). Convertissez les chaînes de prix en entiers ou en nombres à virgule flottante afin que les outils en aval ne soient pas bloqués par les symboles monétaires. Si vous avez affaire à des champs imbriqués comme sale_history, aplatissez-les en colonnes distinctes pour le CSV ou conservez la structure imbriquée dans le JSON. Utilisez pandas avec json_normalize() peut simplifier considérablement cette étape d'aplatissement pour les grands ensembles de données.

La plupart des tutoriels de scraping Redfin s'arrêtent à la récupération de pages individuelles. Mais si vous construisez un pipeline de surveillance immobilière, vous avez besoin d'un moyen de découvrir automatiquement les nouvelles annonces et celles récemment mises à jour sans avoir à explorer à nouveau l'ensemble du site.

Redfin publie des sitemaps XML qui résolvent ce problème. Au moment de la rédaction de cet article, les flux pertinents incluent :

• https://www.redfin.com/newest_listings.xml les propriétés récemment ajoutées
• https://www.redfin.com/sitemap_com_latest_updates.xml pour les annonces récemment modifiées

Voici comment analyser ces sitemaps et intégrer les URL dans votre scraper :

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"])

La stratégie est simple : interrogez le plan du site selon une fréquence définie (quotidienne ou horaire, selon vos besoins), comparez les URL et les horodatages avec votre base de données existante, et ne scrapez que les entrées nouvelles ou mises à jour. Cette approche est nettement plus efficace que l'exploration par force brute, car vous laissez Redfin vous indiquer ce qui a changé au lieu de deviner. Si vous souhaitez extraire les sitemaps de sites web de manière plus générale, la même technique d'analyse XML s'applique à presque tous les sites qui respectent le protocole sitemap.

Redfin utilise plusieurs niveaux de protection contre les accès automatisés. Si votre scraper Redfin commence à renvoyer des erreurs 403 ou des pages CAPTCHA, voici ce qu'il faut vérifier et comment y remédier.

Les en-têtes de type navigateur sont indispensables. Au minimum, définissez un User-Agent, Accept, Accept-Languageet Referer . Nos exemples de code incluent déjà ces en-têtes. Faites tourner votre chaîne User-Agent périodiquement, car une valeur statique unique sur des milliers de requêtes est un signal. Comprendre comment configurer les en-têtes HTTP est fondamental pour tout projet de scraping.

L'espacement des requêtes est plus important que les proxys. Avant d'investir dans une infrastructure de proxys, essayez de ralentir le rythme. Un délai de 2 à 5 secondes entre les requêtes vous permettra de rester en dessous de la plupart des seuils de limitation de débit. Mettez en place un délai d'attente exponentiel lors des tentatives de reconnexion : si vous obtenez un 429 ou un 403, attendez 30 secondes, puis 60, puis 120 avant d'abandonner.

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))

La rotation des proxys devient nécessaire à grande échelle. Si vous devez collecter des milliers d'annonces, la rotation au sein d'un pool de proxys résidentiels donne l'impression que vos requêtes proviennent de différents utilisateurs. Les adresses IP de centres de données ont tendance à être rapidement signalées sur les sites immobiliers.

La gestion des sessions est également utile. Redfin suit les cookies d'une requête à l'autre, donc le fait de maintenir une session (en réutilisant la même httpx.Client instance) peut en fait réduire les soupçons par rapport à l'envoi de requêtes sans état. Veillez simplement à démarrer une nouvelle session périodiquement.

Pour les projets à fort volume, des API de scraping dédiées peuvent gérer l'anti-détection, la rotation des proxys et la résolution des CAPTCHA derrière un seul point de terminaison, vous permettant ainsi de vous concentrer sur la logique d'analyse. Les conseils pour éviter les interdictions d'IP lors du scraping web s'appliquent de manière générale à toutes les plateformes immobilières, et pas seulement à Redfin.

Avant d'exécuter un scraper Redfin à une échelle significative, vous devez comprendre le contexte juridique. Le scraping de données accessibles au public sur des sites web est généralement autorisé aux États-Unis, mais il existe des nuances importantes.

En matière de confidentialité des données, les annonces immobilières peuvent contenir des informations personnelles identifiables : noms des vendeurs, coordonnées des agents et parfois numéros de téléphone. Si vous stockez ou traitez ces données et servez des utilisateurs dans l'UE, les obligations du RGPD s'appliquent quel que soit l'emplacement de vos serveurs. Limitez la collecte d'informations personnelles identifiables au strict nécessaire pour votre cas d'utilisation et mettez en place des politiques de conservation.

Enfin, demandez-vous si le scraping est vraiment nécessaire pour votre cas d'utilisation. Redfin propose un centre de données qui fournit des données agrégées sur le marché immobilier (prix de vente médians, niveaux de stock, durée de mise en vente) sous forme de fichiers CSV téléchargeables gratuitement. Si vous avez besoin de tendances au niveau du marché plutôt que d'annonces individuelles, les données officielles peuvent suffire.

• Utilisez les points de terminaison API cachés de Redfin plutôt que d'analyser le code HTML. Les réponses JSON sont plus stables, plus complètes et plus rapides à traiter que le scraping de pages rendues.
• Traitez les annonces de location et de vente comme des modèles de données distincts. Leurs réponses API contiennent des champs différents, votre logique d'extraction et vos schémas de sortie doivent donc tenir compte des deux.
• Surveillez les plans de site pour détecter les nouvelles annonces plutôt que de réindexer l'ensemble du site. Effectuer des requêtes newest_listings.xml selon un calendrier est nettement plus efficace.
• Respectez d'abord les limites de débit, ajoutez les proxys ensuite. Un délai de 2 à 5 secondes entre les requêtes permet d'éviter la plupart des blocages. Les proxys servent à la mise à l'échelle, pas à remplacer les règles de courtoisie de base.
• Vérifiez les offres de données officielles de Redfin avant de créer un scraper. Le Data Center dispose peut-être déjà des métriques agrégées dont vous avez besoin.

Non. Redfin ne propose pas d'API publique documentée pour les développeurs tiers. Les points de terminaison utilisés dans ce guide sont des API internes que le site web de Redfin appelle pour alimenter ses propres pages. Elles ne sont pas documentées et peuvent changer sans préavis ; vous devez donc créer votre scraper avec une gestion des erreurs qui tienne compte des modifications de schéma.

Le scraping de données accessibles au public est généralement légal aux États-Unis, mais il s'agit d'une zone grise. Les tribunaux ont statué que l'accès aux données Web publiques ne violait pas la loi sur la fraude et les abus informatiques (Computer Fraud and Abuse Act), mais le non-respect des conditions d'utilisation d'un site pourrait entraîner une responsabilité pour rupture de contrat. Consultez toujours un professionnel du droit pour les cas d'utilisation commerciale, et ne scrapez jamais de données protégées par un identifiant sans autorisation.

Commencez par utiliser des en-têtes de navigateur réalistes et ajoutez un délai de 2 à 5 secondes entre les requêtes. Aléatoirez vos intervalles pour éviter les schémas prévisibles. Alternez les chaînes User-Agent et, pour une collecte à grande échelle, utilisez des proxys résidentiels. Mettez en place un backoff exponentiel lorsque vous recevez des réponses 403 ou 429. Le maintien de sessions persistantes à l'aide de cookies réduit également le risque de détection.

Zillow, Realtor.com et Trulia sont les plateformes les plus comparables en termes de couverture des annonces. Le MLS (Multiple Listing Service) est la source de données de référence, mais nécessite un accès sous licence. Pour les statistiques agrégées du marché, le Bureau du recensement des États-Unis et l'Agence fédérale de financement du logement publient des ensembles de données gratuits. Chaque source a une couverture, une fréquence de mise à jour et des restrictions d'accès différentes.

Vous disposez désormais d'une boîte à outils Python fonctionnelle pour extraire les données de Redfin à travers trois types de données principaux : les annonces de location, les biens à vendre et les résultats de recherche. L'approche via l'API cachée vous fournit un JSON propre et structuré sans la fragilité de l'analyse HTML, et la technique de surveillance du plan du site vous permet de suivre les nouveaux biens sans avoir à effectuer de crawls inutiles de l'ensemble du site.

À partir de là, les extensions naturelles incluent la planification de votre scraper avec cron ou une file d'attente de tâches, le stockage des résultats dans une base de données comme PostgreSQL pour l'analyse historique, et l'extension de votre pipeline pour couvrir d'autres sources de données immobilières. Si vous passez plus de temps à lutter contre les protections anti-bot qu'à écrire de la logique de parsing, une API de scraping dédiée comme la Scraper API de WebScrapingAPI peut gérer la rotation des proxys et la gestion des requêtes à votre place, afin que vous puissiez vous concentrer sur les données elles-mêmes.