Comment scraper les données Houzzproduits et idées avec Python

Houzz est l'une des plus grandes plateformes pour le design d'intérieur, le mobilier et la rénovation, associant un catalogue de produits exhaustif à du contenu éditorial inspirant. Ses pages de produits et de listings publiques contiennent exactement les données structurées qui alimentent le suivi des prix, la recherche concurrentielle et l'analyse des tendances : le nom du produit, le prix, la note et le nombre d'avis, le vendeur ou la marque, la catégorie et le lien vers chaque page produit. Extraire tout cela à la main sur une catégorie de centaines de produits est lent et sujet aux erreurs.

Ce guide vous montre comment scraper les données Houzz avec Python de manière fiable. Vous construisez un petit scraper exécutable qui récupère les pages Houzz rendues via la Crawling API, collecte les liens produits depuis une liste de catégorie, analyse les champs souhaités avec BeautifulSoup, gère la pagination, et exporte du JSON et du CSV propres. L'ensemble du tutoriel se limite aux données de produits publiques, et la section sur la légalité vers la fin n'est pas un texte générique, lisez-la avant de viser un volume réel.

Ce que vous allez construire

Un script Python qui prend une URL de catégorie Houzz publique, collecte les liens vers les pages produits, récupère chaque page rendue via la Crawling API, et extrait un enregistrement structuré par produit. L'exemple fil conducteur est la catégorie des meubles-lavabos et consoles de salle de bain. Nous extrayons ces champs :

• Nom le nom du produit tel qu'affiché sur la carte et la page produit.
• Prix le prix affiché pour le produit.
• Note la note en étoiles moyenne.
• Avis le nombre d'avis clients derrière cette note.
• Vendeur le vendeur, magasin ou marque proposant le produit.
• Catégorie la catégorie dans laquelle le produit se trouve.
• Lien l'URL canonique de la page produit.

Pourquoi une requête simple échoue sur Houzz

Si vous demandez une URL de catégorie ou de produit Houzz avec un client HTTP brut, vous obtenez une réponse avec le statut 200 et seulement une fraction des données dans le corps. Deux obstacles se dressent contre vous. Premièrement, Houzz rend la plupart de sa grille de produits et ses détails produit dans le navigateur via JavaScript, donc le HTML initial est une fine coquille qui ne se remplit qu'après l'exécution des scripts de la page. Extraire les cartes produits de cette première réponse vous donne une poignée d'éléments, voire aucun. Deuxièmement, Houzz détecte rapidement le trafic automatisé : les IP de datacenter et les patterns qui ne ressemblent pas à un vrai navigateur sont soumis à des limites de débit, des blocages IP ou des défis avant d'atteindre le contenu rendu.

Un scraper Houzz fonctionnel a donc besoin de deux choses en une seule requête : un navigateur qui rend réellement la page, et une IP que la plateforme lit comme un vrai visiteur. Vous pouvez assembler cela vous-même avec un navigateur sans interface graphique plus un pool de proxies résidentiels rotatifs, mais les maintenir en bonne santé représente l'essentiel du travail. La Crawling API combine les deux en un seul appel : vous lui envoyez l'URL avec un token JavaScript, elle rend la page derrière une IP de confiance, et elle renvoie le HTML final à analyser. Si les cibles lourdes en JavaScript sont nouvelles pour vous, le guide sur le crawling de sites web JavaScript explique plus en profondeur pourquoi.

Prérequis

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

Python de base. Vous devez être à l'aise pour écrire et exécuter un script Python et installer des paquets avec pip. Si vous découvrez le côté analyse, le guide BeautifulSoup est un bon complément à ce tutoriel.

Python 3.8 ou version ultérieure. Confirmez votre version avec python --version. Si vous ne l'avez pas, installez-le depuis python.org ou via une distribution comme Anaconda, et assurez-vous que Python est dans votre PATH.

Un compte Crawlbase et un token JS. Inscrivez-vous, ouvrez votre tableau de bord et copiez votre token JavaScript (JS) depuis la page docs du compte. Crawlbase inclut jusqu'à 20 000 requêtes gratuites pour commencer, ce qui est largement suffisant pour travailler sur ce guide. Traitez le token comme un mot de passe : il authentifie vos requêtes, gardez-le hors du contrôle de version.

Configurer le projet

Créez un environnement virtuel pour garder les dépendances du projet isolées, puis installez les bibliothèques dont le scraper a besoin.

python --version

python -m venv houzz_env
source houzz_env/bin/activate

pip install crawlbase beautifulsoup4

Sous Windows, activez l'environnement avec houzz_env\Scripts\activate à la place de la ligne source. Deux dépendances font le travail : crawlbase est le client officiel pour la Crawling API, et beautifulsoup4 analyse le HTML renvoyé pour que vous puissiez extraire des champs individuels par sélecteur CSS. json et csv sont fournis avec la bibliothèque standard, il n'y a donc rien de plus à installer pour l'étape d'export.

Étape 1 : Récupérer une page Houzz rendue

Commencez par obtenir une page finale. Importez la classe CrawlingAPI, initialisez-la avec votre token JS, et demandez une URL de catégorie Houzz. Houzz charge sa grille de manière asynchrone, donc passez ajax_wait et page_wait pour attendre le contenu dynamique avant la capture. Vérifier le cb_status (legacy pc_status) Crawlbase avant d'analyser rend les échecs visibles plutôt que silencieux.

from crawlbase import CrawlingAPI

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

OPTIONS = {
    "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/122.0",
    "ajax_wait": "true",
    "page_wait": 5000,
}

def crawl(page_url):
    response = api.get(page_url, OPTIONS)
    if response["headers"]["cb_status"] == "200":
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['headers']['cb_status']}")
    return None

if __name__ == "__main__":
    listing_url = "https://www.houzz.com/products/bathroom-vanities-and-sink-consoles/best-sellers--best-sellers"
    html = crawl(listing_url)
    print(html[:500] if html else "No HTML returned")

Les deux options d'attente sont importantes pour une cible rendue côté client comme Houzz. ajax_wait indique à l'API d'attendre que le contenu asynchrone finisse de se charger, et page_wait attend un nombre fixe de millisecondes après le chargement pour que les cartes à rendu tardif apparaissent avant la capture. Cinq secondes est un point de départ raisonnable ; augmentez-le si les résultats reviennent légers. Lancez le script avec python houzz_scraper.py et vous devriez voir de vrais balisages de catégorie Houzz, pas la coquille qu'une requête simple renvoie. Cela confirme que le rendu fonctionne avant d'écrire un seul sélecteur.

Étape 2 : Collecter les liens produits depuis la page de catégorie

Une page de catégorie Houzz est une grille de cartes produits, chacune liant vers une page produit complète. Chargez le HTML rendu dans BeautifulSoup et extrayez le href depuis le lien de titre de chaque carte. Houzz imbrique ces liens dans son conteneur de liste de produits, donc le sélecteur descend de la liste jusqu'à la carte et son ancre de titre.

from bs4 import BeautifulSoup

CARD_SELECTOR = (
    'div[data-container="Product List"] > div.hz-product-card '
    'a.hz-product-card__product-title'
)

def get_product_urls(html):
    soup = BeautifulSoup(html, "html.parser")
    return [a["href"] for a in soup.select(CARD_SELECTOR) if a.get("href")]

Chaque carte produit porte la classe hz-product-card, et le lien de titre à l'intérieur porte hz-product-card__product-title avec l'URL de la page produit dans son href. Lancer cela contre le HTML de catégorie rendu renvoie une liste propre d'URLs de pages produits :

[
  "https://www.houzz.com/products/the-sequoia-bathroom-vanity-acacia-30-single-sink-freestanding-prvw-vr~170329010",
  "https://www.houzz.com/products/bosque-bath-vanity-driftwood-42-single-sink-undermount-freestanding-prvw-vr~107752516",
  "https://www.houzz.com/products/render-bathroom-vanity-oak-white-prvw-vr~176775440",
  "https://www.houzz.com/products/the-wailea-bathroom-vanity-single-sink-42-weathered-fir-freestanding-prvw-vr~188522678"
]

Étape 3 : Gérer la pagination sur les pages de catégorie

Une page de catégorie est une tranche du catalogue. Houzz expose un lien "page suivante" dans son contrôle de pagination, vous récupérez donc une page, collectez ses liens, puis suivez le lien page suivante jusqu'à ce qu'il n'y en ait plus. Un petit enveloppeur de nouvelle tentative autour de la récupération empêche qu'une page lente mette fin à l'exécution.

import time

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

def fetch_html(page_url, max_retries=2):
    for attempt in range(max_retries + 1):
        html = crawl(page_url)
        if html:
            return html
        if attempt < max_retries:
            print(f"Retrying ({attempt + 1}/{max_retries})...")
            time.sleep(1)
    print(f"Unable to fetch {page_url}")
    return None

def get_next_page_url(soup):
    nxt = soup.select_one("a.hz-pagination-link--next")
    return BASE + nxt["href"] if nxt and nxt.get("href") else None

def collect_all_urls(start_url, max_pages):
    all_urls = []
    url = start_url
    page = 0
    while url and page < max_pages:
        html = fetch_html(url)
        if not html:
            break
        all_urls.extend(get_product_urls(html))
        soup = BeautifulSoup(html, "html.parser")
        url = get_next_page_url(soup)
        page += 1
        time.sleep(2)
    return all_urls

fetch_html réessaie une récupération échouée jusqu'à deux fois avec une courte pause, renvoyant le HTML en cas de succès et None une fois qu'il abandonne. get_next_page_url lit l'ancre hz-pagination-link--next et joint son href relatif à l'hôte Houzz. collect_all_urls suit ce lien page suivante de page en page, plafonnant le crawl à votre limite max_pages pour qu'une grande catégorie ne s'emballe pas, et rassemble les liens de chaque page. Le time.sleep(2) entre les pages espace l'exécution pour que vous ne marteliez pas le site.

Étape 4 : Analyser chaque page produit

Avec une liste complète d'URLs de produits, récupérez chaque page et extrayez les champs. Houzz regroupe les détails principaux autour de son bloc de prix, donc les sélecteurs ci-dessous mappent le nom, le prix, la note, le nombre d'avis, le vendeur et la catégorie vers des éléments individuels. Chaque recherche est gardée pour qu'un champ manquant renvoie None au lieu de faire planter l'exécution.

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

def get_rating(soup):
    star = soup.select_one("span.star-rating")
    if star and star.get("aria-label"):
        return star["aria-label"].replace("Average rating: ", "")
    return None

def scrape_product(html, url):
    soup = BeautifulSoup(html, "html.parser")
    return {
        "link": url,
        "name": text_of(soup, "span.view-product-title"),
        "price": text_of(soup, "span.pricing-info__price"),
        "rating": get_rating(soup),
        "reviews": text_of(soup, "span.review-count"),
        "seller": text_of(soup, "a.seller-name"),
        "category": text_of(soup, "nav.breadcrumb li:last-child"),
    }

L'assistant text_of interroge un élément et renvoie son texte nettoyé, ou None quand l'élément est absent, pour qu'un produit omettant un champ ne casse pas la boucle. Les sélecteurs viennent directement du layout produit de Houzz : name lit le span view-product-title, price lit le span pricing-info__price, et la note réside dans un span star-rating dont l'aria-label se lit comme "4.9 out of 5 stars", que get_rating nettoie. Le nombre d'avis, le vendeur et la catégorie se trouvent dans les métadonnées environnantes ; réinspectez la page en direct si l'un d'eux revient None, car Houzz revise périodiquement ces enveloppeurs.

Étape 5 : Assembler le script complet

Maintenant câblez les pièces dans un script exécutable unique : collectez les URLs sur plusieurs pages, scrapez chaque produit, et exportez les enregistrements en JSON et CSV.

import csv
import json
import time
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

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

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

OPTIONS = {
    "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/122.0",
    "ajax_wait": "true",
    "page_wait": 5000,
}

CARD_SELECTOR = (
    'div[data-container="Product List"] > div.hz-product-card '
    'a.hz-product-card__product-title'
)

def crawl(page_url):
    response = api.get(page_url, OPTIONS)
    if response["headers"]["cb_status"] == "200":
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['headers']['cb_status']}")
    return None

def fetch_html(page_url, max_retries=2):
    for attempt in range(max_retries + 1):
        html = crawl(page_url)
        if html:
            return html
        if attempt < max_retries:
            time.sleep(1)
    return None

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

def get_rating(soup):
    star = soup.select_one("span.star-rating")
    if star and star.get("aria-label"):
        return star["aria-label"].replace("Average rating: ", "")
    return None

def get_product_urls(html):
    soup = BeautifulSoup(html, "html.parser")
    return [a["href"] for a in soup.select(CARD_SELECTOR) if a.get("href")]

def get_next_page_url(soup):
    nxt = soup.select_one("a.hz-pagination-link--next")
    return BASE + nxt["href"] if nxt and nxt.get("href") else None

def collect_all_urls(start_url, max_pages):
    all_urls = []
    url = start_url
    page = 0
    while url and page < max_pages:
        html = fetch_html(url)
        if not html:
            break
        all_urls.extend(get_product_urls(html))
        soup = BeautifulSoup(html, "html.parser")
        url = get_next_page_url(soup)
        page += 1
        time.sleep(2)
    return all_urls

def scrape_product(html, url):
    soup = BeautifulSoup(html, "html.parser")
    return {
        "link": url,
        "name": text_of(soup, "span.view-product-title"),
        "price": text_of(soup, "span.pricing-info__price"),
        "rating": get_rating(soup),
        "reviews": text_of(soup, "span.review-count"),
        "seller": text_of(soup, "a.seller-name"),
        "category": text_of(soup, "nav.breadcrumb li:last-child"),
    }

def save_outputs(records):
    with open("houzz_products.json", "w") as f:
        json.dump(records, f, indent=2)
    if not records:
        return
    with open("houzz_products.csv", "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=records[0].keys())
        writer.writeheader()
        writer.writerows(records)

def main():
    listing_url = "https://www.houzz.com/products/bathroom-vanities-and-sink-consoles/best-sellers--best-sellers"
    urls = collect_all_urls(listing_url, max_pages=2)

    records = []
    for url in urls:
        html = fetch_html(url)
        if html:
            records.append(scrape_product(html, url))
        time.sleep(2)

    save_outputs(records)
    print(f"Saved {len(records)} products")

if __name__ == "__main__":
    main()

Le script collecte les liens produits sur jusqu'à deux pages de catégorie, récupère chaque page produit avec l'enveloppeur de nouvelle tentative, l'analyse dans un enregistrement, et espace la boucle avec un délai de deux secondes. save_outputs écrit à la fois un fichier JSON et un CSV en utilisant les clés du premier enregistrement comme en-tête, vous avez donc les données dans la forme que votre outil en aval préfère. Ajustez max_pages et l'URL de catégorie selon votre cible.

À quoi ressemble la sortie

Lancez le script complet avec python houzz_scraper.py et vous obtenez un enregistrement structuré propre par produit, prêt pour l'analyse, une base de données ou un tableur.

[
  {
    "link": "https://www.houzz.com/products/the-sequoia-bathroom-vanity-acacia-30-single-sink-freestanding-prvw-vr~170329010",
    "name": "The Sequoia Bathroom Vanity, Acacia, 30\", Single Sink, Freestanding",
    "price": "$948",
    "rating": "4.9 out of 5 stars",
    "reviews": "128 Reviews",
    "seller": "Cambridge Plumbing",
    "category": "Bathroom Vanities"
  },
  {
    "link": "https://www.houzz.com/products/render-bathroom-vanity-oak-white-prvw-vr~176775440",
    "name": "Render Bathroom Vanity, Oak White",
    "price": "$295",
    "rating": "4.5 out of 5 stars",
    "reviews": "43 Reviews",
    "seller": "Modway",
    "category": "Bathroom Vanities"
  }
]

Le CSV correspondant porte les mêmes colonnes, une ligne par produit, qui s'intègre directement dans pandas ou n'importe quel tableur pour filtrer par tranche de prix, note ou vendeur. Si votre destination est une feuille de calcul plutôt qu'un script, les mêmes enregistrements alimentent un pipeline de scraping e-commerce sans remise en forme supplémentaire.

Rester non bloqué à grande échelle

Même avec le rendu géré, Houzz surveille le trafic à l'allure d'un scraper. Quelques habitudes maintiennent une exécution plus longue en bonne santé, et elles s'appliquent à toute cible commerciale difficile.

• Espacez vos requêtes. Marteler les pages produits dans une boucle serrée est le moyen le plus rapide d'être ralenti ou mis au défi. Les délais de deux secondes ci-dessus sont le plancher, pas le plafond ; élargissez-les pour les gros travaux et variez vos cibles au lieu de crawler une catégorie à plein régime.
• Misez sur la rotation. Un pool d'IP résidentielles répartit les requêtes sur de nombreuses adresses d'utilisateurs réels pour qu'aucune seule ne déclenche une limite de débit. La Crawling API s'en charge pour vous ; si vous gérez votre propre infrastructure, c'est la partie à bien configurer.
• Lisez les codes de statut. Une exécution qui commence à renvoyer des valeurs cb_status non-200 vous indique que le débit ou le niveau d'IP actuel n'est plus suffisant. Traitez cela comme un signal à ralentir, pas du bruit à ignorer.

Pour les crawls plus importants, le Crawler async met les requêtes en file d'attente et livre les résultats vers un webhook, ce qui convient pour exécuter de nombreuses pages de catégorie sans maintenir des connexions ouvertes. Pour le guide complet, consultez comment scraper des sites web sans être bloqué.

Est-il légal de scraper Houzz ?

La question de savoir si le scraping de Houzz est autorisé dépend des conditions d'utilisation de Houzz, de votre juridiction et de ce que vous faites des données. Les Conditions d'utilisation de Houzz restreignent l'accès automatisé et la collecte de données en masse, donc le scraping peut aller à l'encontre de ces conditions quelle que soit la prudence de votre outillage. Rien dans ce code ne change cela ; il rend simplement la partie technique fonctionnelle. Lisez les Conditions d'utilisation de Houzz et son robots.txt, respectez les attentes de débit et les chemins interdits qu'ils définissent, et traitez les deux comme la limite de ce que vous collectez. Maintenez votre volume de requêtes suffisamment bas pour ne pas mettre à rude épreuve ses serveurs.

Quelques lignes à respecter. Ne collectez que les données de produits et de listings publiques : le nom du produit, le prix, la note, le nombre d'avis, le vendeur ou la marque, et la catégorie que tout le monde peut voir sans compte. Houzz héberge également un large corpus de contenu généré par les utilisateurs, y compris des photos de projets, des idées de design et des avis liés à des individus nommés ; traitez tout ce qui est attaché à une vraie personne comme des données personnelles qui sortent de ce cadre, et notez que le RGPD et la CCPA s'appliquent dès que des données personnelles entrent en jeu. Les photographies de produits et les images de design sur Houzz sont protégées par le droit d'auteur des vendeurs, designers et Houzz lui-même, donc collecter une URL d'image ne vous donne pas le droit de redistribuer, réutiliser ou republier l'image. Restez sur les champs factuels du produit, pas les médias.

Ce guide est délibérément limité aux pages de produits publiques car c'est la ligne qui rend le travail défendable. Il ne couvre rien derrière une connexion, les données de compte ou d'idées sauvegardées, les données personnelles des propriétaires ou professionnels, ni les photos protégées par le droit d'auteur que vous redistribueriez. Si votre projet nécessite plus que les champs de produits publics, la bonne voie est un accord de licence : Houzz gère une API publique et des programmes partenaires pour les cas d'usage permis comme son Trade Program et les intégrations vendeurs, et c'est la bonne route pour l'utilisation commerciale ou en masse, pas un scraper plus astucieux.

Foire aux questions

Pourquoi une requête simple ne renvoie-t-elle presque aucun produit Houzz ?

Parce que Houzz charge sa grille de produits et ses détails produit côté client avec JavaScript. Le HTML initial est une coquille qui ne se remplit qu'après l'exécution des scripts de la page dans un navigateur, donc une requête HTTP brute renvoie le statut 200 avec la plupart des cartes et champs produits manquants. Pour obtenir l'ensemble complet, vous devez d'abord rendre la page, ce que le token JS de la Crawling API gère pour vous.

Ai-je besoin du token normal ou du token JS pour Houzz ?

Le token JS. Le token normal récupère le HTML statique, qui sur Houzz est la même fine coquille qu'une récupération simple renvoie. Le token JS rend la page dans un vrai navigateur avant de renvoyer le HTML, donc les cartes produits et les champs produit sont présents quand BeautifulSoup les analyse.

Quelles données puis-je scraper depuis une page produit Houzz ?

Les champs de produits publics : le nom du produit, le prix, la note moyenne et le nombre d'avis, le vendeur ou la marque, la catégorie et le lien produit. Restez sur les données visibles par tout visiteur sans compte, et évitez les photos de projets, les avis ou tout contenu lié à des individus identifiables, qui sort du cadre du produit public couvert par ce guide.

Mes sélecteurs renvoient None. Qu'est-ce qui a changé ?

Très probablement le balisage de Houzz. Les noms de classes comme hz-product-card, pricing-info__price et star-rating et les attributs de conteneur changent sans préavis, donc les sélecteurs qui fonctionnaient le mois dernier peuvent être cassés. Réinspectez une page en direct dans les outils de développement de votre navigateur et mettez à jour les sélecteurs. La maintenance périodique des sélecteurs est normale pour tout scraper en production.

Comment scraper plus d'une page d'une catégorie Houzz ?

Houzz expose une ancre de page suivante avec la classe hz-pagination-link--next. Lisez son href, joignez-le à l'hôte Houzz, et suivez-le de page en page jusqu'à ce que le lien soit absent ou que vous atteigniez votre plafond max_pages. La fonction collect_all_urls ci-dessus montre la boucle complète, avec un court délai entre les pages.

Puis-je utiliser les données Houzz scrapées commercialement ?

Traitez cela comme une question juridique, pas technique. Les Conditions d'utilisation de Houzz restreignent la réutilisation, une grande partie des images de produits est protégée par le droit d'auteur des vendeurs et designers, et tout contenu d'utilisateur est des données personnelles, donc l'utilisation commerciale ou en masse nécessite généralement une permission. Examinez les conditions, considérez l'API officielle et les programmes partenaires de Houzz, et cherchez un conseil juridique avant de construire un produit sur la base de ces données.

HR

Hassan Rehan

Ingénieur logiciel · Crawlbase

Ingénieur logiciel chez Crawlbase, il rédige des guides pratiques sur les proxys rotatifs, le scraping et les détails concrets de l'intégration de proxys dans du vrai code.