Amazon fournit une vaste collection de données sur les produits (données Amazon) qui constituent une ressource précieuse pour les entreprises, les chercheurs et les spécialistes du marketing. Amazon demande que ses mesures anti-grattage soient soigneusement étudiées. Ce guide explique comment utiliser les proxys Massive pour des requêtes HTTP efficaces et collecter des données à partir des pages de produits Amazon tout en évitant les blocages d'adresses IP.

Allons y plonger !

Cas d'utilisation courants des données sur les produits Amazon

En ce qui concerne le web scraping Amazon, il existe plusieurs applications utiles :

• Surveillance et optimisation des prix: suivez les prix en temps réel grâce à des requêtes HTTP automatisées pour ajuster les stratégies.
• Étude de produit et de marché: Consultez les détails des produits et les avis sur les produits pour obtenir des informations sur les préférences des consommateurs et des analyses de marché.
• Analyse de la concurrence: Recueillez systématiquement des données sur les prix et les stratégies de produits des concurrents.
• Gestion des stocks : Surveillez les niveaux de stock pour optimiser les chaînes d'approvisionnement.

Pourquoi utiliser des proxies dans le Web Scraping

Les proxys sont essentiels pour le web scraping Amazon car ils :

• Évitez les interdictions d'adresses IP: faites pivoter les adresses IP et combinez-les avec des agents utilisateurs rotatifs pour échapper à la détection.
• Accédez au contenu verrouillé par région: utilisez des proxys pour imiter les emplacements et contourner les restrictions géographiques.
• Limites de débit de contournement: distribuez les requêtes HTTP sur plusieurs adresses IP pour éviter les restrictions.

Comprendre les mesures anti-grattage d'Amazon

Il n'est pas facile de récupérer des données depuis Amazon en raison des diverses mesures de protection mises en place. Voici quelques obstacles courants que vous pourriez rencontrer :

• CAPTCHA : Amazon utilise souvent des CAPTCHA pour faire la distinction entre les utilisateurs humains et les robots. Ces CAPTCHA sont faciles à résoudre pour les humains, mais difficiles à résoudre pour les scripts automatisés. S'ils ne sont pas gérés efficacement, ces défis peuvent bloquer vos tentatives de grattage.
• Limitation de débit : Pour éviter la surcharge des serveurs, Amazon limite le nombre de demandes que vous pouvez effectuer au cours d'une période donnée. Il est important de respecter ces limites pour éviter d'être bloqué.
• Blocage des adresses IP : Si Amazon détecte une activité de scraping excessive à partir d'une adresse IP spécifique, il se peut qu'il la bloque complètement.
• Structure de page dynamique : Amazon met fréquemment à jour la mise en page et les éléments de son site Web, ce qui peut perturber les scripts de scraping existants qui s'appuient sur des éléments cibles statiques. Cela signifie que vous devrez peut-être constamment ajuster votre code pour suivre ces modifications.

Par exemple, j'ai écrit un script Python Playwright pour extraire les données de plusieurs pages de produits sur Amazon. Cependant, mon grattoir s'est finalement bloqué, comme le montre l'image ci-dessous.

Je n'arrivais plus à extraire les données, ce qui était très frustrant et chronophage. Mais ne vous inquiétez pas, nous allons examiner la solution : utiliser des proxies résidentiels massifs pour passer les données sous le radar.

Proxy résidentiel ou proxy pour centres de données : quel est le meilleur pour Amazon Scraping ?

Lorsque vous sélectionnez des proxys pour scraper Amazon, il est important de déterminer quel type convient le mieux : résidentiel ou de centre de données.

Les proxys résidentiels utilisent les adresses IP fournies par les fournisseurs d'accès à Internet (FAI) à de vrais utilisateurs, ce qui les fait apparaître comme de véritables connexions utilisateur et moins susceptibles d'être détectées.

D'autre part, les proxys des centres de données proviennent de centres de données et sont généralement plus rapides et moins chers, mais ils sont également moins susceptibles d'éviter d'être détectés.

Proxys résidentiels massifs offrent un large éventail d'adresses IP, garantissant un anonymat élevé et réduisant le risque de blocage.

Avantages de l'utilisation de proxys massifs pour Amazon Scraping

Les proxys résidentiels massifs offrent plusieurs avantages clés :

• Anonymat : Un grand nombre d'adresses IP réduit le risque de blocage.
• Couverture mondiale : Accédez aux adresses IP de plus de 195 pays.
• Haute performance : Taux de réussite de 99 % et temps de réponse rapides.
• Bande passante flexible : Choisissez parmi différents niveaux de tarification pour répondre à vos besoins.
• Conformité éthique : 100 % d'origine éthique et conforme au RGPD et au CCPA.
• Support fiable : Surveillance de la disponibilité 24h/24 et 7j/7 et garantie de disponibilité de 99,9 %.

Débuter avec Massive

Pour utiliser les proxys résidentiels massifs pour le scraping d'Amazon, créez un compte sur Massif et sélectionnez un forfait adapté à vos besoins en matière de données et à votre budget. Une fois votre compte actif, rendez-vous dans la section Démarrage rapide :

Vous pouvez voir deux options de ciblage : Par défaut et Filtres cibles. Le Filtres cibles proposent des options de filtrage plus spécifiques, que nous explorerons plus tard. Pour l'instant, commençons par Par défaut ciblage.

Sélectionnez le HTTPS protocole et choisissez Proxys rotatifs. Comme Amazon utilise des mesures anti-grattage avancées, la rotation des proxys vous aidera à éviter d'être détecté. Cela générera une commande cURL contenant l'URL, le nom d'utilisateur et le mot de passe du serveur. Nous utiliserons ces informations d'identification ultérieurement lors de l'implémentation du code.

Ensuite, regardons le Filtre cible options. Vous avez la possibilité de choisir parmi plus de 195 pays. Sélectionnez donc le pays, l'état, la ville ou le code postal de votre choix pour un grattage ciblé.

Par exemple, sélectionnons les États-Unis et la ville de Washington pour extraire les produits Amazon de cette région spécifique.

Création d'un Amazon Scraper avec Python et Massive

Examinons le processus de création d'un scraper Python pour extraire toutes les données d'Amazon à l'aide de proxys Massive et de Playwright. La bibliothèque Playwright est très utile pour automatiser les interactions entre les navigateurs, en particulier pour le contenu chargé dynamiquement.

Nous allons extraire les données suivantes de chaque produit Amazon : nom du produit, évaluation, nombre d'avis, prix, coupon (si disponible) et lien vers le produit.

1. Configurez votre environnement Python

Pour commencer, assurez-vous que Python est installé sur votre machine. Ensuite, installez Playwright et les fichiers binaires de navigateur nécessaires :

pip install playwright
playwright install

2. Importer les bibliothèques requises

Dans votre fichier Python, importez les bibliothèques nécessaires à la programmation asynchrone et à l'automatisation des navigateurs :

import asyncio
from playwright.async_api import async_playwright

3. Création de la fonction de grattage

Définissez une fonction asynchrone nommée amazon_shopping_search. Cette fonction prendra une requête de recherche et un domaine facultatif (par défaut, « com ») :

async def amazon_shopping_search(search_query, domain='com'):

4. Préparez l'URL de recherche

Formatez la requête de recherche en remplaçant les espaces par + pour créer une URL valide pour la recherche :

q = search_query.replace(" ", "+")
base_url = f"<https://www.amazon>.{domain}/s?k={q}"

5. Lancez le navigateur avec les paramètres du proxy

Lancez le navigateur avec vos paramètres de proxy et ajoutez les informations d'identification de votre compte Massive.

async with async_playwright() as p:
    browser = await p.chromium.launch(
        headless=True,
        proxy={
            "server": "<https://network.joinmassive.com:65535>",
            "username": "YOUR_MASSIVE_USERNAME",
            "password": "YOUR_MASSIVE_PASSWORD"
        }
    )

Une fois lancée, toutes les demandes effectuées par le navigateur passent par le serveur proxy spécifié, ce qui permet de préserver l'anonymat.

6. Créer une nouvelle page

Créez une nouvelle page dans le navigateur et initialisez une variable pour suivre le numéro de page actuel :

page = await browser.new_page()
page_number = 1

7. Boucle à racler

Implémentez une boucle qui continue jusqu'à ce qu'il n'y ait plus de pages à gratter. Pour chaque itération, créez l'URL de la page en cours et naviguez jusqu'à celle-ci :

8. Extraire les informations sur le produit

Pour chaque produit de la page, extrayez divers détails tels que le nom, le prix, la note, les avis, le coupon et le lien à l'aide de sélecteurs CSS. Si aucun détail n'est disponible, attribuez « N/A ».

Voici comment extraire chaque information :

A. Nom du produit:

while True:
    url = f"{base_url}&page={page_number}"
    print(f"Scraping page {page_number}...")
    await page.goto(url, wait_until="domcontentloaded")

Extrait de code :

name = await product.query_selector("[data-cy=title-recipe]")
name = await name.inner_text() if name else "N/A"

B. Prix du produit :

Extrait de code :

current_price = await product.query_selector(".a-price > .a-offscreen")
current_price = await current_price.inner_text() if current_price else "N/A"

C. Évaluation du produit :

Extrait de code :

rating = await product.query_selector("[data-cy=reviews-ratings-slot]")
rating = await rating.inner_text() if rating else "N/A"

D. Avis sur les produits :

Extrait de code :

reviews = await product.query_selector(
    ".rush-component > div > span > a > span, a.a-link-normal > span.a-size-base"
)
reviews = await reviews.inner_text() if reviews else "N/A"

E. Coupon de produit:

Extrait de code :

coupon = await product.query_selector(".s-coupon-unclipped")
coupon = await coupon.inner_text() if coupon else "N/A"

F. Lien vers le produit :

Extrait de code :

link = await product.query_selector("a.a-link-normal")
if link:
    full_link = await link.get_attribute("href")
    link = (
        f'<https://www.amazon>.{domain}{full_link.split("/ref=")[0]}'
        if full_link
        else "N/A"
    )
else:
    link = "N/A"

9. Vérifiez la page suivante

Vérifiez s'il y a un lien vers la page suivante. S'il n'existe pas, sortez de la boucle :

next_page = await page.query_selector(".s-pagination-next")
if not next_page:
    print("No more pages to scrape.")
    break

10. Fermez le navigateur

Après avoir effacé toutes les pages, fermez le navigateur !

await browser.close()

11. Fonction principale

Enfin, définissez une fonction asynchrone principale qui lance le processus de scraping avec une requête de recherche spécifique. Exécutez cette fonction pour lancer le scraping :

async def main():
    await amazon_shopping_search(search_query="office chair", domain="com")

# Run the main function
asyncio.run(main())

Enregistrer les données au format CSV

L'étape suivante consiste à enregistrer ces données dans un fichier CSV, ce qui permet une analyse et un traitement plus approfondis des données. Utilisez le module csv intégré de Python pour enregistrer les données extraites dans un fichier CSV.

import csv 

# Open the CSV file once before the loop
with open('product_data.csv', mode='w', newline='', encoding='utf-8') as file:
    writer = csv.writer(file)
    # Write the header
    writer.writerow(['Name', 'Current Price', 'Rating',
                     'Reviews', 'Coupon', 'Link'])

    # ... existing code ...

    for product in products:
        # ... existing code ...

        # Write the data if the product is valid and not sponsored
        if name != "N/A" and "Sponsored" not in name:
            writer.writerow(
                [name, current_price, rating, reviews, coupon, link])

    # ... existing code ...

Code complet

Consultez le code complet pour extraire les données des produits Amazon :

import asyncio
from playwright.async_api import async_playwright
import csv

# Function to search for products on Amazon
async def amazon_shopping_search(search_query, domain="com"):
    # Replace spaces in the search query with '+'
    q = search_query.replace(" ", "+")
    # Construct the base URL for the search
    base_url = f"<https://www.amazon>.{domain}/s?k={q}"

    # Launch a headless browser
    async with async_playwright() as p:
        browser = await p.chromium.launch(
            headless=True,
            # Using Massive proxy to avoid IP blocking
            proxy={
                "server": "<https://network.joinmassive.com:65535>",
                "username": "YOUR_MASSIVE_USERNAME",
                "password": "YOUR_MASSIVE_PASSWORD",
            },
        )
        # Create a new page in the browser
        page = await browser.new_page()
        # Initialize the page number
        page_number = 1

        # Open the CSV file for writing
        with open("product_data.csv", mode="w", newline="", encoding="utf-8") as file:
            writer = csv.writer(file)
            # Write the header row
            writer.writerow(
                ["Name", "Current Price", "Rating", "Reviews", "Coupon", "Link"]
            )

            # Start scraping the pages
            while True:
                # Construct the URL for the current page
                url = f"{base_url}&page={page_number}"
                print(f"Scraping page {page_number}...")
                # Navigate to the current page
                await page.goto(url, wait_until="domcontentloaded")
                # Take a screenshot of the page
                await page.screenshot(path="image.png")
                # Wait for the main results container to load
                await page.wait_for_selector(".s-main-slot")

                # Get all the products on the page
                products = await page.query_selector_all(".s-result-item")

                # Iterate over each product
                for product in products:
                    # Get the name of the product
                    name = await product.query_selector("[data-cy=title-recipe]")
                    name = await name.inner_text() if name else "N/A"

                    # Get the current price of the product
                    current_price = await product.query_selector(
                        ".a-price > .a-offscreen"
                    )
                    current_price = (
                        await current_price.inner_text() if current_price else "N/A"
                    )

                    # Get the rating of the product
                    rating = await product.query_selector(
                        "[data-cy=reviews-ratings-slot]"
                    )
                    rating = await rating.inner_text() if rating else "N/A"

                    # Get the reviews of the product
                    reviews = await product.query_selector(
                        ".rush-component > div > span > a > span, a.a-link-normal > span.a-size-base"
                    )
                    reviews = await reviews.inner_text() if reviews else "N/A"

                    # Get the coupon of the product
                    coupon = await product.query_selector(".s-coupon-unclipped")
                    coupon = await coupon.inner_text() if coupon else "N/A"

                    # Get the link of the product
                    link = await product.query_selector("a.a-link-normal")
                    if link:
                        full_link = await link.get_attribute("href")
                        link = full_link.split("/ref=")[0] if full_link else "N/A"
                        link = f"<https://www.amazon>.{domain}{link}"
                    else:
                        link = "N/A"

                    # Write the product data to the CSV file
                    if name != "N/A" and "Sponsored" not in name:
                        writer.writerow(
                            [name, current_price, rating, reviews, coupon, link]
                        )

                # Check if there is a next page
                next_page = await page.query_selector(".s-pagination-next")
                if not next_page:
                    print("No more pages to scrape.")
                    break
                page_number += 1
        print("Scraping completed successfully.")
        # Close the browser
        await browser.close()

# Main function to start the scraping process
async def main():
    # Start the Amazon shopping search with the specified query and domain
    await amazon_shopping_search(search_query="office chair", domain="com")

# Run the main function
asyncio.run(main())

Fonction #Main pour démarrer le processus de grattage

async def main () :

page = attendre navigateur.nouveau_page () # Initialise le numéro de page page_number = 1

    # Create a new page in the browser

    # Create a new page in the browser

« serveur » : »https://network.joinmassive.com:65535«, « nom d'utilisateur » : « VOTRE_MASSIVE_USERNAME », « password » : « VOTRE_MASSIVE_PASSWORD »,

Utiliser un proxy massif pour éviter le blocage des adresses IP

Remplacez les espaces dans la requête de recherche par « + »

q = search_query.replace(" ", "+")
# Construct the base URL for the search
base_url = f"<https://www.amazon>.{domain}/s?k={q}"

# Launch a headless browser
async with async_playwright() as p:

importer asyncio depuis playwright.async_api import async_playwright import csv

Une fois le code exécuté avec succès, toutes les données du produit récupérées sont enregistrées dans un fichier CSV :

Sympa ! Les données sont faciles à analyser et à lire.

Conclusion

Cet article explique comment l'utilisation de proxys Massive peut vous aider à extraire des données précieuses tout en minimisant les risques de détection et de blocage. Pour obtenir des conseils détaillés sur l'utilisation des proxys Massive, consultez notre documentation officielle.

N'oubliez pas d'explorer Massif des solutions de proxy fiables et éthiques. Découvrez-les et inscrivez-vous dès aujourd'hui !

‍