eBay est l'une des plus grandes places de marché du commerce électronique au monde, proposant des milliards d'annonces eBay et attirant des millions de visiteurs quotidiens. Pour les entreprises, les données sur les produits eBay constituent une mine de données précieuses qui peuvent s'avérer précieuses pour la veille économique, les études de marché et les analyses concurrentielles. Cependant, le processus de web scraping permettant d'extraire des données d'eBay à grande échelle pose des défis techniques importants en raison des mécanismes anti-grattage avancés de la plateforme.

Ce guide étape par étape explique comment créer un web scraper eBay à l'aide du réseau proxy de Massive pour extraire efficacement les données des annonces eBay tout en minimisant le risque de blocage.

Sans plus attendre, commençons !

Pourquoi extraire les données d'eBay ?

Les données brutes du site Web d'eBay fournissent aux entreprises des informations précieuses qui leur permettent de prendre des décisions éclairées et de bénéficier d'un avantage concurrentiel. Voici comment les données accessibles au public d'eBay transforment les stratégies commerciales :

1. Étude de marché : En suivant les prix, les promotions et les préférences des clients des concurrents en temps réel, vous pouvez identifier les lacunes du marché et ajuster votre stratégie pour surpasser vos concurrents.
2. Tarification intelligente : La surveillance des fluctuations de prix sur eBay vous permet d'ajuster vos prix pour rester compétitif tout en maintenant des marges saines. Cela est particulièrement utile sur les marchés en évolution rapide où les prix changent fréquemment ou pendant les pics saisonniers.
3. Décisions relatives aux produits : Tirez parti des données relatives aux ventes et aux commentaires d'eBay pour valider vos choix de produits avant d'investir dans de nouveaux stocks. En analysant ce qui se vend bien et en comprenant les commentaires des clients, vous pouvez affiner votre offre de produits et planifier vos lancements pour un impact maximal.
4. Gestion des stocks : Les données d'eBay indiquent clairement les tendances de la demande, ce qui vous permet de maintenir des niveaux d'inventaire optimaux. Cela vous permet d'optimiser les niveaux de stock, d'éviter les surstocks et de prévenir les ruptures de stock.

Évitez de vous faire bloquer lorsque vous grattez eBay

Construire un scraper eBay n'est pas aussi simple qu'il y paraît. Le grattage d'eBay à grande échelle présente des défis importants en raison de la limitation du débit basée sur IP, CAPTCHAet des mesures anti-éraflures strictes. Lorsque vous dépassez les limites de requêtes d'eBay, votre adresse IP est bloquée ou fait l'objet de CAPTCHA.

Pourquoi avez-vous besoin de proxys pour eBay Scraping ?

Lorsque vous créez un scraper eBay pour extraire les données eBay à grande échelle, les proxys ne sont pas seulement utiles, ils sont essentiels. L'utilisation de proxys vous permet de répartir vos demandes sur plusieurs adresses IP, ce qui vous permet de :

• Évitez d'être bloqué ou étranglé
• Maintenez des vitesses de grattage constantes
• Empêcher la mise sur liste noire des adresses IP (ce qui peut être un véritable casse-tête à résoudre)
• Faites évoluer votre collecte de données de manière fiable

Pourquoi choisir Massive Proxies pour Scraping eBay ?

Comme nous l'avons déjà dit plus haut, l'extraction de données sur eBay n'est pas simple. Vous devez envisager d'utiliser une sorte de proxy, et proxys résidentiels sont les plus préférés. Notre utilisation de proxys résidentiels Des adresses IP provenant de véritables ordinateurs de bureau et appareils mobiles, ce qui les rend très efficaces pour contourner les mesures anti-grattage d'eBay. Voici ce que nous proposons :

1. Taux de réussite élevé: Nos adresses IP résidentielles réduisent considérablement les risques de blocage, permettant une collecte de données fiable à grande échelle.
2. Accès mondial: Collectez des données de manière fluide depuis n'importe quelle place de marché eBay du monde entier à l'aide de proxys spécifiques à chaque région.
3. Données locales précises: ciblez des villes ou des pays spécifiques pour obtenir des informations précises sur le marché et les prix.
4. Performances garanties: Profitez de taux de réussite de 99 % avec des temps de réponse rapides et une surveillance de la disponibilité 24 h/24 et 7 j/7.
5. Utilisation flexible: choisissez parmi différentes options de bande passante pour répondre à vos besoins de scraping, qu'il s'agisse d'une petite entreprise ou d'une entreprise.

💡 Conseil de pro : Utilisez toujours des proxys de votre pays cible lorsque vous explorez les différentes places de marché eBay. Cela vous permettra d'obtenir des données locales sur les prix et les disponibilités. Massive Proxies fournit des adresses IP spécifiques à la localisation sur tous les principaux marchés eBay pour des résultats cohérents.

Commencer à utiliser Massive Proxies

Si vous découvrez Massive pour la première fois, créer un compte. Choisissez un plan adapté à vos besoins.

Remarque : Nous proposons un Essai gratuit de 2 Go pour les entreprises. Pour commencer, remplissez ce formulaire. Si vous avez besoin de plus de bande passante, contactez notre équipe commerciale, et nous vous aiderons.

Après votre inscription, rendez-vous sur Tableau de bord Massive pour récupérer vos informations d'identification du proxy (nom d'utilisateur et mot de passe).

‍Étapes de configuration :

Visitez le Démarrage rapide section pour personnaliser les paramètres de votre proxy :

• Choisissez votre protocole préféré (HTTP, HTTPS ou SOCKS5)
• Choisissez entre proxys rotatifs ou collants
• Définissez les préférences de ciblage géographique (pays, État, ville ou code postal)

Une fois la configuration terminée, vous obtiendrez une commande cURL prête à l'emploi adaptée à votre cas d'utilisation spécifique.

Pour des fonctionnalités avancées telles que le ciblage basé sur la localisation et les sessions persistantes, consultez le Une documentation volumineuse. La documentation fournit des instructions étape par étape pour tirer le meilleur parti des proxies résidentiels Massive.

Avec cette configuration, vous pouvez utiliser Massive Proxies pour extraire les données eBay des principaux sites de vente, notamment aux États-Unis, au Royaume-Uni, en Allemagne et en Australie.

Quelles données sur les produits pouvez-vous extraire d'eBay ?

Scraping eBay peut vous fournir une mine d'informations sur les produits. Voici une ventilation complète des données disponibles :

• URL du produit : Le lien vers la page produit eBay
• Titre : Le nom de l'article
• Sous-titre : Texte descriptif supplémentaire
• Prix actuel : Le prix de vente actuel
• Prix du Was : Le prix précédent (si disponible)
• Réduction : Le pourcentage ou le montant de la réduction
• Disponibilité : Quantité disponible et état des stocks
• Nombre de produits vendus : Nombre d'articles vendus
• Détails de livraison : Coût et délai de livraison estimé
• Lieu : L'origine de l'expédition
• Retours : Détails de la politique de retour
• État : Si l'article est neuf, d'occasion ou remis à neuf
• Brand: Manufacturer or brand name
• Type: The category or product type
• Seller Information:
  • Seller/store name
  • Customer feedback percentage
  • Total sales by the seller

Required User Inputs

To start scraping eBay, you'll need to specify two key parameters:

1. Target Country: You can extract data from 10 regional eBay domains:

"US": "https://www.ebay.com",
"GB": "https://www.ebay.co.uk",
"DE": "https://www.ebay.de",
"ES": "https://www.ebay.es",
"FR": "https://www.ebay.fr",
"IT": "https://www.ebay.it",
"CA": "https://www.ebay.ca",
"MX": "https://www.mx.ebay.com",
"NL": "https://www.ebay.nl",
"AU": "https://www.ebay.com.au"

2. ‍Search Terms: Enter what you want to scrape (e.g., "recliner chair", "drone camera"). You can input multiple terms using commas.

2. Item Limit: (Optional) Specify how many items to scrape. Skip this to collect all available data across all pages.

The extracted data will be saved in a structured JSON file.

Building an eBay Data Scraper with Massive Proxies

This guide explores step-by-step how to scrape eBay at scale. While we focus on scraping eBay.com (US site), the same principles apply to other country-specific eBay sites with minor adjustments to selectors.

Step #1: Project Setup

First, make sure you have Python 3 installed on your system. If not, download and install it.

Now, create a directory for your project:

mkdir ebay_scraper

Open the project folder in your preferred IDE (like VS Code) and create a file named usa_ebay.py. This file will contain our scraping logic to scrape eBay data.

You'll also need to create a .env file to store your Massive Proxy credentials:

PROXY_USERNAME=your_username
PROXY_PASSWORD=your_password

Now, your project structure should look like this:

ebay_scraper/
├── .env
└── usa_ebay.py

‍

Step #2: Installing Dependencies

To scrape eBay data efficiently, you will need to use several key libraries:

• curl_cffi: A high-performance HTTP client that supports JA3/TLS fingerprinting and HTTP/2
• beautifulsoup4: For HTML parsing
• python-dotenv: For environment variable management
• aiofiles: For asynchronous file operations

Now, you can install these dependencies using pip as shown below:

pip install curl-cffi beautifulsoup4 python-dotenv aiofiles

‍

Step #3: Configuring Massive Proxies

This step sets up a proxy to enable geotargeting, ensuring requests are routed through specific countries for extracting eBay data accurately:

def setup_proxy(self):
    """Configure proxy settings for geotargeted requests"""
    self.proxy_host = "network.joinmassive.com:65534"
    self.username = os.getenv("PROXY_USERNAME")
    self.password = os.getenv("PROXY_PASSWORD")
    self.proxy_auth = f"{self.username}-country-{self.domain}:{self.password}"

‍

Step #4: Request Configuration

Configure HTTP requests using the curl_cffi library. The setup involves two methods:

1. _get_proxy_config: Formats proxy authentication credentials and host details
2. _make_request: Handles HTTP request execution with features like rate limiting and browser emulation

def _get_proxy_config(self) -> Dict[str, str]:
    """Generate proxy configuration dictionary"""
    return {"https": f"http://{self.proxy_auth}@{self.proxy_host}"}


async def _make_request(self, session: AsyncSession, url: str, page_type: str):
    """Make HTTP request with proxy and browser emulation"""
    async with self.semaphore:
        response = await session.get(
            url,
            proxies=self._get_proxy_config(),
            impersonate="chrome124",
            timeout=self.page_timeout,
        )

‍

Step #5: Processing Search Pages

This method _process_search_page manages the processing of individual search result pages. It takes an async session, page number, and search term as inputs. Here's how it works:

The function constructs the search URL by building query parameters that include:

• The search keyword (_nkw)
• Page number (_pgn)
• Items per page setting (_ipg) optimized to 240 items

Then, it makes an async request using the previously configured request method. If the content is retrieved successfully, it parses it using BeautifulSoup with the lxml parser. Then, it extracts product URLs from the parsed HTML and processes the extracted product URLs in batches.

async def _process_search_page(
    self, session: AsyncSession, page_num: int, search_term: str
):
    """Process a single search results page"""
    try:
        params = {
            "_nkw": search_term,
            "_pgn": page_num,
            "_ipg": 240,  # Maximum items per page
        }
        url = self.base_url + urlencode(params)

        status_code, html_content = await self._make_request(session, url, "search")
        if html_content:
            soup = BeautifulSoup(html_content, "lxml")
            urls = self._extract_product_urls(soup)

            logger.info(f"Found {len(urls)} products on page {page_num}")
            return await self._process_product_batch(session, urls)
    except Exception as e:
        logger.error(f"Error processing page {page_num}: {str(e)}")
        return False, False

‍

Step #6: Extracting Product URLs

This method handles the crucial task of extracting product URLs from search result pages. Here's how the product URL extraction works:

The _extract_product_urls method accepts a BeautifulSoup object that contains the parsed HTML content and returns a list of valid product URLs. It implements a focused approach to URL extraction:

• Uses CSS selector a.s-item__link to find all product link elements
• Iterates through each link element to extract the href attribute
• Validates URLs by checking for the presence of itm/ in the URL path
• Builds a filtered list containing only valid product URLs

def _extract_product_urls(self, soup: BeautifulSoup) -> List[str]:
    """Extract product URLs from search results page"""
    urls = []
    for link in soup.select("a.s-item__link"):
        url = link.get("href", "")
        if url and "itm/" in url:
            urls.append(url)
    return urls

‍

Step #7: Scraping Product Details

The _extract_product_details method systematically extracts product information from eBay product pages. It processes a BeautifulSoup object and returns a ProductDetails object containing structured data.

def _extract_product_details(self, soup: BeautifulSoup, url: str) -> ProductDetails:
    """Extract all product details from page"""
    details = ProductDetails(url=url)

    try:
        details.store_info = DataExtractor.extract_store_info(soup)

        # Title section
        if title_div := soup.select_one("div.x-item-title"):
            if title := title_div.select_one("h1.x-item-title__mainTitle span"):
                details.title = title.text.strip()
            if subtitle := title_div.select_one("div.x-item-title__subTitle span"):
                details.subtitle = subtitle.text.strip()

        # Price section
        if price_section := soup.select_one("div.x-price-section"):
            if current_price := price_section.select_one("div.x-price-primary span"):
                details.current_price = current_price.text.strip()
            if was_price := price_section.select_one(
                "span.ux-textspans--STRIKETHROUGH"
            ):
                details.was_price = was_price.text.strip()

            # Discount calculation
            discount = None
            if emphasis_discount := price_section.select_one(
                "span.ux-textspans--EMPHASIS"
            ):
                discount = emphasis_discount.text.strip()
            elif secondary_discount := price_section.select_one(
                "span.ux-textspans--SECONDARY"
            ):
                discount = secondary_discount.text.strip()
            if discount and (percentage_match := re.search(r"(\d+)%", discount)):
                details.discount = percentage_match.group(1) + "%"

        # Quantity section
        if quantity_div := soup.select_one("div.x-quantity__availability"):
            spans = quantity_div.select("span.ux-textspans")
            if spans:
                details.availability = spans[0].text.strip()
                if len(spans) > 1:
                    details.sold_count = spans[1].text.strip()

        # Shipping section
        if shipping_div := soup.select_one("div.d-shipping-minview"):
            if shipping_section := shipping_div.select_one(
                "div.ux-labels-values__values-content"
            ):
                details.shipping, details.location = (
                    DataExtractor.extract_shipping_info(shipping_section)
                )

        # Returns section
        if returns_div := soup.select_one("div.x-returns-minview"):
            if returns_section := returns_div.select_one(
                "div.ux-labels-values__values-content"
            ):
                details.returns = DataExtractor.extract_returns_info(returns_section)

        # Additional details
        if condition_span := soup.select_one(
            "div.x-item-condition-max-view .ux-section__item > span.ux-textspans"
        ):
            details.condition = condition_span.text.strip().split(".")[0] + "."
        if (brand_dl := soup.select_one("dl.ux-labels-values--brand")) and (
            brand_value := brand_dl.select_one("dd .ux-textspans")
        ):
            details.brand = brand_value.text.strip()
        if (type_dl := soup.select_one("dl.ux-labels-values--type")) and (
            type_value := type_dl.select_one("dd .ux-textspans")
        ):
            details.type = type_value.text.strip()
    except Exception as e:
        logger.error(f"Error extracting details from {url}: {str(e)}")
    return details

‍

Step #8: Handling Pagination

The _has_next_page method uses two different approaches to check for pagination:

• First, it looks for a next page link by searching for an anchor tag with type = « suivant » attribut. Si ce lien existe et possède une valeur valide href attribut, il confirme la présence d'une page suivante.
• En tant que mécanisme de repli, il vérifie également la présence d'un élément de bouton suivant. Cela recherche un bouton avec type = « suivant » et vérifie s'il n'est pas désactivé en cochant aria-disabled attribut. Si le bouton existe mais n'est pas désactivé, cela signifie que d'autres pages sont disponibles.

def _has_next_page(self, soup: BeautifulSoup) -> bool:
    """Determine if there is a next page of results"""
    next_link = soup.select_one('a[type="next"]')
    if next_link and next_link.get("href"):
        return True
    next_button = soup.select_one('button[type="next"]')
    return not (next_button and next_button.get("aria-disabled") == "true")

‍

Étape #9 : Stockage des données

Enfin, enregistrez les données extraites dans un fichier JSON :

class FileHandler:
    """Handle file operations with error handling and backups"""

    @staticmethod
    async def save_to_file(filename: str, data: Dict):
        """Save data with automatic backup creation"""
        temp_file = f"{filename}.temp"
        backup_file = f"{filename}.backup"

        try:
            # Create directory structure
            os.makedirs(os.path.dirname(filename), exist_ok=True)

            # Save to temporary file
            async with aiofiles.open(temp_file, "w", encoding="utf-8") as f:
                await f.write(json.dumps(data, indent=2, ensure_ascii=False))

            # Create backup of existing file
            if os.path.exists(filename):
                os.replace(filename, backup_file)

            # Replace with new file
            os.replace(temp_file, filename)

            logger.info(f"Data successfully saved to {filename}")
        except Exception as e:
            logger.error(f"Error saving data: {str(e)}")
            raise

‍

Étape #10 : Exécutez le grattoir

La mise en œuvre complète du scraping d'eBay sur 10 domaines de marché est disponible sur GitHub. Le scraper extrait les données du produit et génère un fichier JSON structuré, chaque entrée contenant :

{
    "url": "https://www.ebay.com/itm/294701001393",
    "title": "Manual Recliner Armchair PU Sofa Chair w/ Adjustable Leg Rest & 135° Reclining",
    "subtitle": "Comfortable & Easy to Clean & 360° Swivel & Steel Frame",
    "current_price": "US $228.99",
    "was_price": "US $651.99",
    "discount": "65%",
    "availability": "More than 10 available",
    "sold_count": "93 sold",
    "shipping": "Free shipping - Arrives by Christmas",
    "location": "Wilsonville, Oregon, United States",
    "returns": "30 days returns Buyer pays for return shipping",
    "condition": "A brand-new, unused, unopened, undamaged item in its original packaging (where packaging is applicable).",
    "brand": "Homcom",
    "type": "Recliner Armchair",
    "store_info": {
        "name": "Aosom-Direct",
        "feedback": "97.5% positive feedback",
        "sales": "482K items sold",
    },
}

‍

Conclusion

Ce guide explique comment créer un scraper eBay qui fonctionne sur les différentes places de marché eBay. En utilisant des proxys résidentiels, vous pouvez recueillir des données précises sur les produits tout en minimisant les risques de blocage. L'approche que nous avons décrite permet de collecter des données de manière fiable sur les différents sites régionaux d'eBay.

Si vous avez besoin de plus de détails sur la configuration du proxy ou sur les meilleures pratiques, vous trouverez tout dans documentation.

Prêt à démarrer ? Inscrivez-vous à Massive Proxies dès aujourd'hui 🚀