Comment scraper les données produits Targetprix, produits et disponibilité

Target.com est l'un des plus grands catalogues de vente au détail aux États-Unis, avec des millions de pages de produits publiques couvrant l'électronique, l'habillement, les articles ménagers et l'épicerie. Chaque annonce porte les données qui alimentent la plupart des recherches en retail : un titre, un prix actuel, un identifiant TCIN, une note en étoiles et un signal clair de disponibilité en stock ou en rupture. Les trackers de prix, les analystes de la concurrence et les chercheurs en produits surveillent ces champs parce qu'ils offrent l'une des lectures les plus nettes de ce qu'un grand détaillant facture et stocke à tout moment.

Ce guide vous montre comment scraper des données de produits Target avec Python. Vous construisez un petit script fonctionnel qui récupère une page de recherche ou de produit Target via la Crawling API, analyse un enregistrement propre pour chaque produit, gère la pagination sur les pages de résultats et exporte en JSON et CSV. L'ensemble du tutoriel reste limité aux données de catalogue publiques : les titres, les prix, les notes et la disponibilité que tout le monde peut voir sur Target.com sans se connecter.

Ce que vous allez construire

Un script Python qui prend une URL de recherche Target, récupère la page rendue via la Crawling API et extrait un enregistrement structuré par produit. Nous utilisons une recherche "womens sweaters" comme exemple fil conducteur, la même requête que l'ancien tutoriel utilisait, et extrayons ces champs de chaque fiche produit :

• Title le nom du produit affiché sur la fiche d'annonce.
• Price le prix listé actuel, qui peut être une valeur unique ou une plage.
• TCIN / SKU l'identifiant de produit propre à Target, lu depuis l'URL du produit.
• Rating la note en étoiles moyenne, dérivée de la largeur de la barre de notation.
• Review count combien d'avis soutiennent cette note.
• Availability si l'article est en stock ou indisponible.
• Product URL le lien absolu vers la page de détail de l'article.

Pourquoi une requête simple échoue sur Target

Si vous pointez un client HTTP nu vers une URL de recherche Target, vous obtenez un résultat presque vide. Target rend sa grille de recherche côté client : le serveur envoie une coquille légère, et les fiches produits ne se remplissent qu'après l'exécution du JavaScript de la page. Analysez une réponse requests.get() simple et vous verrez une liste vide, parce que les produits que vous cherchiez n'étaient jamais dans ce premier payload HTML.

De plus, Target surveille le trafic automatisé et bloque les modèles de requêtes qui ne ressemblent pas à un vrai navigateur. Un scraper Target fonctionnel a donc besoin de deux choses en une seule requête : un navigateur qui rend la page, et une adresse IP que Target perçoit comme un vrai acheteur. Vous pouvez assembler cela vous-même avec un navigateur sans interface graphique et un pool de proxies résidentiels rotatifs, mais maintenir cette pile en bonne santé représente l'essentiel du travail. La Crawling API regroupe les deux en un seul appel : vous lui envoyez l'URL de recherche, 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 retourne le HTML finalisé à analyser.

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 êtes novice dans ce langage, le guide pour débuter avec le scraping Python couvre le niveau que ce tutoriel suppose.

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 depuis la page de documentation du compte. Crawlbase émet deux tokens : un token normal pour les sites statiques et un token JavaScript pour les pages dynamiques rendues par JS. Target est rendu par JS, donc ce tutoriel utilise le token JavaScript. Le niveau gratuit inclut 1 000 requêtes sans carte, 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é afin que vous puissiez extraire chaque champ des fiches produits par sélecteur CSS.

python --version

python -m venv target_env
source target_env/bin/activate

pip install crawlbase beautifulsoup4

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

touch target_scraper.py

Comprendre la page de recherche Target

Une recherche Target se trouve à une URL stable : https://www.target.com/s?searchTerm=womens+sweaters. La page présente une grille de fiches produits, une par article, chacune portant le même ensemble de champs : un titre, un prix, une barre de note en étoiles, un nombre d'avis et un lien vers la page de détail du produit. Target marque la plupart d'entre eux avec des attributs data-test, qui sont bien plus durables que ses noms de classes générés.

Avant d'écrire des sélecteurs, ouvrez une page de recherche dans votre navigateur, faites un clic droit sur une fiche produit et choisissez Inspecter. Chaque fiche se trouve à l'intérieur de div[data-test="product-grid"], le lien du titre porte data-test="product-title", le prix actuel utilise data-test="current-price", le nombre d'avis utilise data-test="rating-count", et la note elle-même est une barre masquée avec data-ref="rating-mask" dont la largeur CSS encode le score. Le TCIN, l'identifiant de produit interne de Target, est intégré dans l'URL du produit après le marqueur /A-, donc vous le lisez directement depuis le lien.

Étape 1 : Récupérer la page de recherche rendue

Commencez par obtenir la page finalisée. Importez la classe CrawlingAPI, initialisez-la avec votre token JavaScript, définissez l'URL de recherche et demandez-la avec les options de rendu JS. Vérifier le statut avant d'analyser permet de détecter les échecs de manière explicite plutôt que silencieuse.

from crawlbase import CrawlingAPI
from urllib.parse import quote

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["headers"]["pc_status"] == "200":
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['headers']['pc_status']}")
    return None

if __name__ == "__main__":
    search_term = "womens sweaters"
    url = f"https://www.target.com/s?searchTerm={quote(search_term)}"
    html = crawl(url)
    print(html[:500] if html else "No HTML returned")

Les deux options d'attente sont importantes pour une grille qui se remplit après le chargement. ajax_wait indique à l'API d'attendre que le contenu asynchrone soit terminé, et page_wait maintient la pause 5000 millisecondes après le chargement pour que les fiches rendues tardivement apparaissent avant la capture de la page. La Crawling API rapporte son propre résultat dans response["headers"]["pc_status"], vérifiez donc cela plutôt que le code HTTP brut. Exécutez le script et vous devriez voir du vrai balisage de produit, pas une coquille vide. Cela confirme que le rendu fonctionne avant d'écrire un seul sélecteur.

Étape 2 : Analyser les fiches produits avec BeautifulSoup

HTML rendu en main, chargez-le dans BeautifulSoup, trouvez chaque fiche produit et extrayez chaque champ par son sélecteur. La note nécessite une petite aide : Target dessine la barre d'étoiles comme un masque rempli, et le score se trouve dans le width CSS de la barre sous forme de pourcentage, donc vous convertissez ce pourcentage en une valeur sur 5.

from bs4 import BeautifulSoup

BASE = "https://www.target.com"
GRID = 'div[data-test="product-grid"] section[class^="styles__StyledRowWrapper"] div[class^="styles__StyledCardWrapper"]'

def extract_rating(element):
    style = element.get("style") if element else None
    if not style:
        return None
    for prop in style.split(";"):
        prop = prop.strip()
        if prop.startswith("width:"):
            value = prop[len("width:"):].strip()
            if value.endswith("%"):
                percentage = float(value[:-1])
                return round((percentage / 100) * 5, 2)
    return None

def extract_tcin(href):
    if href and "/A-" in href:
        return href.split("/A-")[1].split("?")[0].split("#")[0]
    return None

def scrape_target_listing(html):
    soup = BeautifulSoup(html, "html.parser")
    products = soup.select(GRID)
    results = []
    for product in products:
        try:
            title_el = product.select_one('a[data-test="product-title"]')
            rating_el = product.select_one('div[data-ref="rating-mask"]')
            reviews_el = product.select_one('span[data-test="rating-count"]')
            price_el = product.select_one('span[data-test="current-price"]')
            sold_out_el = product.select_one('[data-test="soldOut"]')

            href = title_el["href"] if title_el else None
            availability = "Out of stock" if sold_out_el else "In stock"

            results.append({
                "title": title_el.get_text(strip=True) if title_el else None,
                "price": price_el.get_text(strip=True) if price_el else None,
                "tcin": extract_tcin(href),
                "rating": extract_rating(rating_el),
                "review_count": reviews_el.get_text(strip=True) if reviews_el else None,
                "availability": availability,
                "product_url": BASE + href if href else None,
            })
        except Exception as e:
            print(f"Skipped a card: {e}")
    return results

Le sélecteur de grille de produits enchaîne trois éléments directement issus du script original : le conteneur data-test="product-grid", l'enveloppe de ligne et l'enveloppe de fiche. À l'intérieur de chaque fiche, le titre et le prix proviennent de leurs sélecteurs data-test, le nombre d'avis de rating-count et la note de la barre masquée via extract_rating. L'aide extract_tcin lit l'identifiant de produit de Target depuis l'URL après /A-, et la disponibilité est déduite de la présence ou non d'un marqueur de rupture de stock. Chaque garde if el else None rend l'extraction robuste quand un champ est absent, ce qui est courant puisque chaque fiche n'affiche pas forcément une note ou un nombre d'avis.

Étape 3 : Gérer la pagination sur les pages de résultats

Une page de résultats est une démonstration ; un vrai job parcourt l'ensemble des résultats. Target pagine sa recherche avec le paramètre Nao dans l'URL, qui définit l'offset de départ pour chaque page. Les résultats arrivent par lots de 24, donc Nao=1 est la première page, Nao=25 la deuxième, et ainsi de suite. Vous avancez l'offset, récupérez chaque page et arrêtez-vous quand il n'y a plus de bouton de page suivante activé.

PER_PAGE = 24

def has_next_page(html):
    soup = BeautifulSoup(html, "html.parser")
    return bool(soup.select_one('button[data-test="next"]:not([disabled])'))

def scrape_all_pages(base_url, max_pages=5):
    all_products = []
    for page in range(max_pages):
        nao = page * PER_PAGE + 1
        url = f"{base_url}&Nao={nao}"
        html = crawl(url)
        if not html:
            break
        found = scrape_target_listing(html)
        if not found:
            break
        all_products.extend(found)
        print(f"Page {page + 1}: {len(found)} products")
        if not has_next_page(html):
            break
    return all_products

L'offset Nao est calculé à partir de l'index de page, donc la page 0 demande Nao=1, la page 1 demande Nao=25, et la boucle continue jusqu'à ce que has_next_page ne trouve plus de button[data-test="next"] activé. Le plafond max_pages et l'interruption sur résultats vides vous arrêtent tous les deux tôt, de sorte qu'une recherche avec deux pages de résultats ne tourne jamais à travers cinq requêtes. Plafonner les pages maintient également vos crédits du niveau gratuit sous contrôle pendant que vous testez encore.

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

Câblez maintenant la récupération, l'analyse et la pagination dans un script exécutable, puis écrivez les enregistrements en JSON et CSV afin de pouvoir les charger dans un notebook ou une feuille de calcul.

import csv
import json
from urllib.parse import quote
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})
BASE = "https://www.target.com"
GRID = 'div[data-test="product-grid"] section[class^="styles__StyledRowWrapper"] div[class^="styles__StyledCardWrapper"]'
PER_PAGE = 24
FIELDS = ["title", "price", "tcin", "rating", "review_count", "availability", "product_url"]

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

def extract_rating(element):
    style = element.get("style") if element else None
    if not style:
        return None
    for prop in style.split(";"):
        prop = prop.strip()
        if prop.startswith("width:"):
            value = prop[len("width:"):].strip()
            if value.endswith("%"):
                percentage = float(value[:-1])
                return round((percentage / 100) * 5, 2)
    return None

def extract_tcin(href):
    if href and "/A-" in href:
        return href.split("/A-")[1].split("?")[0].split("#")[0]
    return None

def scrape_target_listing(html):
    soup = BeautifulSoup(html, "html.parser")
    products = soup.select(GRID)
    results = []
    for product in products:
        try:
            title_el = product.select_one('a[data-test="product-title"]')
            rating_el = product.select_one('div[data-ref="rating-mask"]')
            reviews_el = product.select_one('span[data-test="rating-count"]')
            price_el = product.select_one('span[data-test="current-price"]')
            sold_out_el = product.select_one('[data-test="soldOut"]')

            href = title_el["href"] if title_el else None
            availability = "Out of stock" if sold_out_el else "In stock"

            results.append({
                "title": title_el.get_text(strip=True) if title_el else None,
                "price": price_el.get_text(strip=True) if price_el else None,
                "tcin": extract_tcin(href),
                "rating": extract_rating(rating_el),
                "review_count": reviews_el.get_text(strip=True) if reviews_el else None,
                "availability": availability,
                "product_url": BASE + href if href else None,
            })
        except Exception as e:
            print(f"Skipped a card: {e}")
    return results

def has_next_page(html):
    soup = BeautifulSoup(html, "html.parser")
    return bool(soup.select_one('button[data-test="next"]:not([disabled])'))

def scrape_all_pages(base_url, max_pages=5):
    all_products = []
    for page in range(max_pages):
        url = f"{base_url}&Nao={page * PER_PAGE + 1}"
        html = crawl(url)
        if not html:
            break
        found = scrape_target_listing(html)
        if not found:
            break
        all_products.extend(found)
        print(f"Page {page + 1}: {len(found)} products")
        if not has_next_page(html):
            break
    return all_products

def export(rows, name="target_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():
    search_term = "womens sweaters"
    base_url = f"https://www.target.com/s?searchTerm={quote(search_term)}"
    rows = scrape_all_pages(base_url, max_pages=3)
    export(rows)

if __name__ == "__main__":
    main()

Exécutez le script complet avec python target_scraper.py. Il parcourt jusqu'à trois pages de la recherche, analyse une ligne par produit et écrit target_products.json et target_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 scraper une catégorie différente, changez search_term vers n'importe quelle requête supportée par Target, ou pointez base_url vers une page de catégorie plutôt qu'une recherche.

À quoi ressemble le résultat

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

[
  {
    "title": "Women's Fine Gauge Crewneck Sweater - A New Day",
    "price": "$20.00",
    "tcin": "88228365",
    "rating": 3.9,
    "review_count": "587",
    "availability": "In stock",
    "product_url": "https://www.target.com/p/women-s-fine-gauge-crewneck-sweater-a-new-day/-/A-88228365"
  },
  {
    "title": "Women's Crew Neck Cashmere-Like Pullover Sweater - Universal Thread",
    "price": "$20.00 - $25.00",
    "tcin": "88062926",
    "rating": 4.2,
    "review_count": "746",
    "availability": "In stock",
    "product_url": "https://www.target.com/p/women-s-crew-neck-cashmere-like-pullover-sweater-universal-thread/-/A-88062926"
  }
]

Notez que rating et review_count reviennent en null pour les produits sans avis encore, ce qui est attendu : la barre de note masquée n'est simplement pas rendue sur leurs fiches. Les prix arrivent sous forme de chaînes affichées, incluant des plages comme "$20.00 - $25.00", donc normalisez-les en nombres en aval si vous prévoyez de les comparer ou de les représenter graphiquement. C'est exactement l'ensemble de champs que vous voulez pour un flux de travail d'intelligence tarifaire.

Passer à l'échelle sur plusieurs requêtes et rester non bloqué

Une recherche est une démonstration ; un vrai job de recherche s'étend sur de nombreuses requêtes ou catégories. Conservez une correspondance de termes de recherche à scraper, parcourez-la et espacez les requêtes. Le même ensemble de champs s'applique à une page de détail de produit individuelle, où le titre, le prix, le TCIN, la note et un badge de disponibilité explicite se trouvent tous sur une seule URL. Même avec le rendu géré, Target surveille le trafic aux allures de scraper, donc quelques habitudes maintiennent une exécution saine et s'appliquent à n'importe quelle cible commerciale difficile.

• Espacez vos requêtes. Répartissez les requêtes avec un délai entre les pages et les requêtes plutôt que de tout crawler à pleine vitesse. Planifiez les jobs plus lourds pendant les heures creuses pour alléger la charge sur les serveurs de Target.
• Misez sur la rotation. Un pool d'adresses IP résidentielles répartit les requêtes sur de nombreuses adresses d'utilisateurs réels de sorte qu'aucune ne déclenche une limite de débit. La Crawling API gère cela pour vous ; si vous montez votre propre pile, c'est la partie à soigner.
• Ne conservez que ce dont vous avez besoin. Stockez les champs produits que votre projet utilise et éliminez le reste. Vérifiez périodiquement vos sélecteurs pour que le scraper suive les modifications du balisage.

Pour le guide plus large sur l'évitement des blocages, voir comment scraper des sites web sans être bloqué, et pour plus d'informations sur l'importance du rendu ici, comment crawler des sites web JavaScript. Le même modèle s'applique aux autres grands détaillants, comme dans les guides sur le scraping de données produits Best Buy et de Walmart avec Python.

Est-il légal de scraper Target ?

La légalité du scraping de Target dépend des conditions d'utilisation de Target, de votre juridiction et de ce que vous faites des données. Les conditions de Target restreignent l'accès automatisé, de sorte que le scraping peut aller à l'encontre de ces conditions quelle que soit la précaution de vos outils. Aucun code présenté ici ne change cela ; il ne fait que rendre la partie technique fonctionnelle. Lisez les conditions d'utilisation de Target et son fichier robots.txt, et traitez les deux comme la frontière de ce que vous collectez. Pour un usage commercial ou concurrentiel, le tableau juridique se complexifie, et consulter un expert juridique pour votre cas spécifique est la démarche sensée.

Quelques lignes à respecter. Collectez uniquement les données publiques : les titres, les prix, les TCINs, les notes et les liens d'annonces que tout le monde peut voir sur une page de recherche ou de produit Target sans compte. Maintenez un volume de requêtes suffisamment faible pour ne pas solliciter les serveurs de Target, et évitez les données personnelles, notamment tout ce qui est lié à des acheteurs, des évaluateurs ou des associés de magasin identifiables au-delà de ce qui est publiquement listé. Ne redistribuez pas les médias protégés par des droits d'auteur tels que la photographie de produit de Target, et si vous envisagez 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 publiques de recherche et de produits parce que c'est la ligne qui rend le travail défendable. Il ne couvre rien derrière une connexion, les données de compte ou de commande, les détails de paiement, ni aucune tentative de contournement d'une authentification ou d'un CAPTCHA auquel vous n'êtes pas en droit de répondre. Target gère un programme d'affiliation et de partenariat et propose des flux de données officiels pour les partenaires agréés, et c'est le bon canal lorsque vous avez besoin de grands volumes, d'une structure garantie ou de droits commerciaux. Si votre projet nécessite plus que des données de catalogue publiques, un accord officiel est la bonne approche, pas un scraper plus astucieux.

Foire aux questions

Pourquoi une requête simple ne retourne-t-elle aucun produit de Target ?

Target rend sa grille de recherche côté client : le premier payload HTML est une coquille, et les fiches produits n'apparaissent qu'après l'exécution du JavaScript de la page. Un requests.get() brut analyse cette coquille et ne trouve rien, c'est pourquoi la tentative DIY de l'ancien guide retournait une liste vide. Rendre la page via la Crawling API derrière une adresse IP de confiance résout à la fois le problème du JavaScript et du blocage, c'est pourquoi le scraper présenté ici achemine sa requête par ce biais.

Qu'est-ce qu'un TCIN et comment l'obtenir ?

Le TCIN est l'identifiant de produit interne de Target, l'équivalent d'un SKU sur le site. Il apparaît dans chaque URL de produit après le marqueur /A-, par exemple /A-88228365 signifie TCIN 88228365. L'aide extract_tcin le lit directement depuis le lien produit, donc vous obtenez une clé stable pour chaque article sans requête supplémentaire, ce qui est pratique pour dédupliquer ou joindre des enregistrements dans le temps.

Comment scraper une catégorie Target spécifique plutôt qu'une recherche ?

Pointez le scraper vers l'URL de catégorie plutôt que vers une URL de recherche. La grille de produits, les sélecteurs data-test et le paramètre de pagination Nao se comportent de la même façon sur les pages de catégories, donc le même analyseur et la même boucle de pagination s'appliquent. Remplacez simplement base_url dans main par la catégorie que vous voulez et gardez le reste du script tel quel.

Comment lire la disponibilité des produits ?

Sur les fiches de recherche et de catégorie, un article en rupture de stock affiche un marqueur de rupture, que le scraper détecte avec une vérification [data-test="soldOut"] et enregistre comme "Out of stock", revenant à "In stock" par défaut. Pour une lecture précise de disponibilité par magasin, scrapez la page de produit individuelle, où Target affiche un badge de disponibilité clair et des options d'expédition ou de retrait liées à un emplacement.

Pourquoi certaines notes sont-elles null dans le résultat ?

Une note ou un nombre d'avis null signifie que ce produit n'a pas encore d'avis, donc Target ne rend pas la barre de note masquée sur sa fiche. L'aide extract_rating lit le score depuis la largeur CSS de la barre, et quand la barre est absente, elle retourne None. C'est un comportement attendu, pas un échec de sélecteur ; les nouvelles annonces ou celles à faible trafic n'ont simplement rien à afficher.

Comment éviter d'être bloqué en scrapant Target ?

Maintenez un faible taux de requêtes par adresse IP, ajoutez un délai entre les pages et les requêtes, et acheminez via des adresses IP résidentielles rotatives de sorte qu'aucune adresse unique ne déclenche une limite de débit. La Crawling API gère la rotation, un pool d'adresses IP de confiance et la gestion des CAPTCHA pour vous ; si vous construisez votre propre pile, c'est la partie sur laquelle investir. Surveillez les codes pc_status que l'API retourne et levez le pied lorsque vous commencez à voir des échecs.

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.