Comment extraire les données sur les produits Amazon : guide complet des meilleures pratiques et des outils disponibles

Le scraping d'Amazon est une tâche complexe qui nécessite un ensemble d'outils et une approche stratégique. Voici un guide étape par étape pour préparer votre système au scraping des données sur les produits Amazon.

Étape 1 : Installez Python

Python est le langage de programmation principal pour le web scraping. Assurez-vous d'avoir installé Python 3.8 ou une version supérieure. Si ce n'est pas le cas, rendez-vous sur python.org pour télécharger et installer la dernière version de Python.

Étape 2 : Créer un dossier de projet

Créez un dossier dédié pour stocker vos fichiers de code destinés au web scraping d'Amazon. L'organisation de vos fichiers facilitera votre flux de travail.

Étape 3 : Configurer un environnement virtuel

La création d'un environnement virtuel est considérée comme une bonne pratique en développement Python. Elle vous permet de gérer les dépendances spécifiques au projet, garantissant ainsi qu'il n'y a pas de conflit avec d'autres projets.

Pour les utilisateurs de macOS et Linux, exécutez les commandes suivantes pour créer et activer un environnement virtuel :

$ python3 -m venv .env
$ source .env/bin/activate

Pour les utilisateurs de Windows, les commandes sont légèrement différentes :

c:\amazon>python -m venv .env
c:\amazon>.env\scripts\activate

Étape 4 : Installer les paquets Python requis

Les deux étapes principales du web scraping consistent à récupérer le code HTML et à l'analyser pour extraire les données pertinentes.

• Bibliothèque Requests : une bibliothèque Python tierce très populaire utilisée pour effectuer des requêtes HTTP. Elle offre une interface simple pour communiquer avec les serveurs web, mais renvoie le code HTML sous forme de chaîne de caractères, ce qui n'est pas facile à interroger.
• Beautiful Soup : cette bibliothèque Python facilite le web scraping en permettant d'extraire des données de fichiers HTML et XML, et de rechercher des éléments spécifiques tels que des balises, des attributs ou du texte.

Installez ces bibliothèques à l'aide de la commande suivante :

$ python3 -m pip install requests beautifulsoup4

Remarque pour les utilisateurs Windows : remplacez python3 par python.

Étape 5 : Configuration de base du scraping

Créez un fichier nommé amazon.py et insérez le code permettant d'envoyer une requête vers une page produit Amazon spécifique. Par exemple :

import requests
url = 'https://www.amazon.com/Robux-Roblox-Online-Game-Code/dp/B07RZ74VLR/'
response = requests.get(url)
print(response.text)

L'exécution de ce code peut entraîner le blocage de la requête par Amazon et renvoyer une erreur 503, car le site détecte que la requête n'a pas été effectuée via un navigateur.

Étape 6 : Contourner les mécanismes de blocage

Amazon bloque souvent les tentatives de scraping, renvoyant des codes d'erreur commençant par 400 ou 500. Pour contourner cela, vous pouvez imiter un navigateur en envoyant des en-têtes personnalisés, notamment l'agent utilisateur et parfois la langue acceptée.

Pour trouver l'agent utilisateur de votre navigateur, appuyez sur F12, ouvrez l'onglet Réseau, rechargez la page et examinez les en-têtes de requête.

Voici un exemple de dictionnaire pour les en-têtes personnalisés :

custom_headers = {
    'user-agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/602.18 (KHTML, like Gecko) Chrome/54.0.3129.163 Safari/602.6 Edge/9.50428',
    'accept-language': 'en-US,en;q=0.9',
}

Envoyez ce dictionnaire à l'aide de la méthode get comme suit :

response = requests.get(url, headers=custom_headers)

Cela devrait vous permettre d'obtenir le code HTML souhaité avec les détails du produit. Envoyer autant d'en-têtes que possible réduit au minimum le besoin de rendu JavaScript. Si un rendu est nécessaire, des outils tels que Playwright ou Selenium peuvent être utilisés.

Lorsqu'il s'agit d'extraire des informations sur les produits d'Amazon, on rencontre généralement deux types de pages principales qui contiennent les données essentielles : la page de catégorie et la page de détails du produit. Chacune de ces pages joue un rôle crucial dans l'extraction des informations requises, et il est essentiel de savoir comment naviguer sur les deux.

La page de catégorie

Prenons, par exemple, l'URL https://www.amazon.com/s?i=specialty-aps&bbn=16225007011&rh=n%3A16225007011%2Cn%3A193870011

Sur la page de catégorie, vous trouverez les informations de base :

• Titre du produit : le nom du produit.
• Image du produit : représentation visuelle de l'article.
• Évaluation du produit : les notes et les commentaires des utilisateurs.
• Prix du produit : le prix de vente actuel.
• Page des URL des produits : liens vers les pages individuelles des produits.

Si vous souhaitez obtenir des informations plus détaillées, telles que les descriptions ou les spécifications du produit, vous devrez vous rendre sur les pages de détails de chaque produit.

En cliquant sur l'URL d'un produit (par exemple https://www.amazon.com/Robux-Roblox-Online-Game-Code/dp/B07RZ74VLR/), vous accédez à une mine d'informations détaillées. Pour voir comment ces informations sont structurées, vous pouvez utiliser un navigateur moderne comme Chrome.

Inspecter les éléments HTML

Cliquez avec le bouton droit de la souris sur le titre du produit et sélectionnez « Inspecter ». Le balisage HTML du titre du produit apparaîtra en surbrillance. Il est notamment contenu dans une balise span, et son attribut id est défini comme « productTitle ».

La même méthode peut être utilisée pour trouver le balisage d'autres éléments essentiels :

• Prix : cliquez avec le bouton droit sur le prix et sélectionnez « Inspecter ». La partie du prix exprimée en dollars est contenue dans une balise span de classe « a-price-whole », tandis que les centimes sont stockés dans une autre balise span, désignée par la classe « a-price-fraction ».
• Note, image et description : utilisez la même fonctionnalité d'inspection pour localiser ces composants essentiels, chacun étant encapsulé dans des balises et des classes spécifiques.

Le processus d'extraction des données produit sur Amazon peut être décomposé en étapes spécifiques, chacune ciblant un aspect particulier des informations produit. En utilisant des bibliothèques Python telles que requests et BeautifulSoup, nous pouvons accéder aux détails souhaités, les localiser et les extraire. Voici un guide détaillé sur la marche à suivre :

1. Lancer la requête

Commencez par envoyer une requête GET avec des en-têtes personnalisés à l'URL de la page du produit :

response = requests.get(url, headers=custom_headers)
soup = BeautifulSoup(response.text, 'lxml')

Nous utilisons BeautifulSoup pour analyser le contenu HTML, ce qui facilite l'extraction d'informations spécifiques à l'aide de sélecteurs CSS. 2. Localiser et extraire le nom du produit

Identifiez le titre du produit à l'aide de l'identifiant unique productTitle situé dans un élément span :

title_element = soup.select_one('#productTitle')
title = title_element.text.strip()

3. Localiser et extraire la note du produit

Pour extraire la note du produit, vous devez accéder à l'attribut title du sélecteur #acrPopover :

rating_element = soup.select_one('#acrPopover')
rating_text = rating_element.attrs.get('title')
rating = rating_text.replace('out of 5 stars', '')

4. Localiser et extraire le prix du produit

Extrayez le prix du produit à l'aide du sélecteur #price_inside_buybox :

price_element = soup.select_one('#price_inside_buybox')
print(price_element.text)

5. Localiser et extraire l'image du produit

Récupérez l'URL de l'image par défaut à l'aide du sélecteur #landingImage :

image_element = soup.select_one('#landingImage')
image = image_element.attrs.get('src')

6. Localiser et extraire la description du produit

Récupérez la description du produit à l'aide du sélecteur #productDescription :

description_element = soup.select_one('#productDescription')
print(description_element.text)

7. Localiser et extraire les avis sur le produit

L'extraction des avis est plus complexe, car un produit peut avoir plusieurs avis. Un seul avis peut contenir diverses informations telles que l'auteur, la note, le titre, le contenu, la date et le statut de vérification.

Collecte des avis

Utilisez le sélecteur div.review pour identifier et collecter tous les avis :

review_elements = soup.select("div.review")
scraped_reviews = []

for review in review_elements:
   # Extracting specific review details...

Extraction des détails des avis

Chaque avis peut être décomposé en détails spécifiques :

• Auteur : span.a-profile-name
• Note : i.review-rating
• Titre : a.review-title > span:not([class])
• Contenu : span.review-text
• Date : span.review-date
• Statut vérifié : span.a-size-mini

Chacun de ces éléments peut être sélectionné à l'aide de ses sélecteurs CSS respectifs, puis extrait à l'aide de méthodes similaires à celles décrites dans les étapes précédentes.

Assemblage des données d'avis

Créez un objet contenant les détails de l'avis extrait et ajoutez-le au tableau des avis :

r = {
       "author": r_author,
       "rating": r_rating,
       "title": r_title,
       "content": r_content,
       "date": r_date,
       "verified": r_verified
}

scraped_reviews.append(r)

Le scraping des données produit sur Amazon est une tâche complexe qui nécessite une approche précise pour cibler des éléments spécifiques au sein de la structure de la page web. En tirant parti des capacités des outils modernes de scraping web, il est possible d'extraire avec succès des informations détaillées sur les produits.

Gestion des fiches produits

Pour extraire des informations détaillées sur les produits, vous commencerez souvent par une page de liste de produits ou une page de catégorie, où les produits sont affichés sous forme de grille ou de liste.

Identification des liens vers les produits

Sur une page de catégorie, vous remarquerez peut-être que chaque produit est contenu dans une balise div dotée d'un attribut spécifique [data-asin]. Les liens vers les produits individuels se trouvent souvent à l'intérieur d'une balise h2 au sein de cette div.

Le sélecteur CSS correspondant à ces liens serait :

[data-asin] h2 a

Analyse et suivi des liens

Vous pouvez utiliser BeautifulSoup pour sélectionner ces liens et extraire les attributs href. Notez que ces liens peuvent être relatifs ; vous devrez donc utiliser la méthode urljoin pour les convertir en URL absolues.

from urllib.parse import urljoin

def parse_listing(listing_url):
    # Your code to fetch and parse the page goes here...
    link_elements = soup_search.select("[data-asin] h2 a")
    page_data = []
    for link in link_elements:
        full_url = urljoin(listing_url, link.attrs.get("href"))
        product_info = get_product_info(full_url)
        page_data.append(product_info)

Gestion de la pagination

De nombreuses pages de listes sont paginées. Vous pouvez passer à la page suivante en localisant le lien contenant le texte « Next ».

next_page_el = soup.select_one('a:contains("Next")')
if next_page_el:
    next_page_url = next_page_el.attrs.get('href')
    next_page_url = urljoin(listing_url, next_page_url)

Vous pouvez ensuite utiliser cette URL pour analyser la page suivante, en continuant la boucle jusqu'à ce qu'il n'y ait plus de liens « Suivant ».

8. Exporter les données de produits extraites vers un fichier JSON

Les données de produits extraites sont collectées sous forme de dictionnaires au sein d'une liste. Ce format permet une conversion aisée en DataFrame Pandas, facilitant ainsi la manipulation et l'exportation des données.

Voici comment créer un DataFrame à partir des données extraites et l'enregistrer sous forme de fichier JSON :

import pandas as pd

df = pd.DataFrame(page_data)
df.to_json('baby.json', orient='records')

Cela créera un fichier JSON contenant toutes les informations sur les produits extraites.

Ce guide fournit une procédure étape par étape pour extraire des listes de produits, y compris la navigation à travers la pagination et l'exportation des résultats vers un fichier JSON. Il est essentiel d'adapter ces méthodes à la structure et aux exigences spécifiques du site que vous explorez.

import requests
from bs4 import BeautifulSoup
from urllib.parse import urljoin
import pandas as pd

custom_headers = {
    "accept-language": "en-US,en;q=0.9",
    "user-agent": "{user-agent}",
}

def get_response(url):
    """Make a GET request and return the response if successful."""
    with requests.Session() as session:
        session.headers.update(custom_headers)
        response = session.get(url)
        if response.status_code != 200:
            print(f"Error in getting webpage {url}")
            return None
        return response

def get_product_info(url):
    """Scrape product details from the given URL."""
    response = get_response(url)
    if response is None:
        return None

    # ... rest of the code ...

    return {
        "title": title,
        "price": price,
        "rating": rating,
        "image": image,
        "description": description,
        "url": url,
        "reviews": scraped_reviews,
    }

def parse_listing(listing_url):
    """Parse multiple product listings from the given URL."""
    page_data = []
    while listing_url:
        response = get_response(listing_url)
        if response is None:
            break

        soup_search = BeautifulSoup(response.text, "lxml")
        link_elements = soup_search.select("[data-asin] h2 a")

        for link in link_elements:
            full_url = urljoin(listing_url, link.attrs.get("href"))
            print(f"Scraping product from {full_url[:100]}", flush=True)
            product_info = get_product_info(full_url)
            if product_info:
                page_data.append(product_info)

        next_page_el = soup_search.select_one('a:contains("Next")')
        listing_url = urljoin(listing_url, next_page_el.attrs.get('href')) if next_page_el else None
        print(f'Scraping next page: {listing_url}', flush=True) if listing_url else None

    return page_data

def main():
    search_url = "{category url}"
    data = parse_listing(search_url)
    df = pd.DataFrame(data)
    df.to_json("amz.json", orient='records')

if __name__ == '__main__':
    main()

L'extraction de données sur Amazon n'est pas aussi simple qu'il n'y paraît. Avec la complexité croissante de la sécurité Web, l'extraction d'informations précieuses de cette colossale plateforme de commerce électronique présente une multitude de défis. De la limitation de débit aux algorithmes complexes de détection des bots, Amazon veille à rester une cible difficile pour l'extraction de données.

Défis liés au scraping de données sur Amazon

• Limitation du débit : Amazon applique des mesures de limitation du débit pour contrôler le nombre de requêtes provenant d'une même adresse IP. Le dépassement de ces limites peut entraîner le blocage de votre adresse IP.
• Algorithmes de détection des bots : des algorithmes sophistiqués sont en place pour inspecter vos en-têtes HTTP à la recherche de schémas inhabituels, vérifiant si les requêtes proviennent de bots automatisés.
• Mises en page en constante évolution : avec des mises en page variées et des structures HTML fluctuantes, suivre le rythme de cette interface en constante évolution nécessite de la vigilance et une grande capacité d'adaptation.

Stratégies pour surmonter ces défis

Pour surmonter ces obstacles, une approche stratégique est nécessaire. Voici quelques bonnes pratiques essentielles à suivre lors du scraping d'Amazon :

• Utilisez un User-Agent réaliste : il est crucial de donner à votre User-Agent une apparence authentique pour contourner la détection. Voici les User-Agents les plus courants qui imitent l'activité d'un navigateur réel.
• Définissez votre empreinte de manière cohérente : de nombreuses plateformes, dont Amazon, utilisent le protocole TCP (Transmission Control Protocol) et l'empreinte IP pour identifier les bots. Il est essentiel de veiller à ce que vos paramètres d'empreinte restent uniformes pour passer inaperçu.
• Modifiez judicieusement le modèle de crawling : pour créer un modèle de crawling efficace, il faut simuler la façon dont un utilisateur réel naviguerait sur une page web. Cela implique d'intégrer des clics, des défilements et des mouvements de souris qui imitent le comportement humain. Concevoir un modèle qui reflète l'interaction humaine peut réduire le risque de détection.
• Envisagez la gestion des proxys : bien que l'article initial n'en fasse pas mention, l'utilisation de proxys peut ajouter une couche supplémentaire d'anonymat. En répartissant les requêtes sur différentes adresses IP, vous pouvez encore mieux échapper à la détection.
• Restez informé des politiques et technologies d'Amazon : Amazon met fréquemment à jour ses mesures de sécurité et son interface utilisateur. En réexaminant régulièrement vos méthodes de scraping et en les adaptant à ces changements, vous vous assurerez que vos techniques restent efficaces.

Le scraping des données produit d'Amazon est une tâche complexe, qui exige une compréhension approfondie des meilleures pratiques et une adaptation constante aux stratégies en constante évolution d'Amazon. En adoptant ces techniques et en restant vigilant face à un environnement en constante évolution, vous pouvez accéder aux données précieuses nécessaires à votre analyse ou à votre projet. N'oubliez pas qu'il ne s'agit là que d'un aperçu de ce qui est nécessaire pour scraper Amazon, et que des recherches et des outils supplémentaires peuvent être nécessaires pour atteindre vos objectifs spécifiques.

Si les méthodes de scraping manuel décrites ci-dessus peuvent certainement fournir des informations précieuses, elles nécessitent une surveillance continue, une adaptation constante et un savoir-faire technique. Pour ceux qui recherchent une approche plus rationalisée et conviviale, l'API Amazon Scraper offre une solution efficace et dédiée.

Pourquoi choisir l'API Amazon Scraper ?

L'API Amazon Scraper est un outil spécialement conçu pour gérer les complexités du scraping d'Amazon. Voici ce que vous pouvez réaliser avec cette API spécialisée :

• Options de scraping polyvalentes : vous pouvez extraire et analyser différents types de pages Amazon. Que vous souhaitiez extraire des données des pages Recherche, Produits, Offres, Questions et réponses, Avis, Meilleures ventes ou Vendeurs, cette API répond à vos besoins.
• Portée mondiale : ciblez et récupérez des données produit localisées dans pas moins de 195 pays à travers le monde. Cette vaste couverture permet une analyse approfondie et des informations précieuses sur différents marchés et segments démographiques.
• Récupération efficace des données : l'API renvoie des résultats analysés précis dans un format JSON clair. Aucune bibliothèque supplémentaire ni configuration complexe n'est nécessaire ; vous recevez les données prêtes à l'emploi.
• Fonctionnalités avancées pour les besoins complexes : profitez de fonctionnalités conçues pour l'efficacité, telles que les capacités de scraping en masse et les tâches automatisées. Ces fonctionnalités rationalisent le processus de scraping, vous permettant de collecter de vastes quantités de données avec un minimum d'intervention manuelle.
• Conformité et facilité d'utilisation : contrairement au scraping manuel, l'utilisation d'une API dédiée comme l'API Amazon Scraper garantit souvent une meilleure conformité aux réglementations légales et aux conditions d'utilisation d'Amazon, ce qui en fait une option plus sûre pour l'extraction de données.

L'extraction des données sur les produits Amazon peut s'effectuer selon deux méthodes distinctes, chacune répondant à des compétences et des exigences différentes. Explorons ces deux voies :

Créer votre propre scraper avec Requests et Beautiful Soup

Si vous avez un penchant pour le codage et possédez les compétences nécessaires, la création d'un scraper personnalisé à l'aide de bibliothèques Python populaires telles que Requests et Beautiful Soup peut s'avérer une aventure passionnante. Voici un bref aperçu du processus :

Envoi d'en-têtes personnalisés : en personnalisant les en-têtes HTTP, vous pouvez imiter les requêtes d'un navigateur authentique et échapper à la détection.

Rotation des User-Agents : des changements fréquents de User-Agent peuvent dissimuler davantage vos activités de scraping, les faisant ressembler davantage à des interactions d'utilisateurs ordinaires.

Rotation des proxys : l'utilisation d'un pool de proxys vous permet de répartir les requêtes sur plusieurs adresses IP, ce qui aide à contourner les interdictions ou les limitations de débit.

Bien que cette méthode offre flexibilité et contrôle, elle exige des efforts considérables, du temps et une surveillance continue. La mise en page en constante évolution d'Amazon et ses mesures anti-bot strictes en font une voie difficile, nécessitant des mises à jour et des ajustements constants.

Solution simplifiée avec l'API Amazon Scraper

Pour ceux qui recherchent une alternative plus conviviale et plus rapide, l'API Amazon Scraper offre une solution sur mesure :

• Fonctionnalités prêtes à l'emploi : l'API est spécialement conçue pour Amazon et offre des fonctionnalités permettant de scraper facilement différents types de pages.
• Couverture complète : capable de cibler des données dans de nombreux endroits à travers le monde, l'API est polyvalente et d'une grande portée.
• Facilité d'utilisation : Oubliez les complexités du codage manuel ; l'API renvoie des données prêtes à l'emploi dans un format JSON pratique.

L'API Amazon Scraper constitue un point d'entrée accessible au scraping des données Amazon, en particulier pour les particuliers ou les organisations qui ne disposent pas des ressources techniques ou du temps nécessaires pour développer et maintenir un scraper personnalisé.

Que vous choisissiez d'écrire votre propre code avec Requests et Beautiful Soup ou d'opter pour l'API Amazon Scraper spécialisée, votre décision doit correspondre à vos compétences, vos ressources, vos objectifs et votre respect des directives légales et éthiques.

• Pour les utilisateurs avertis qui aiment relever des défis, le codage d'un scraper personnalisé offre contrôle et personnalisation.
• Pour ceux qui privilégient l'efficacité, l'accessibilité et la conformité, l'API Amazon Scraper fournit une solution prête à l'emploi qui simplifie le processus.

Les deux voies peuvent mener à des informations précieuses, mais votre choix aura un impact significatif sur le parcours. Comprendre les atouts et les limites de chaque approche vous aidera à prendre une décision éclairée qui correspond le mieux à vos besoins.