Comment gratter Realtor.com : Guide pratique 2026

Savoir scraper Realtor.com ouvre la voie à une longue liste de cas d'utilisation pratiques. Les équipes d'investissement extraient des annonces pour analyser des biens comparables et entraîner des modèles AVM. Les agences immobilières cherchent à générer des prospects, repérant les biens expirés ou remis en vente avant leurs concurrents. Les analystes de marché suivent les tendances des stocks et des prix code postal par code postal. Les ingénieurs Proptech intègrent les annonces dans des pipelines LLM pour les enrichir. Le point commun : les annonces de Realtor.com sont constamment mises à jour, de sorte que la collecte manuelle devient impossible au-delà d'une poignée de biens, et le scraping structuré est la seule solution raisonnable pour suivre le rythme.

La plupart des tutoriels s'arrêtent à six champs. Vous pouvez en extraire beaucoup plus en parcourant à la fois les résultats de recherche et les pages de détails. À partir d'une fiche de résultats de recherche, les champs fiables sont le prix de l'annonce, l'adresse complète, le nombre de chambres, le nombre de salles de bains, la superficie, la taille du terrain, le statut de l'annonce et l'URL canonique de la page de détails.

En suivant chaque URL de page de détails, vous pouvez extraire :

• Informations sur le bien : année de construction, type de bien, charges de copropriété, parking, dimensions du terrain
• Équipements : chauffage, climatisation, revêtements de sol, appareils électroménagers, caractéristiques extérieures
• Coordonnées géographiques : latitude et longitude (pratique pour la cartographie et les jointures au niveau du code postal)
• Médias : URL des images de la galerie de photos de l'annonce
• Agent : nom de l'agent, numéro de téléphone et agence immobilière
• Métadonnées de l'annonce : identifiant MLS, durée de mise en vente, historique des prix

C'est l'ensemble de données qui alimente les comparaisons, les listes de prospects et les AVM, et pas seulement un simple fichier de prix et d'adresses.

Avant d'écrire du code de scraping, comprenez à quoi vous vous exposez. Realtor.com utilise une pile anti-bot comportementale qui va bien au-delà du blocage d'IP. Des analyses de rétro-ingénierie attribuent cette protection à une pile de fingerprinting de type Kasada ; que Kasada soit ou non le fournisseur actuel, les signaux de détection sont bien documentés dans le domaine de la protection contre les bots.

Trois couches sont importantes pour apprendre à scraper Realtor.com à un volume significatif :

1. Empreintes digitales TLS et JS. Le Python standard requests génère une poignée de main TLS et un ordre d'en-têtes qui ne correspondent pas à ceux des navigateurs réels, ce que le système de Realtor.com peut signaler dès la première requête.
2. Corrélation comportementale. Les proxys d'entropie de la souris, les schémas de défilement et les signaux d'interaction DOM sont évalués par rapport aux distributions humaines. Un scraper qui martèle les pages depuis une seule adresse IP ne ressemble en rien à un humain.
3. Pages CAPTCHA. Lorsque votre score dépasse le seuil, le corps de la page se transforme en page de défi plutôt qu'en annonces, souvent avec un code d'état 200, de sorte qu'un scraper naïf ne se rend même pas compte qu'il a échoué.

Prévoyez ces trois éléments dès le premier jour plutôt que de les ajouter à la va-vite après le premier lot de lignes vides.

Il n'y a pas de réponse unique à la question de savoir comment scraper Realtor.com, mais trois pistes méritent d'être connues, chacune correspondant à un cas d'utilisation différent.

Recommandation rapide : si vous êtes une équipe Python développant un flux de données récurrent, utilisez requests une API de scraping et analysez le HTML avec BeautifulSoup, comme le fait ce guide. N'utilisez un navigateur headless que lorsque vous avez réellement besoin d'interagir avec une vue nécessitant une connexion ou fortement dépendante de JavaScript, et considérez les scrapers visuels sans code comme des outils ponctuels plutôt que comme une infrastructure de production.

Avant d'aborder le scraping de Realtor.com de bout en bout, configurez un environnement vierge. Vous aurez besoin de Python 3.9 ou d'une version plus récente, d'un virtualenv vierge et de quatre paquets :

python -m venv .venv && source .venv/bin/activate
pip install requests beautifulsoup4 lxml pandas

Vous aurez également besoin d'une clé API de scraping. Dans ce guide, nous utiliserons WebScrapingAPI comme couche de requêtes ; inscrivez-vous, copiez votre clé depuis le tableau de bord et enregistrez-la en tant que variable d'environnement afin qu'elle ne se retrouve jamais dans git :

export WSA_KEY="your_key_here"

C'est tout ce qu'il y a à configurer. Pas de pilotes de navigateur, pas de listes de proxys à gérer.

Nous allons maintenant créer le scraper proprement dit en cinq étapes ciblées : inspecter le DOM et identifier des sélecteurs stables, récupérer les pages de recherche via l'API de scraping, analyser les fiches d'annonces avec BeautifulSoup, parcourir les résultats paginés et exporter vers JSON, CSV ou un DataFrame pandas. Les blocs de code ci-dessous partent du principe que la configuration de la section précédente est en place.

Ouvrez les résultats de recherche de Realtor.com dans Chrome, cliquez avec le bouton droit sur une fiche d'annonce et choisissez Inspecter. Chaque fiche est contenue dans un <li> avec data-testid="result-card". Le prix, l'adresse et les champs méta se trouvent à l'intérieur de <div>s et <li>contenant leurs propres data-label attributs (pc-price, pc-address, pc-meta-beds, etc.).

Realtor.com associe également chaque carte à une classe hachée telle que BasePropertyCard_propertyCardWrap__abc123. Ne sélectionnez pas en fonction du hachage. Ces suffixes sont régénérés à chaque build du front-end et perturberont votre scraper sans avertissement. Ancrez-vous sur data-testid les data-label dans la mesure du possible. Ils sont explicitement présents pour les tests du front-end lui-même, ce qui en fait les points d'ancrage les plus stables dont vous disposez.

Une fois les sélecteurs mappés, acheminez la requête via l'API de scraping. L'API se charge de la rotation des proxys résidentiels, du rendu JS et de la gestion des CAPTCHA, ce qui permet à votre code de se concentrer sur l'analyse.

import os, requests

WSA_KEY = os.environ["WSA_KEY"]
SEARCH_URL = "https://www.realtor.com/realestateandhomes-search/Cincinnati_OH"

def fetch(url: str) -> str:
    r = requests.get(
        "https://api.webscrapingapi.com/v2",
        params={
            "api_key": WSA_KEY,
            "url": url,
            "render_js": "1",
            "country": "us",
        },
        timeout=60,
    )
    r.raise_for_status()
    return r.text

html = fetch(SEARCH_URL)

Pourquoi acheminer spécifiquement via une API sur Realtor.com ? Un requests.get se heurtera à une page CAPTCHA après quelques appels, car l'empreinte TLS et l'ordre des en-têtes ne correspondent pas à ceux d'un vrai navigateur. L'API normalise ces deux éléments pour vous et fait tourner l'IP résidentielle à chaque requête.

Une fois le code HTML en main, BeautifulSoup le transforme en un format que vous pouvez interroger. Soyez prudent : toutes les fiches ne contiennent pas tous les champs, alors protégez chaque requête pour qu’un seul champ manquant (comme la superficie du terrain) ne vienne pas corrompre toute la ligne.

from bs4 import BeautifulSoup

def parse_cards(html: str) -> list[dict]:
    soup = BeautifulSoup(html, "lxml")
    cards = soup.select('li[data-testid="result-card"]')
    listings = []
    for card in cards:
        def text(sel):
            el = card.select_one(sel)
            return el.get_text(strip=True) if el else None
        link = card.select_one("a[data-testid='card-link']")
        listings.append({
            "price":    text('[data-label="pc-price"]'),
            "address":  text('[data-label="pc-address"]'),
            "beds":     text('[data-label="pc-meta-beds"] span'),
            "baths":    text('[data-label="pc-meta-baths"] span'),
            "sqft":     text('[data-label="pc-meta-sqft"] span'),
            "lot_size": text('[data-label="pc-meta-sqftlot"] span'),
            "url": link["href"] if link and link.has_attr("href") else None,
        })
    return listings

Nous utiliserons le url champ pour suivre chaque annonce jusqu'à sa page de détail. Si vous préférez utiliser BeautifulSoup de manière plus approfondie, notre guide de parsing Python avec BeautifulSoup est un excellent complément de lecture.

Realtor.com utilise la pagination avec un /pg-N modèle d'URL, et chaque page de résultats renvoie environ 42 annonces (le nombre exact varie, ne le considérez donc pas comme une condition d'arrêt). La stratégie la plus robuste combine un compteur de pages avec une vérification de l'absence de résultats :

def scrape_search(base_url: str, max_pages: int = 10) -> list[dict]:
    all_listings = []
    for page in range(1, max_pages + 1):
        page_url = base_url if page == 1 else f"{base_url}/pg-{page}"
        cards = parse_cards(fetch(page_url))
        if not cards:
            break
        all_listings.extend(cards)
    return all_listings

S'arrêter lorsqu'une page renvoie zéro fiche est bien plus sûr que de se fier à un nombre fixe de fiches par page.

Une fois que vous avez collecté les annonces, passez-les par pandas pour les dédupliquer et les exporter dans le format de votre choix. L'URL de la page de détail est la clé la plus stable par annonce.

import pandas as pd

df = pd.DataFrame(scrape_search(SEARCH_URL))
df = df.drop_duplicates(subset="url").reset_index(drop=True)

df.to_json("realtor_listings.json", orient="records", indent=2)
df.to_csv("realtor_listings.csv", index=False)

Le format CSV est le moyen le plus simple d'importer les données dans Excel et les outils BI. Le format JSON est plus adapté si le code en aval attend des objets imbriqués, en particulier après l'ajout de champs de la page de détail. Dans tous les cas, effectuez un déduplication avant l'exportation, car Realtor.com affiche parfois la même annonce sur des pages de recherche adjacentes.

Les pages de détails contiennent un ensemble de données plus riche : année de construction, équipements, coordonnées de l'agent, latitude/longitude, photos. Realtor.com intègre deux charges utiles structurées :

1. Un <script type="application/ld+json"> bloc respectant le vocabulaire RealEstateListing de schema.org.
2. Une <script id="__NEXT_DATA__"> payload (le blob d'hydratation Next.js) contenant l'enregistrement complet du bien immobilier.

Les deux sont au format JSON :

import json
from bs4 import BeautifulSoup

def parse_detail(html: str) -> dict:
    soup = BeautifulSoup(html, "lxml")
    raw  = soup.find("script", id="__NEXT_DATA__").string
    prop = json.loads(raw)["props"]["pageProps"]["initialReduxState"]["propertyDetails"]
    coord = (prop.get("location", {}).get("address", {}).get("coordinate") or {})
    adv   = (prop.get("advertisers") or [{}])[0]
    return {
        "year_built": prop.get("description", {}).get("year_built"),
        "lat": coord.get("lat"), "lon": coord.get("lon"),
        "amenities": prop.get("description", {}).get("features", []),
        "agent_name":  adv.get("name"),
        "agent_phone": (adv.get("phones") or [{}])[0].get("number"),
        "brokered_by": adv.get("office", {}).get("name"),
        "photos": [p["href"] for p in (prop.get("photos") or [])],
    }

Ce chemin de clé varie ; enregistrez la charge utile brute pendant le développement et réinitialisez-la lorsque vous constatez une KeyError. JSON-LD est plus stable mais expose moins de champs.

Une fois que vous disposez d'un JSON d'annonces propre, un LLM est le moyen le plus rapide de l'enrichir. Évitez le modèle « résumer cette page » ; travaillez par annonces et utilisez des invites structurées.

Deux pipelines qui s'avèrent payants :

• Analyse comparative. Intégrez cinq à dix annonces d’un même code postal dans une seule requête avec un schéma JSON demandant le prix au m² ajusté, les correspondances de type de logement et les indicateurs d’anomalies. Vous obtenez un rapport comparatif en un seul aller-retour.
• Enrichissement des prospects. Transmettez le nom de l'agent, le nom de l'agence et l'URL de l'annonce à un modèle qui renvoie une fiche de contact normalisée avec un score de confiance.

Extraire les pages au format Markdown plutôt qu'en HTML via votre API de scraping réduit le coût des jetons de moitié environ.

Si vous effectuez un scraping de Realtor.com à partir d'une adresse IP de centre de données avec des en-têtes par défaut, vous serez bloqué. Au-delà de ce que gère pour vous une API de scraping, les mesures d'atténuation qui font la différence sont les suivantes :

• Proxys résidentiels. Les adresses IP de centres de données sont signalées en masse ; la rotation résidentielle fait passer le trafic pour celui de vrais visiteurs.
• Rotation des en-têtes. Randomisez User-Agent, Accept-Languageet Sec-Ch-Ua par requête, et veillez à ce qu'ils restent cohérents (un identifiant d'utilisateur iPhone associé à un en-tête de plateforme Windows est un indice immédiat).
• Limitation du débit. Un intervalle de trois à six secondes entre les requêtes vous permet de rester en dessous de la plupart des seuils comportementaux.
• Retard exponentiel. En cas de 403 ou 429, mettez en veille 2 ** attempt + random.random() et faites tourner la session ; ne réessayez jamais sur la même connexion.

Mettre tout cela en place soi-même est un projet ; la plupart des équipes délèguent cette tâche.

Les pages d'annonces de Realtor.com sont publiques ; la collecte de champs relatifs au prix, à l'adresse et à la structure à des fins de recherche interne est donc généralement justifiable, mais ce n'est pas un blanc-seing. Lisez les conditions d'utilisation de Realtor.com et le fichier robots.txt avant de mettre en place un pipeline récurrent. Traitez les noms d'agents, les numéros de téléphone et les e-mails comme des données à caractère personnel au sens de la CCPA californienne et des réglementations analogues ; leur collecte à des fins de revente ou de prospection non sollicitée vous fait entrer dans un domaine réglementé.

Cinq types de défaillances sont à l'origine de la plupart des bugs liés au scraping de Realtor :

• Liste d'annonces vide. Vous êtes sur une page CAPTCHA qui a renvoyé un code 200 ; vérifiez le titre de la page, puis activez le rendu JS au niveau de l'API.
• Décalage de classe hachée. Remplacez tout BasePropertyCard_propertyCardWrap__* sélecteur par un data-testid ou data-label lookup.
• Pics 403 / 429. Allongez le délai de repli, faites tourner la session et n'augmentez la concurrence qu'une fois que votre taux d'erreur s'est stabilisé.
• Champs de détails manquants. Le __NEXT_DATA__ chemin d'accès a été déplacé ; enregistrez la charge utile brute et réassociez les clés.
• Lignes en double. Effectuez toujours une déduplication sur l'URL de la liste avant l'exportation.

• Les sélecteurs d'abord, les requêtes ensuite. Ancrez-vous sur data-testid et data-label , jamais sur des noms de classes hachés comme BasePropertyCard_propertyCardWrap__*, qui se régénèrent à chaque build du front-end.
• Passez par une API de scraping pour la production. Une simple requests atteindra les pages CAPTCHA sur Realtor.com en quelques appels ; une couche API gère les proxys, le rendu JS et l'empreinte TLS en un seul saut.
• Les pages de détail multiplient par 10 votre ensemble de données. L'année de construction, les équipements, les coordonnées de l'agent et les coordonnées géographiques se trouvent dans le __NEXT_DATA__ blob et JSON-LD de chaque page de propriété, et non dans la fiche de résultats de recherche.
• Limitez et reculez, même avec une bonne API. Environ trois à six secondes de jitter, une rotation résidentielle et un backoff exponentiel sur les codes 403/429 permettent de stabiliser les pipelines de longue durée.
• Respectez le cadre légal. Les données des annonces sont publiques ; les coordonnées des agents sont des données personnelles. Lisez les conditions avant de passer à l'échelle et évitez la revente de champs réglementés.

Il n'existe pas d'API publique polyvalente pour parcourir les annonces. La société mère de Realtor.com a historiquement proposé un accès aux API Web RETS et RESO via les flux de données MLS, mais ceux-ci sont réservés aux courtiers ou aux partenaires et ne sont pas ouverts aux développeurs. Pour la plupart des développeurs et analystes indépendants, le scraping structuré des pages d'annonces publiques reste la seule voie pratique pour obtenir des données en masse.

Oui, presque immédiatement. La pile anti-bot de Realtor.com tient à jour des listes des principaux ASN cloud et les limite ou les conteste de manière agressive. Un scraper fonctionnant sur une instance EC2 ou Cloud Run standard sera confronté à des pages CAPTCHA après seulement quelques requêtes. Vous aurez besoin de proxys résidentiels ou mobiles, ou d'une API de scraping gérant la rotation d'IP de manière transparente.

Les trois sites sont rendus par React, paginés et protégés par des piles anti-bot comportementales, mais les détails de mise en œuvre diffèrent. Zillow s'appuie fortement sur sa __NEXT_DATA__ payload et est très strict en matière de vérification des empreintes digitales mobiles. Redfin expose une API JSON interne plus riche utilisée par son frontend. Realtor.com se situe entre les deux : des data-testid hooks sur les cartes et un __NEXT_DATA__ blob sur les pages de détails.

Ne comptez pas sur les classes hachées dès le départ. Ancrez chaque sélecteur sur data-testid et data-label , qui font partie du contrat de test du front-end et changent rarement. Ajoutez un test de validation qui récupère chaque matin une annonce connue et vérifie qu’elle comporte un prix, puis déclenchez une alerte en cas d’échec afin de pouvoir réancrer les sélecteurs avant que le pipeline ne se vide silencieusement.

Une fourchette de départ utile est d'environ trois à six secondes de délai aléatoire entre les requêtes par session, avec une à trois sessions simultanées, chacune sur une adresse IP résidentielle différente. Surveillez votre taux de 403/429 ; s'il dépasse un ou deux pour cent sur une heure, ralentissez davantage ou alternez les proxys de manière plus agressive. Le trafic en rafale est signalé plus rapidement qu'un volume constant.

Savoir comment scraper Realtor.com de bout en bout consiste principalement à empiler les bons éléments dans le bon ordre : fixer des sélecteurs stables, acheminer les requêtes via un système qui gère la pile anti-bot à votre place, suivre les URL des annonces vers les pages de détail pour le reste de l'ensemble de données, et dédupliquer avant l'exportation. Si vous maîtrisez ces étapes, vous disposerez d'un pipeline capable de survivre à la prochaine refonte du front-end au lieu de s'effondrer.

Les parties difficiles – rotation résidentielle, rendu JS, gestion des CAPTCHA – sont précisément ce qui ralentit les équipes pendant des semaines lorsqu’elles sont développées en interne. Ce sont également les parties qui tirent le plus grand bénéfice d’une délégation à une couche de requêtes gérée, afin que vos ingénieurs puissent rester concentrés sur l’analyse, la modélisation et l’analyse en aval.

Si vous préférez ne pas gérer vous-même une flotte de proxys, un générateur d’en-têtes et un solveur de CAPTCHA, notre API Scraper sur WebScrapingAPI est conçue précisément pour ce type de tâche : elle renvoie du code HTML rendu pour n’importe quelle URL que vous lui indiquez, gère les tentatives de reconnexion en cas d’erreurs 403/429 et fait tourner des adresses IP résidentielles dans 195 pays, de sorte que votre scraper donne l’impression que 200 personnes différentes parcourent les annonces de Cincinnati. Intégrez-la à la structure ci-dessus et le seul code que vous aurez à gérer sera la couche d'analyse.