Comment scraper les données produits de Costcoprix, articles et disponibilité

Costco exploite plus de 800 entrepôts dans le monde, et le même catalogue est disponible sur costco.com sous forme de pages produits publiques et de résultats de recherche. Les prix, les numéros d'article, les notes et les statuts de stock sont tous visibles sur la page par quiconque, sans compte. Ces données publiques constituent un signal fiable pour le suivi des prix, la recherche concurrentielle et la surveillance des stocks, c'est pourquoi les détaillants, les analystes et les développeurs les récupèrent selon un calendrier régulier.

Ce guide vous montre comment scraper les données produits de Costco avec Python. Vous construisez un scraper simple et fonctionnel qui récupère les pages de recherche et de produits Costco via la Crawling API, analyse un enregistrement propre pour chaque article, gère la pagination dans les résultats de recherche et exporte les données en JSON et CSV. L'ensemble de la démonstration se concentre sur les données produits publiques : les titres, prix, numéros d'article, notes et disponibilités que tout le monde peut voir sur une annonce sans se connecter.

Ce que vous allez construire

Un script Python qui prend une URL de recherche Costco ou une URL de produit, récupère la page rendue via la Crawling API et extrait un enregistrement structuré par produit. Nous utilisons une recherche de canapés comme exemple tout au long de ce tutoriel, la même catégorie que dans l'ancien guide, et nous extrayons ces champs :

• Titre le nom du produit affiché sur l'annonce ou la page produit.
• Prix le prix affiché, quand le produit en montre un.
• Numéro d'article l'identifiant unique du produit Costco, utile pour suivre les stocks entre plusieurs exécutions.
• Note la note moyenne en étoiles, lue sur la carte produit ou la page.
• Disponibilité le signal de disponibilité en stock sur la page produit.
• URL du produit le lien vers la page de détail de l'article.
• URL de l'image la source de l'image du produit.

Pourquoi une requête simple échoue sur Costco

Si vous pointez un client HTTP basique vers une URL de recherche ou de produit Costco, vous obtenez rarement les données que vous cherchez. Deux obstacles se dressent contre vous. Premièrement, les pages Costco rendent une grande partie de leur contenu côté client : le site envoie un squelette léger et remplit la grille de produits et les blocs de prix au fur et à mesure que le JavaScript de la page s'exécute, de sorte que le HTML initial manque souvent les champs que vous voulez. Deuxièmement, Costco détecte rapidement le trafic automatisé. Les plages d'adresses IP de datacenter et les modèles de requêtes qui ne ressemblent pas à un vrai navigateur se heurtent à un challenge, une page interstitielle ou un blocage direct avant même d'atteindre les annonces.

Un scraper Costco fonctionnel a donc besoin de deux choses en une seule requête : un navigateur qui rend la page, et une adresse IP que le site considère comme un vrai acheteur. Vous pouvez assembler cela vous-même avec un navigateur sans tête et un pool de proxies résidentiels rotatifs, mais maintenir cette infrastructure en bon état représente l'essentiel du travail. La Crawling API regroupe les deux en un seul appel : vous lui envoyez l'URL, elle rend la page derrière une adresse IP résidentielle de confiance, gère la rotation et la résolution des CAPTCHA, et vous renvoie le HTML terminé à analyser.

Prérequis

Quelques éléments doivent être en place avant d'écrire du code. Aucun ne prend beaucoup de temps.

Bases de Python. Vous devez être à l'aise pour écrire et exécuter un script Python et installer des paquets avec pip. Si vous débutez dans ce langage, la documentation officielle Python ou tout cours pour débutants couvre le niveau requis pour ce tutoriel.

Python 3.8 ou version ultérieure. Vérifiez votre version avec python --version (ou python3 --version). Si vous ne l'avez pas, installez-le depuis python.org et assurez-vous que Python est dans le PATH de votre système.

Un compte Crawlbase et un token. Inscrivez-vous pour un compte gratuit, ouvrez votre tableau de bord et copiez votre token. Les pages Costco sont très dépendantes de JavaScript, vous voulez donc le token JavaScript pour ces requêtes. Le niveau gratuit inclut jusqu'à 20 000 requêtes sans carte bancaire, ce qui est largement suffisant pour construire et tester ce scraper. Traitez le token comme un mot de passe et ne le mettez pas dans le contrôle de version.

Configurer le projet

Créez un environnement virtuel pour que les dépendances du projet restent isolées, puis installez les deux bibliothèques dont le scraper a besoin. crawlbase est le client officiel pour la Crawling API, et beautifulsoup4 analyse le HTML retourné pour que vous puissiez extraire chaque champ de la page par sélecteur CSS.

python --version

python -m venv costco_env
source costco_env/bin/activate

pip install crawlbase beautifulsoup4

Sous Windows, activez l'environnement avec costco_env\Scripts\activate à la place de la ligne source. Une fois les deux bibliothèques installées, créez le fichier script que le reste du guide va construire :

touch costco_scraper.py

Comprendre les pages Costco

Il existe deux types de pages à scraper, et elles ont un balisage différent. Une page de résultats de recherche comme https://www.costco.com/s?dept=All&keyword=sofas présente une grille de cartes produits. Une page produit comme https://www.costco.com/coddle-aria-fabric-sleeper-sofa.product.4000223041.html affiche la vue détaillée complète d'un article, incluant la description, les caractéristiques et la disponibilité.

Avant d'écrire des sélecteurs, ouvrez chaque page dans votre navigateur, faites un clic droit sur un produit et choisissez Inspecter. Sur la page de recherche, Costco enveloppe l'annonce dans div[id="productList"] et regroupe les articles sous div[data-testid="Grid"]. Chaque carte expose le titre dans un div dont le data-testid commence par Text_ProductTile_, le prix dans celui commençant par Text_Price_, la note sous Rating_ProductTile_, le lien dans une ancre a[data-testid="Link"], et l'image dans une balise img. Sur la page produit, le titre est un h1[automation-id="productName"], le prix un span[automation-id="productPriceOutput"], et la note un div[itemprop="ratingValue"]. Ce sont les éléments que vous ciblez.

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

Commencez par obtenir la page terminée. Importez la classe CrawlingAPI, initialisez-la avec votre token, définissez l'URL de recherche et faites la requête. Costco charge sa grille de manière asynchrone, donc passez les options ajax_wait et page_wait pour laisser à la page le temps de se terminer avant d'être capturée. Vérifier le code de statut avant d'analyser permet de rendre les échecs visibles plutôt que silencieux.

from crawlbase import CrawlingAPI

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

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 5000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

if __name__ == "__main__":
    search_url = "https://www.costco.com/s?dept=All&keyword=sofas"
    html = crawl(search_url)
    print(html[:500] if html else "No HTML returned")

Les deux options d'attente sont importantes pour une grille qui se remplit au chargement de la page. ajax_wait indique à l'API d'attendre que le contenu asynchrone soit terminé, et page_wait maintient une pause pour un nombre fixe de millisecondes après le chargement afin que les cartes à rendu tardif apparaissent avant la capture de la page. Exécutez le script et vous devriez voir le vrai balisage produit, non pas un squelette de chargement. Cela confirme que le rendu fonctionne avant d'écrire un seul sélecteur.

Étape 2 : Analyser les résultats de recherche avec BeautifulSoup

Avec le HTML rendu en main, chargez-le dans BeautifulSoup, trouvez chaque carte produit et extrayez chaque champ par son sélecteur. Costco regroupe les articles sous div[id="productList"] > div[data-testid="Grid"], et chaque carte expose son titre, son prix, sa note, son lien et son image. Enveloppez la boucle pour qu'un champ manquant retourne une valeur de repli propre plutôt que de planter l'exécution.

from bs4 import BeautifulSoup
import re

def item_number_from_url(url):
    match = re.search(r"\.product\.(\d+)\.html", url or "")
    return match.group(1) if match else "N/A"

def scrape_search_listings(html):
    soup = BeautifulSoup(html, "html.parser")
    products = []
    items = soup.select('div[id="productList"] > div[data-testid="Grid"]')
    for item in items:
        title_el = item.select_one('div[data-testid^="Text_ProductTile_"]')
        price_el = item.select_one('div[data-testid^="Text_Price_"]')
        rating_el = item.select_one('div[data-testid^="Rating_ProductTile_"] > div')
        link_el = item.select_one('a[data-testid="Link"]')
        image_el = item.find("img")

        product_url = link_el["href"] if link_el else "N/A"
        products.append({
            "title": title_el.get_text(strip=True) if title_el else "N/A",
            "price": price_el.get_text(strip=True) if price_el else "N/A",
            "item_number": item_number_from_url(product_url),
            "rating": rating_el["aria-label"] if rating_el and rating_el.has_attr("aria-label") else "N/A",
            "product_url": product_url,
            "image_url": image_el["src"] if image_el and image_el.has_attr("src") else "N/A",
        })
    return products

Chaque carte correspond à un dictionnaire propre. Le titre vient de div[data-testid^="Text_ProductTile_"] et le prix de div[data-testid^="Text_Price_"], tous deux utilisant la correspondance par préfixe ^= car Costco suffixe ces identifiants de test par produit. La note est lue depuis l'attribut aria-label sur le div de note imbriqué, qui contient le texte lisible "Average rating is 4.65 out of 5 stars". Le numéro d'article est extrait de l'URL du produit, car Costco l'encode dans le segment .product.NNNN.html, vous obtenez ainsi un identifiant stable sans sélecteur supplémentaire sur la page. Chaque champ se replie sur "N/A" quand il est absent, ce qui maintient l'extraction résiliente car toutes les cartes n'affichent pas un prix ou une note.

Étape 3 : Gérer la pagination dans les pages de recherche

Les résultats de recherche Costco s'étendent sur plusieurs pages, et le site charge chacune d'elles avec un paramètre &currentPage= sur l'URL. Pour collecter une catégorie complète, ajoutez ce paramètre et parcourez les pages dans l'ordre, en rythmant les requêtes pour ne pas surcharger le site dans une boucle rapide.

import time

def scrape_all_pages(base_url, total_pages):
    all_products = []
    for page_num in range(1, total_pages + 1):
        paginated_url = f"{base_url}&currentPage={page_num}"
        print(f"Scraping page {page_num}")
        html = crawl(paginated_url)
        if not html:
            break
        found = scrape_search_listings(html)
        if not found:
            break
        all_products.extend(found)
        time.sleep(2)
    return all_products

La sortie sur résultats vides vous arrête tôt quand une catégorie n'a plus de pages, et le time.sleep(2) entre les requêtes rythme l'exécution pour que vous ne soyez pas signalé pour un trafic en rafale. Définissez total_pages sur le nombre de pages de résultats que couvre la recherche pour votre mot-clé.

Étape 4 : Scraper une page produit individuelle

Les cartes de recherche vous donnent les champs principaux, mais la page produit contient le reste : la description complète, les caractéristiques structurées et le signal de disponibilité. La page se rend de la même manière que la grille de recherche, donc réutilisez le helper crawl et analysez les sélecteurs de détail.

def scrape_product_page(html, url):
    soup = BeautifulSoup(html, "html.parser")

    title_el = soup.select_one('h1[automation-id="productName"]')
    price_el = soup.select_one('span[automation-id="productPriceOutput"]')
    rating_el = soup.select_one('div[itemprop="ratingValue"]')
    desc_el = soup.select_one('div[id="product-tab1-espotdetails"]')
    image_el = soup.find("img", class_="thumbnail-image")
    stock_el = soup.select_one('div[automation-id="productInventoryStatus"]')

    specifications = {}
    for row in soup.select("div.product-info-description .row"):
        name = row.select_one(".spec-name")
        value = row.select_one("div:not(.spec-name)")
        if name and value:
            specifications[name.get_text(strip=True)] = value.get_text(strip=True)

    return {
        "title": title_el.get_text(strip=True) if title_el else "N/A",
        "price": price_el.get_text(strip=True) if price_el else "N/A",
        "item_number": item_number_from_url(url),
        "rating": rating_el.get_text(strip=True) if rating_el else "N/A",
        "availability": stock_el.get_text(strip=True) if stock_el else "N/A",
        "description": desc_el.get_text(strip=True) if desc_el else "N/A",
        "image_url": image_el["src"] if image_el and image_el.has_attr("src") else "N/A",
        "specifications": specifications,
    }

Les sélecteurs de la page produit viennent directement du balisage de détail de Costco. Le titre est un h1[automation-id="productName"], le prix un span[automation-id="productPriceOutput"], la note un div[itemprop="ratingValue"], et le bloc de description se trouve sous div[id="product-tab1-espotdetails"]. La boucle des caractéristiques parcourt chaque .row dans le tableau de description, lit le libellé depuis .spec-name et le couple avec la cellule de valeur voisine, vous obtenez ainsi un dictionnaire propre d'attributs comme le matériau de la structure et les dimensions. La disponibilité est lue depuis le bloc de statut de l'inventaire ; réutilisez le même helper item_number_from_url pour que l'identifiant reste cohérent avec les enregistrements de recherche.

Étape 5 : Assembler le script et exporter en JSON et CSV

Maintenant, reliez la récupération, la pagination et les analyseurs en un script fonctionnel, puis écrivez les enregistrements en JSON et CSV pour pouvoir les charger dans un notebook ou un tableur. Une liste de champs partagée maintient les colonnes CSV en accord avec les clés du dictionnaire.

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

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})
FIELDS = ["title", "price", "item_number", "rating", "product_url", "image_url"]

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 5000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

def item_number_from_url(url):
    match = re.search(r"\.product\.(\d+)\.html", url or "")
    return match.group(1) if match else "N/A"

def scrape_search_listings(html):
    soup = BeautifulSoup(html, "html.parser")
    products = []
    items = soup.select('div[id="productList"] > div[data-testid="Grid"]')
    for item in items:
        title_el = item.select_one('div[data-testid^="Text_ProductTile_"]')
        price_el = item.select_one('div[data-testid^="Text_Price_"]')
        rating_el = item.select_one('div[data-testid^="Rating_ProductTile_"] > div')
        link_el = item.select_one('a[data-testid="Link"]')
        image_el = item.find("img")
        product_url = link_el["href"] if link_el else "N/A"
        products.append({
            "title": title_el.get_text(strip=True) if title_el else "N/A",
            "price": price_el.get_text(strip=True) if price_el else "N/A",
            "item_number": item_number_from_url(product_url),
            "rating": rating_el["aria-label"] if rating_el and rating_el.has_attr("aria-label") else "N/A",
            "product_url": product_url,
            "image_url": image_el["src"] if image_el and image_el.has_attr("src") else "N/A",
        })
    return products

def scrape_all_pages(base_url, total_pages):
    all_products = []
    for page_num in range(1, total_pages + 1):
        paginated_url = f"{base_url}&currentPage={page_num}"
        print(f"Scraping page {page_num}")
        html = crawl(paginated_url)
        if not html:
            break
        found = scrape_search_listings(html)
        if not found:
            break
        all_products.extend(found)
        time.sleep(2)
    return all_products

def export(rows, name="costco_products"):
    with open(f"{name}.json", "w", encoding="utf-8") as f:
        json.dump(rows, f, indent=2, ensure_ascii=False)
    with open(f"{name}.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=FIELDS)
        writer.writeheader()
        writer.writerows(rows)
    print(f"Saved {len(rows)} products to {name}.json and {name}.csv")

def main():
    base_url = "https://www.costco.com/s?dept=All&keyword=sofas"
    products = scrape_all_pages(base_url, total_pages=5)
    export(products)

if __name__ == "__main__":
    main()

Exécutez le script complet avec python costco_scraper.py. Il parcourt les pages de recherche, analyse une ligne par produit et écrit à la fois costco_products.json et costco_products.csv. La liste FIELDS partagée maintient l'ordre des colonnes CSV en accord avec les clés du dictionnaire, de sorte que les deux exports ne divergent jamais. Pour enrichir les données avec des descriptions, des caractéristiques et la disponibilité, passez chaque product_url à crawl et scrape_product_page de l'étape 4.

À quoi ressemble la sortie

Vous obtenez une liste propre d'enregistrements produits, prête à être écrite en JSON, CSV ou dans une base de données.

[
  {
    "title": "Coddle Aria Fabric Sleeper Sofa with Reversible Chaise Gray",
    "price": "$1,299.99",
    "item_number": "4000223041",
    "rating": "Average rating is 4.65 out of 5 stars. Based on 1668 reviews.",
    "product_url": "https://www.costco.com/coddle-aria-fabric-sleeper-sofa-with-reversible-chaise-gray.product.4000223041.html",
    "image_url": "https://cdn.bfldr.com/U447IH35/at/nx2pbmjk76t8c5k4h3qpsg6/4000223041-847_gray_1.jpg"
  },
  {
    "title": "Larissa Fabric Chaise Sofa",
    "price": "$1,899.99",
    "item_number": "4000052035",
    "rating": "Average rating is 4.03 out of 5 stars. Based on 87 reviews.",
    "product_url": "https://www.costco.com/larissa-fabric-chaise-sofa.product.4000052035.html",
    "image_url": "https://cdn.bfldr.com/U447IH35/as/ck2h3n29gz2j6m7c9f7x4rhm/4000052035-847_gray_1"
  }
]

Une exécution sur une page produit retourne un enregistrement plus riche, avec la description, le signal de disponibilité et un dictionnaire de caractéristiques d'attributs comme le style du dossier, le matériau de la structure et les dimensions globales extraits directement du tableau de détail.

Rester non bloqué

Même avec le rendu géré, Costco surveille le trafic qui ressemble à celui d'un scraper. Quelques habitudes maintiennent une exécution en bonne santé, et elles s'appliquent à toute cible commerciale difficile.

• Rythmez vos requêtes. Étalez les requêtes avec un délai entre les pages plutôt que de tout crawler à pleine vitesse. Planifiez les tâches plus lourdes pendant les heures creuses pour alléger la charge sur les serveurs de Costco.
• Misez sur la rotation. Un pool d'adresses IP résidentielles répartit les requêtes sur de nombreuses adresses d'utilisateurs réels afin qu'aucune ne déclenche une limite de débit. La Crawling API gère cela pour vous ; si vous construisez votre propre infrastructure, c'est la partie à bien maîtriser.
• Ne conservez que ce dont vous avez besoin. Stockez les champs produit que votre projet utilise et écartez le reste. Vérifiez périodiquement vos sélecteurs pour que le scraper suive les évolutions du balisage.

Pour le manuel général sur la façon d'éviter les blocages, consultez comment scraper des sites web sans être bloqué, et pour en savoir plus sur l'importance du rendu ici, comment crawler des sites web JavaScript. Les données que vous collectez alimentent directement les travaux d'intelligence tarifaire, et les schémas généraux s'appliquent aux autres boutiques couvertes dans ce guide de web scraping e-commerce.

Est-il légal de scraper Costco ?

Que le scraping de Costco soit autorisé dépend des conditions d'utilisation de Costco, de votre juridiction et de ce que vous faites avec les données. Les conditions de Costco restreignent l'accès automatisé, de sorte que 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 de Costco et son robots.txt, et traitez les deux comme la limite de ce que vous collectez. Pour une utilisation commerciale ou concurrentielle, le tableau juridique devient plus complexe, et consulter un expert juridique sur votre cas spécifique est la démarche raisonnable.

Quelques lignes à tenir. Ne collectez que les données publiques : les titres, prix, numéros d'article, notes, disponibilités et liens d'annonces que tout le monde peut voir sur une page Costco sans compte. Maintenez votre volume de requêtes suffisamment bas pour ne pas surcharger les serveurs de Costco, et évitez les données personnelles, y compris tout ce qui est lié à des membres, évaluateurs ou vendeurs identifiables au-delà de ce qui est listé publiquement. Si vous prévoyez de réutiliser les données commercialement, obtenez une autorisation ou un accord officiel plutôt que de supposer que le silence vaut consentement.

Ce guide est délibérément limité aux pages de produits et de recherche publiques car c'est la ligne qui rend le travail défendable. Il ne couvre rien derrière une connexion, les données de membre ou de commande, les prix affichés uniquement aux membres connectés, ni toute tentative de contourner une authentification ou un CAPTCHA que vous n'êtes pas autorisé à passer. Si votre projet a besoin de plus que des données produits publiques, un accord officiel de données ou un programme partenaire est la bonne voie, pas un scraper plus ingénieux.

Foire aux questions

Pourquoi une requête simple ne retourne-t-elle aucun produit depuis Costco ?

Costco rend une grande partie de sa grille de produits et de ses blocs de prix côté client au chargement de la page, de sorte qu'une requête brute obtient souvent un squelette manquant les champs que vous voulez. De plus, Costco challenge ou bloque le trafic qui ne ressemble pas à un vrai navigateur. Rendre la page via la Crawling API derrière une IP de confiance, avec les options ajax_wait et page_wait définies, résout les deux problèmes, c'est pourquoi le scraper ici achemine sa requête à travers elle.

Quelles données puis-je extraire de Costco avec ce scraper ?

Dans les résultats de recherche, vous obtenez le titre, le prix, le numéro d'article, la note, l'URL du produit et l'URL de l'image pour chaque carte. Depuis une page produit individuelle, vous obtenez également la description, le tableau complet des caractéristiques et le signal de disponibilité. Tout cela est des données produits publiques que vous pouvez stocker en JSON ou CSV pour analyse.

Comment scraper plusieurs pages de résultats de recherche Costco ?

Costco charge chaque page de recherche avec un paramètre &currentPage= sur l'URL. Ajoutez ce paramètre et bouclez sur les numéros de page, en analysant chaque page à son tour et en s'arrêtant tôt quand une page ne retourne aucun produit. Ajoutez un court délai entre les requêtes pour rythmer l'exécution plutôt que de surcharger le site.

Comment obtenir le numéro d'article Costco ?

Costco encode le numéro d'article dans l'URL du produit, dans le segment .product.NNNN.html. Le scraper l'extrait avec un petit helper regex, vous obtenez ainsi un identifiant stable depuis les cartes de recherche et les pages produits sans dépendre d'un sélecteur sur la page qui pourrait changer.

Ai-je besoin du token JavaScript pour scraper Costco ?

Oui. Les pages de Costco dépendent de JavaScript pour rendre la grille de produits, les prix et la disponibilité, vous voulez donc le token JavaScript et les options d'attente quand vous appelez la Crawling API. Le niveau gratuit inclut jusqu'à 20 000 requêtes pour construire et tester, et vous pouvez vérifier les tarifs actuels sur la page de tarification.

Comment éviter d'être bloqué lors du scraping de Costco ?

Maintenez un faible taux de requêtes par IP, ajoutez un délai entre les pages et routez via des IP résidentielles rotatives afin qu'aucune adresse unique ne déclenche une limite de débit. La Crawling API gère la rotation, un pool d'IP de confiance et la gestion des CAPTCHA pour vous ; si vous construisez votre propre infrastructure, c'est la partie dans laquelle investir. Surveillez les codes de statut et reculez quand vous commencez à voir des challenges.

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.