Comment automatiser l'extraction de données immobilièresannonces de propriétés planifiées avec Crawlbase

Les annonces immobilières publiques font partie des données les plus utiles du web ouvert. Le prix, le nombre de chambres, de salles de bain, la superficie et l'adresse figurent directement sur chaque page de résultats, et suivre l'évolution de ces chiffres dans le temps vous indique où un marché se réchauffe, où les loyers s'assouplissent et quelles annonces sont mal évaluées. Le hic, c'est qu'un seul instantané suffit rarement. Les données immobilières n'ont de valeur que lorsqu'elles sont fraîches, ce qui signifie que vous devez les collecter encore et encore, selon un calendrier, sans rester assis devant un terminal à surveiller chaque exécution.

Ce guide vous montre comment automatiser l'extraction de données immobilières avec JavaScript et Node.js. Vous construisez un workflow exécutable qui extrait des annonces publiques via la Crawling API, analyse le prix, le nombre de chambres, de salles de bain, la superficie, l'adresse et le lien pour chaque propriété, puis automatise le tout de trois façons : une exécution cron planifiée pour une collecte régulière, le Crawler asynchrone avec un webhook pour les gros volumes, et un stockage simple pour les résultats. Si vous avez seulement besoin d'un scraping ponctuel d'un seul site, les guides par site liés ci-dessous conviennent mieux. Celui-ci concerne l'exécution répétée du travail. Tout ici reste limité aux données d'annonces publiques, et la section sur la légalité, vers la fin, n'est pas du remplissage, alors lisez-la avant de pointer ceci vers un quelconque volume réel.

Ce que vous allez construire

Un workflow Node.js qui prend une URL publique de recherche de propriétés, récupère le HTML rendu via la Crawling API, extrait un enregistrement structuré pour chaque annonce de la page et s'exécute selon un calendrier. Pour chaque propriété, nous extrayons ces champs :

• Prix le prix affiché sur la carte, comme "$2,400/mo" ou "$525,000".
• Chambres le nombre de chambres.
• Salles de bain le nombre de salles de bain.
• Superficie la surface au sol en pieds carrés.
• Adresse l'adresse postale affichée sur l'annonce.
• Lien l'URL de la page de l'annonce individuelle.

Au-dessus de l'analyseur, vous câblez trois couches d'automatisation : une exécution planifiée, un chemin asynchrone à fort volume, et un stockage JSON avec un horodatage sur chaque lot pour que vous puissiez comparer une collecte à la suivante.

Pourquoi une simple requête échoue sur les sites immobiliers

Si vous demandez une URL de recherche de propriétés avec un client HTTP nu, vous récupérez rarement la grille d'annonces. Deux choses jouent contre vous. D'abord, la plupart des portails immobiliers modernes rendent leurs résultats dans le navigateur avec JavaScript, de sorte que le HTML initial est une coquille quasi vide jusqu'à ce que les scripts de la page s'exécutent. Ensuite, ces sites repèrent agressivement le trafic automatisé : les IP de datacenter et les schémas de requêtes qui ne ressemblent pas à un vrai navigateur sont confrontés à un CAPTCHA, limités en débit ou bloqués avant d'atteindre les annonces rendues.

Un scraper immobilier fonctionnel a donc besoin de deux choses dans une seule requête : un navigateur qui rend réellement la page, et une IP que la plateforme interprète comme un vrai visiteur. Vous pouvez assembler cela vous-même avec un navigateur sans interface plus un pool de proxys résidentiels rotatifs, mais les coudre ensemble et les garder en bonne santé représente l'essentiel du travail, et cela empire dès que vous tournez selon un calendrier et que le volume grimpe. La Crawling API regroupe les deux en un seul appel : vous lui envoyez l'URL, elle rend la page derrière une IP de confiance, et elle vous renvoie un HTML fini que vous pouvez analyser avec cheerio.

Prérequis

Vous avez besoin de quelques éléments en place avant d'écrire le moindre code. Aucun ne prend longtemps.

JavaScript et Node.js de base. Vous devez être à l'aise pour écrire et exécuter un script Node et installer des paquets avec npm. Juste assez pour lire des fonctions suffit amplement.

Node.js 16 ou ultérieur. Confirmez votre version avec node --version. Si vous ne l'avez pas, installez-le depuis le site web de Node.js ou via un gestionnaire de versions comme nvm.

Un compte Crawlbase et un token. Inscrivez-vous, ouvrez votre tableau de bord et copiez votre token. L'offre gratuite vous donne 1 000 requêtes sans carte. Traitez le token comme un mot de passe : il authentifie vos requêtes, donc gardez-le hors du contrôle de version.

Configurer le projet

Créez un dossier de projet, initialisez-le et installez les bibliothèques dont le workflow a besoin.

node --version

mkdir real-estate-automation && cd real-estate-automation
npm init -y

npm install crawlbase cheerio node-cron express

Quatre dépendances font le travail : crawlbase est le client Node officiel de la Crawling API et du Crawler asynchrone, cheerio analyse le HTML renvoyé avec une API à la jQuery pour que vous puissiez en extraire les champs par sélecteur CSS, node-cron exécute le scraping selon un calendrier, et express reçoit le webhook que le Crawler asynchrone renvoie. Créez un fichier nommé scraper.js dans ce dossier et ajoutez le code des étapes ci-dessous.

Étape 1 : Récupérer une page d'annonces rendue

Commencez par obtenir la page finie. Importez la classe CrawlingAPI, initialisez-la avec votre token et demandez une URL de recherche publique. Comme la page est rendue en JavaScript, passez { ajax_wait: true, page_wait: 3000 } pour que l'API attende le chargement des cartes d'annonces avant de renvoyer. Vérifier le code de statut avant l'analyse garde les échecs bruyants plutôt que silencieux.

const { CrawlingAPI } = require('crawlbase');

const api = new CrawlingAPI({ token: 'YOUR_CRAWLBASE_TOKEN' });

const listingsURL = 'https://www.example-realty.com/homes-for-rent/ca/los-angeles';

api
  .get(listingsURL, { ajax_wait: true, page_wait: 3000 })
  .then((response) => {
    if (response.statusCode === 200) {
      console.log(response.body.slice(0, 500));
    }
  })
  .catch((error) => console.error('API request error:', error));

Exécutez le script avec node scraper.js et vous devriez voir un véritable balisage d'annonces en haut du corps, pas une coquille dépouillée. Cela confirme que le rendu fonctionne avant d'écrire le moindre sélecteur. Remplacez listingsURL par la recherche publique que vous voulez suivre : une ville, un quartier, une tranche de prix, l'URL que le site affiche lorsque vous filtrez une recherche dans le navigateur est celle que vous explorez.

Étape 2 : Analyser chaque annonce avec cheerio

Avec le HTML rendu en main, chargez-le dans cheerio et parcourez les cartes d'annonces. Une page de résultats dispose chaque propriété dans un conteneur répété, vous sélectionnez donc chaque carte, puis lisez le prix, les chambres, les salles de bain, la superficie, l'adresse et le lien à l'intérieur. Les sélecteurs exacts ci-dessous proviennent d'une disposition de carte typique ; vous les ajusterez au site que vous ciblez en inspectant une carte dans les outils de développement de votre navigateur. Lire chaque champ de façon défensive empêche une valeur manquante de faire planter l'exécution, et analyser le prix en un nombre vous donne de quoi trier et comparer.

const cheerio = require('cheerio');

function parseListings(html) {
  const $ = cheerio.load(html);
  const properties = [];

  $('li[data-testid="listing-card"]').each((i, el) => {
    const card = $(el);

    const price = card.find('span.listing-card-price').text().trim();
    const priceValue = parseFloat(price.replace(/[^0-9.]/g, ''));

    const beds = card.find('p:contains("Beds") strong').first().text().trim();
    const baths = card.find('p:contains("Baths") strong').first().text().trim();
    const sqft = card.find('p:contains("Sq Ft") strong').first().text().trim();

    const address = card.find('a.listing-card-address').text().trim();
    const href = card.find('a.listing-card-address').attr('href');
    const link = href
      ? new URL(href, 'https://www.example-realty.com').href
      : '';

    if (price && address) {
      properties.push({ price, priceValue, beds, baths, sqft, address, link });
    }
  });

  return properties;
}

Quelques détails gardent cela fidèle à la page. Chaque carte se trouve à l'intérieur d'un conteneur li répété, le prix provient du span de prix et est aussi analysé en un priceValue numérique pour que vous puissiez trier du moins cher en premier, et les chambres, salles de bain et superficie sont lues depuis des blocs étiquetés avec un sélecteur :contains() qui survit à de petits réagencements. L'ancre d'adresse fait aussi office de lien d'annonce, donc un seul find vous donne les deux, et le href est résolu en URL absolue pour qu'il fonctionne en dehors de la page. Seules les cartes ayant un prix et une adresse sont ajoutées, ce qui écarte les tuiles promotionnelles que les sites immobiliers mêlent à une grille de résultats.

Étape 3 : Assembler le scraping et stocker les résultats

Maintenant, câblez la récupération et l'analyse dans une seule fonction qui renvoie des enregistrements propres, puis écrivez chaque lot sur disque avec un horodatage. Garder chaque exécution dans son propre fichier horodaté est ce qui vous permet de comparer une collecte à la suivante et de voir les prix bouger.

const fs = require('fs');

async function scrape(url) {
  const response = await api.get(url, { ajax_wait: true, page_wait: 3000 });
  if (response.statusCode !== 200) {
    console.error(`Request failed: ${response.statusCode}`);
    return [];
  }
  return parseListings(response.body);
}

function save(properties) {
  properties.sort((a, b) => a.priceValue - b.priceValue);
  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
  const file = `listings_${timestamp}.json`;
  fs.writeFileSync(file, JSON.stringify(properties, null, 2));
  console.log(`Saved ${properties.length} properties to ${file}`);
  return file;
}

async function runOnce() {
  const url = 'https://www.example-realty.com/homes-for-rent/ca/los-angeles';
  const properties = await scrape(url);
  if (properties.length) save(properties);
}

module.exports = { scrape, save, runOnce, parseListings };

Collez la fonction parseListings de l'étape 2 et la configuration de l'API de l'étape 1 dans le même fichier pour que scrape puisse les appeler. Exécutez node -e "require('./scraper').runOnce()" et vous obtenez un fichier JSON trié et horodaté de chaque annonce publique de la page. C'est l'unité de travail que les couches d'automatisation ci-dessous planifient et répètent.

Automatisez-le avec un calendrier

Un scraping ponctuel capture un seul instant. Les données immobilières ne sont utiles que lorsqu'elles sont à jour, donc la première couche d'automatisation est une exécution récurrente. Avec node-cron, vous gardez le processus en vie et déclenchez runOnce sur une expression cron. L'exemple ci-dessous s'exécute chaque matin à 7h.

const cron = require('node-cron');
const { runOnce } = require('./scraper');

// Minute Hour DayOfMonth Month DayOfWeek
cron.schedule('0 7 * * *', async () => {
  console.log(`Scheduled run at ${new Date().toISOString()}`);
  try {
    await runOnce();
  } catch (error) {
    console.error('Scheduled run failed:', error.message);
  }
});

console.log('Scheduler started. Waiting for the next run...');

Démarrez-le avec node schedule.js et laissez-le tourner sur un petit serveur ou un conteneur. Chaque matin, il scrape la recherche et dépose un fichier horodaté frais, construisant un historique que vous pouvez comparer pour repérer les changements de prix, les nouvelles annonces et les propriétés qui ont quitté le marché. Si vous préférez ne pas garder un processus en vie, le même appel runOnce fonctionne depuis une entrée cron système ou n'importe quel exécuteur de tâches ; node-cron n'est que l'option en cours de processus. Le motif est identique à celui du guide sur comment automatiser le scraping d'Amazon, où un calendrier transforme un seul scraping en un pipeline de suivi.

Passez à l'échelle avec le Crawler asynchrone et un webhook

Une boucle planifiée convient pour une poignée de recherches. Dès que vous suivez des dizaines de villes ou des milliers de pages d'annonces, attendre tour à tour chaque requête synchrone devient lent, et un processus de longue durée est un endroit fragile pour héberger autant de travail. Le Crawler asynchrone est conçu pour cela : vous lui poussez des URL, Crawlbase les récupère et les rend sur sa propre infrastructure, et il renvoie chaque page finie à un webhook que vous hébergez. Votre code cesse d'attendre les requêtes et se contente de traiter les résultats à mesure qu'ils arrivent.

D'abord, montez un petit point de terminaison qui reçoit les rappels. Le Crawler y poste le HTML rendu, vous analysez et stockez donc directement dans le gestionnaire.

const express = require('express');
const { parseListings, save } = require('./scraper');

const app = express();
app.use(express.text({ type: '*/*', limit: '10mb' }));

app.post('/crawlbase-webhook', (req, res) => {
  const html = req.body;
  const properties = parseListings(html);
  if (properties.length) save(properties);
  res.sendStatus(200);
});

app.listen(3000, () => console.log('Webhook listening on :3000'));

Ensuite, poussez vos URL de recherche au Crawler en nommant le webhook comme rappel. Le Crawler met chacune en file d'attente, la rend et appelle votre point de terminaison avec le résultat, vous pouvez donc soumettre un grand lot et laisser les réponses revenir en flux.

const { Crawler } = require('crawlbase');

const crawler = new Crawler({ token: 'YOUR_CRAWLBASE_TOKEN' });

const searches = [
  'https://www.example-realty.com/homes-for-rent/ca/los-angeles',
  'https://www.example-realty.com/homes-for-rent/ca/san-diego',
  'https://www.example-realty.com/homes-for-rent/ca/san-francisco',
];

for (const url of searches) {
  crawler.post(
    url,
    { callback: 'true', callback_url: 'https://your-server.com/crawlbase-webhook' },
    { ajax_wait: true, page_wait: 3000 }
  );
}

La séparation est l'essentiel. Le Crawler absorbe la partie lente et bloquante, le rendu et les nouvelles tentatives, du côté de Crawlbase, et votre webhook n'exécute jamais que l'étape rapide d'analyse et de stockage. Ce découplage est ce qui permet au même workflow de passer de trois recherches à trois mille sans que votre processus garde chaque requête ouverte. Votre webhook a bien besoin d'une URL publique pendant le développement ; un outil de tunneling expose localhost:3000 pour que le Crawler puisse l'atteindre.

À quoi ressemble la sortie

Qu'un enregistrement provienne de l'exécution planifiée ou du webhook asynchrone, chaque lot a la même forme : un objet par annonce, trié du moins cher en premier, avec le prix, les chambres, les salles de bain, la superficie, l'adresse et le lien.

[
  {
    "price": "$2,400/mo",
    "priceValue": 2400,
    "beds": "2",
    "baths": "1",
    "sqft": "850",
    "address": "1234 Sunset Blvd, Los Angeles, CA 90026",
    "link": "https://www.example-realty.com/property/1234-sunset-blvd"
  },
  {
    "price": "$3,150/mo",
    "priceValue": 3150,
    "beds": "3",
    "baths": "2",
    "sqft": "1,320",
    "address": "88 Maple Ave, Los Angeles, CA 90042",
    "link": "https://www.example-realty.com/property/88-maple-ave"
  }
]

Comme chaque exécution atterrit dans son propre fichier horodaté, comparer deux lots est une différence d'ensembles sur le champ link pour les annonces nouvelles et retirées, et une jointure sur link avec une comparaison de priceValue pour les changements de prix. Cette comparaison est toute la raison d'automatiser : un seul scraping vous dit le marché d'aujourd'hui, un historique planifié vous dit où il va. Si vous voulez les mêmes enregistrements dans un tableur, la version héritée de ce workflow écrivait directement dans Excel avec ExcelJS, et rajouter cet export ne demande que quelques lignes par-dessus le stockage JSON.

Rester débloqué à grand volume

Même avec le rendu pris en charge, les portails immobiliers surveillent le trafic en forme de scraper, et un calendrier qui se déclenche chaque jour rend les schémas faciles à repérer. Quelques habitudes maintiennent une exécution saine.

• Espacez vos requêtes. Répartissez les récupérations plutôt que de marteler les pages dans une boucle serrée. Lorsque vous scrapez de nombreuses recherches, ajoutez un délai entre elles ou appuyez-vous sur le Crawler asynchrone, qui met en file d'attente et cadence le travail pour vous.
• Appuyez-vous sur la rotation. Un pool d'IP résidentielles répartit les requêtes sur de nombreuses adresses de vrais utilisateurs pour qu'aucune seule ne déclenche une limite ou un CAPTCHA. La Crawling API et le Crawler asynchrone s'en chargent pour vous ; si vous montez votre propre pile, c'est la partie à réussir.
• Lisez les codes de statut. Une exécution qui se met à renvoyer des défis ou des réponses non 200 vous indique que le débit actuel ou le palier d'IP ne suffit plus. Traitez cela comme un signal pour lever le pied, pas comme du bruit à ignorer.

Pour le manuel plus large, voyez comment scraper des sites web sans se faire bloquer. Si vous voulez un tutoriel sur un seul site plutôt que cette optique d'automatisation, les guides dédiés sur comment scraper Zillow et comment scraper Redfin couvrent les dispositions de cartes et la pagination spécifiques à ces portails.

Est-il légal de scraper des données immobilières ?

Que le scraping d'un site immobilier soit autorisé dépend des conditions d'utilisation de ce site, de votre juridiction et de ce que vous faites des données. La plupart des portails restreignent l'accès automatisé dans leurs conditions, donc le scraping peut aller à l'encontre de ces conditions, quelle que soit la prudence de votre outillage. Aucun code ici ne change cela ; il fait simplement fonctionner la partie technique. Lisez les Conditions d'utilisation du site et son robots.txt, et traitez les deux comme la limite de ce que vous collectez et de la fréquence à laquelle vous le demandez. Un calendrier rend la discipline de débit plus importante, pas moins.

Limitez le travail aux seules données d'annonces publiques : le prix, les chambres, les salles de bain, la superficie, l'adresse et le lien d'annonce que tout le monde peut voir sur une page de résultats publique sans compte. Ne collectez pas de données personnelles sur les agents, les propriétaires ou les acheteurs au-delà de ce qu'une fiche d'entreprise publique montre déjà, et n'en construisez pas de profils d'individus. Le RGPD et le CCPA s'appliquent dès qu'une donnée personnelle entre en jeu, et une adresse postale publique rattachée à une personne nommée peut en relever, alors penchez vers les faits sur la propriété et éloignez-vous des personnes. Ne redistribuez pas les médias protégés par le droit d'auteur d'un portail, comme les photos d'annonces, comme s'ils étaient les vôtres, et ne touchez à rien derrière une connexion.

Un point propre à ce secteur : une grande partie des données de propriété les plus riches provient du MLS, et les flux MLS sont presque toujours sous licence, et non libres de droits. Si votre projet a besoin de données d'annonces complètes, exactes et redistribuables, le bon chemin est un flux sous licence ou une API officielle, pas un scraper. Plusieurs grands portails proposent des programmes partenaires ou des API pour développeurs précisément pour cette raison. Utilisez-les quand vous avez besoin de volume, d'une structure garantie ou de droits commerciaux. Ce guide est délibérément limité aux annonces publiques sur des pages de recherche publiques, car c'est la ligne qui maintient le travail défendable.

Foire aux questions

Comment automatiser l'extraction de données immobilières selon un calendrier ?

Enveloppez votre scraping dans une fonction et appelez-la depuis un planificateur. L'option en cours de processus la plus simple est node-cron : donnez-lui une expression cron comme 0 7 * * * et il déclenche votre fonction runOnce chaque matin. Chaque exécution dépose un fichier horodaté frais, vous accumulez donc un historique que vous pouvez comparer. Si vous préférez ne pas garder un processus Node en vie, la même fonction fonctionne depuis une entrée cron système ou n'importe quel exécuteur de tâches.

Quand dois-je utiliser le Crawler asynchrone plutôt que la Crawling API ?

Utilisez la Crawling API synchrone lorsque vous scrapez une poignée de recherches et voulez le résultat dans le même appel. Passez au Crawler asynchrone lorsque vous suivez des dizaines de villes ou des milliers de pages d'annonces : vous poussez les URL, Crawlbase les rend sur sa propre infrastructure, et il poste chaque page finie à un webhook que vous hébergez. Ce découplage empêche votre processus d'attendre tour à tour chaque requête lente.

Pourquoi une simple requête renvoie-t-elle des données incomplètes des sites immobiliers ?

Parce que la plupart des portails rendent leur grille d'annonces côté client avec JavaScript et défient le trafic automatisé avec des CAPTCHA. Une requête HTTP brute depuis une IP de datacenter renvoie généralement une coquille vide ou une page de blocage plutôt que les cartes de propriétés. Pour obtenir une page complète, vous devez la rendre derrière une IP de confiance, ce dont la Crawling API se charge pour vous lorsque vous passez les options JavaScript.

Quels champs puis-je extraire d'une annonce de propriété publique ?

Les faits publics sur une carte de résultats : prix, nombre de chambres, nombre de salles de bain, superficie, l'adresse postale et le lien vers la page d'annonce complète. Ce guide analyse exactement ceux-là. Tenez-vous à l'écart des données personnelles sur les agents, les propriétaires ou les acheteurs, et des médias protégés par le droit d'auteur comme les photos d'annonces, qui portent tous deux des contraintes légales et de licence que les faits publics sur une propriété n'ont pas.

Mes sélecteurs renvoient des valeurs vides. Qu'est-ce qui a changé ?

Presque certainement le balisage du site. Les noms de classe des cartes d'annonces et les valeurs data-testid sont générés et changent sans préavis, donc des sélecteurs qui marchaient le mois dernier peuvent casser, surtout sur un calendrier qui tourne sans surveillance. Réinspectez une carte en direct dans les outils de développement de votre navigateur et mettez à jour le sélecteur. Une maintenance périodique des sélecteurs est normale pour tout scraper en production.

Vaut-il mieux scraper ou utiliser un flux MLS ?

Pour des données d'annonces complètes, exactes et redistribuables, un flux MLS sous licence ou une API officielle de portail est le bon outil, puisque les données MLS sont presque toujours sous licence plutôt que libres de droits. Scraper des pages de recherche publiques convient pour suivre des faits d'annonces publics à volume modeste, pour la recherche et l'analyse des mouvements de prix, limité aux données publiques et dans le cadre des conditions de chaque site. Adaptez la source à l'usage : faits publics et volume léger favorisent un scraper, usage complet ou commercial favorise un flux sous licence.

HO

Henry Obinna

Rédacteur de contenu indépendant

Rédacteur de contenu indépendant ayant contribué des guides de web scraping et d'outillage open source au blog Crawlbase.