Comment extraire les annonces de produits Etsyproduits, prix et boutiques

Etsy est une marketplace mondiale dédiée aux articles artisanaux, vintage et créatifs, et chaque page de recherche constitue un flux public structuré de ce que les vendeurs proposent en ce moment : le titre du produit, le prix demandé, la boutique qui se cache derrière et une note par étoiles. Pour quiconque fait de la veille concurrentielle, du suivi des prix ou de l'analyse dans l'univers du fait main, ces données d'annonces représentent l'un des signaux de demande les plus lisibles sans avoir de compte. Un vendeur peut observer comment ses concurrents fixent le prix d'un article similaire ; un acheteur peut surveiller une catégorie pour détecter des tendances ; un analyste peut cartographier l'évolution d'une niche dans le temps.

Ce guide vous montre comment extraire les annonces de produits Etsy avec Python. Vous construirez un petit script fonctionnel qui récupère une page de recherche Etsy via la Crawling API, analyse un enregistrement propre par annonce, gère la pagination sur plusieurs pages de résultats et exporte les données en JSON et CSV. L'ensemble du tutoriel se limite aux données d'annonces publiques : les titres, prix, noms de boutiques, notes et liens que tout le monde peut voir sur une page de recherche Etsy sans se connecter.

Ce que vous allez construire

Un script Python qui prend une requête de recherche Etsy, récupère chaque page de résultats rendue via la Crawling API, et extrait un enregistrement structuré par carte d'annonce. Nous utilisons la requête de recherche clothes comme exemple fil rouge, la même que celle utilisée dans l'ancien tutoriel, et nous extrayons ces champs de chaque carte :

• Title le nom du produit affiché sur la carte d'annonce.
• Price le prix affiché, tel que la valeur monétaire qu'Etsy affiche sur la carte.
• Shop le nom de la boutique du vendeur associée à l'annonce.
• Rating la note moyenne par étoiles, lorsque l'annonce en affiche une.
• Link l'URL vers la page de détail propre à l'annonce.

Pourquoi une requête simple échoue sur Etsy

Si vous pointez un client HTTP brut sur une URL de recherche Etsy, vous obtenez rarement les annonces recherchées. Deux éléments jouent contre vous. Premièrement, Etsy repose fortement sur JavaScript : il envoie une coquille légère et remplit les cartes d'annonces au fur et à mesure que les scripts de la page s'exécutent, de sorte que le HTML initial est souvent dépourvu de la majeure partie de la grille. Deuxièmement, Etsy détecte rapidement le trafic automatisé. Les plages d'IP de centres de données et les schémas de requêtes qui ne ressemblent pas à un vrai navigateur se voient opposer un CAPTCHA, une page de vérification ou un blocage pur et simple avant même d'accéder aux résultats.

Un scraper Etsy fonctionnel a donc besoin de deux choses en une seule requête : un navigateur qui rend la page, et une IP qu'Etsy considère 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 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 de recherche, elle rend la page derrière une IP résidentielle de confiance, gère la rotation et la résolution des CAPTCHA, et vous renvoie le HTML final prêt à analyser.

Prérequis

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

Notions de base en Python. Vous devez être à l'aise pour écrire et exécuter un script Python et installer des paquets avec pip. Si vous débutez avec ce langage, la documentation officielle Python ou tout cours pour débutants couvre le niveau supposé par 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. Etsy rend ses annonces avec JavaScript, utilisez donc le token JavaScript pour ce scraper. Le niveau gratuit inclut 1 000 requêtes sans carte bancaire, ce qui est largement suffisant pour construire et tester. Traitez le token comme un mot de passe et ne le committez pas dans votre système de contrôle de version.

Configurer le projet

Créez un environnement virtuel pour isoler les dépendances du projet, puis installez les trois bibliothèques dont le scraper a besoin. crawlbase est le client officiel pour la Crawling API, beautifulsoup4 analyse le HTML renvoyé pour que vous puissiez extraire chaque champ des cartes d'annonces par sélecteur CSS, et pandas fait de l'export CSV une simple ligne de code.

python --version

python -m venv etsy_env
source etsy_env/bin/activate

pip install crawlbase beautifulsoup4 pandas

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

touch etsy_scraper.py

Comprendre la page de recherche Etsy

La page de recherche Etsy se trouve à une URL stable indexée sur la requête : une recherche de clothes donne https://www.etsy.com/search?q=clothes, et vous naviguez entre les pages de résultats en ajoutant un paramètre &page=. La page présente une grille de cartes d'annonces, une par produit, chacune portant le même ensemble de champs : un titre, un prix, un nom de boutique, une note par étoiles et un lien vers la page de détail de l'annonce.

Avant d'écrire des sélecteurs, ouvrez une page de recherche dans votre navigateur, faites un clic droit sur une carte d'annonce et choisissez Inspecter. Etsy enveloppe chaque résultat dans un élément de liste sous un conteneur de résultats de recherche, et expose le titre, le prix et la note à l'intérieur de cette carte. Ce sont ces éléments que vous ciblez. Les noms de classes Etsy changent de temps à autre, donc les sélecteurs ci-dessous fonctionnaient au moment de la rédaction ; attendez-vous à devoir ré-inspecter la page en direct et à les ajuster si un champ commence à revenir vide.

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

Commencez par obtenir la page finale. Importez la classe CrawlingAPI, initialisez-la avec votre token, définissez l'URL de recherche et faites la requête. 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": 3000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("latin1")
    print(f"Request failed: {response['status_code']}")
    return None

if __name__ == "__main__":
    search_url = "https://www.etsy.com/search?q=clothes"
    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 chargé, et page_wait maintient l'attente un nombre fixe de millisecondes après le chargement pour que les cartes à rendu tardif apparaissent avant la capture de la page. Le corps est décodé en latin1 car les pages Etsy contiennent des caractères que le décodage strict UTF-8 peut ne pas gérer correctement. Exécutez le script et vous devriez voir le vrai balisage des annonces, pas une coquille de défi. Cela confirme que le rendu fonctionne avant d'écrire un seul sélecteur.

Étape 2 : Analyser les cartes d'annonces avec BeautifulSoup

Le HTML rendu en main, chargez-le dans BeautifulSoup, trouvez chaque carte d'annonce et extrayez chaque champ par son sélecteur. Etsy regroupe les résultats dans une liste ordonnée sous le conteneur de résultats de recherche, avec un élément de liste par carte. À l'intérieur de chaque carte, le titre, le prix, la boutique et la note se trouvent dans leurs propres éléments, et le lien de l'annonce est l'ancre de la carte. Enveloppez chaque carte dans un try/except pour qu'une annonce malformée ne fasse pas planter l'exécution.

from bs4 import BeautifulSoup

CONTAINER = "div.search-listings-group div[data-search-results-container] ol li"

def text_of(card, selector):
    el = card.select_one(selector)
    return el.get_text(strip=True) if el else None

def parse_link(card):
    a = card.select_one("a.listing-link[href]")
    return a["href"] if a else None

def scrape_listings(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select(CONTAINER)
    results = []
    for card in cards:
        try:
            title = text_of(card, "div.v2-listing-card__info h3.v2-listing-card__title")
            if not title:
                continue
            results.append({
                "title": title,
                "price": text_of(card, "div.n-listing-card__price p.lc-price span.currency-value"),
                "shop": text_of(card, "div.v2-listing-card__info p.v2-listing-card__shop span"),
                "rating": text_of(card, "div.shop-name-with-rating span.larger_review_stars > div"),
                "link": parse_link(card),
            })
        except Exception as e:
            print(f"Skipped a card: {e}")
    return results

L'assistant text_of interroge un élément dans une carte et retourne None quand il est absent, au lieu de lancer une exception sur un appel .get_text() contre rien. Cela rend l'extraction résiliente lorsqu'un champ est absent, ce qui est courant puisque toutes les annonces n'affichent pas une note. Le titre provient de h3.v2-listing-card__title, le prix du span.currency-value dans le bloc de prix, le nom de la boutique de l'élément de boutique de la carte d'annonce, et la note du bloc d'étoiles d'avis. Le sélecteur de conteneur ainsi que les sélecteurs de titre, prix et note sont repris directement de l'ancien tutoriel ; la boutique et le lien sont les deux champs supplémentaires que cette version ajoute.

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

Une page de recherche est un échantillon ; l'ensemble complet de résultats s'étend sur de nombreuses pages. Etsy divise les résultats de recherche en pages numérotées, et vous les parcourez en ajoutant &page=N à l'URL de recherche. Pour obtenir un jeu de données complet, lisez le nombre total de pages depuis la première page, puis parcourez chaque page à son tour. Un court délai entre les requêtes pace l'exécution pour ne pas bombarder Etsy dans une boucle serrée.

import time

PAGINATION = 'div[data-appears-component-name="search_pagination"] nav ul.search-pagination li:nth-last-child(3) a'

def get_total_pages(html):
    soup = BeautifulSoup(html, "html.parser")
    el = soup.select_one(PAGINATION)
    try:
        return int(el.get_text(strip=True)) if el else 1
    except ValueError:
        return 1

def scrape_all_pages(query, max_pages=5):
    search_url = f"https://www.etsy.com/search?q={query}"
    first = crawl(search_url)
    if not first:
        return []
    total = min(get_total_pages(first), max_pages)
    all_listings = scrape_listings(first)
    print(f"page 1: {len(all_listings)} listings (of {total} pages)")
    for page in range(2, total + 1):
        html = crawl(f"{search_url}&page={page}")
        if not html:
            break
        found = scrape_listings(html)
        all_listings.extend(found)
        print(f"page {page}: {len(found)} listings")
        time.sleep(2)
    return all_listings

get_total_pages lit le nombre de pages depuis le contrôle de pagination : le sélecteur hérité cible le troisième lien de pagination en partant de la fin, qui correspond à la dernière page numérotée avant les flèches suivant et dernier. Il bascule sur 1 si le contrôle est absent ou si le texte n'est pas un nombre, de sorte qu'un résultat sur une seule page fonctionne quand même. Le plafond max_pages maintient une exécution de test limitée pendant le développement, et le time.sleep(2) entre les requêtes pace le crawl pour ne pas être signalé pour un trafic à feu rapide.

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

Maintenant, reliez la récupération, l'analyse et la pagination en un seul script exécutable, puis écrivez les enregistrements en JSON et CSV pour pouvoir les charger dans un notebook ou un tableur. JSON conserve la structure pour le code ; le CSV, écrit avec pandas, s'ouvre directement dans n'importe quel outil de tableur.

import json
import time
import pandas as pd
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})
CONTAINER = "div.search-listings-group div[data-search-results-container] ol li"
PAGINATION = 'div[data-appears-component-name="search_pagination"] nav ul.search-pagination li:nth-last-child(3) a'

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

def text_of(card, selector):
    el = card.select_one(selector)
    return el.get_text(strip=True) if el else None

def parse_link(card):
    a = card.select_one("a.listing-link[href]")
    return a["href"] if a else None

def scrape_listings(html):
    soup = BeautifulSoup(html, "html.parser")
    results = []
    for card in soup.select(CONTAINER):
        try:
            title = text_of(card, "div.v2-listing-card__info h3.v2-listing-card__title")
            if not title:
                continue
            results.append({
                "title": title,
                "price": text_of(card, "div.n-listing-card__price p.lc-price span.currency-value"),
                "shop": text_of(card, "div.v2-listing-card__info p.v2-listing-card__shop span"),
                "rating": text_of(card, "div.shop-name-with-rating span.larger_review_stars > div"),
                "link": parse_link(card),
            })
        except Exception as e:
            print(f"Skipped a card: {e}")
    return results

def get_total_pages(html):
    soup = BeautifulSoup(html, "html.parser")
    el = soup.select_one(PAGINATION)
    try:
        return int(el.get_text(strip=True)) if el else 1
    except ValueError:
        return 1

def scrape_all_pages(query, max_pages=5):
    search_url = f"https://www.etsy.com/search?q={query}"
    first = crawl(search_url)
    if not first:
        return []
    total = min(get_total_pages(first), max_pages)
    listings = scrape_listings(first)
    print(f"page 1: {len(listings)} listings (of {total} pages)")
    for page in range(2, total + 1):
        html = crawl(f"{search_url}&page={page}")
        if not html:
            break
        found = scrape_listings(html)
        listings.extend(found)
        print(f"page {page}: {len(found)} listings")
        time.sleep(2)
    return listings

def export(rows, name="etsy_listings"):
    with open(f"{name}.json", "w", encoding="utf-8") as f:
        json.dump(rows, f, indent=2, ensure_ascii=False)
    pd.DataFrame(rows).to_csv(f"{name}.csv", index=False)
    print(f"Saved {len(rows)} listings to {name}.json and {name}.csv")

def main():
    rows = scrape_all_pages("clothes", max_pages=5)
    if rows:
        export(rows)

if __name__ == "__main__":
    main()

Exécutez le script complet avec python etsy_scraper.py. Il récupère chaque page de recherche rendue, analyse une ligne par annonce, parcourt les pages de résultats jusqu'à max_pages, et écrit à la fois etsy_listings.json et etsy_listings.csv. Construire le CSV depuis un DataFrame pandas signifie que les colonnes suivent automatiquement les clés du dictionnaire, de sorte que les deux exports ne divergent jamais.

À quoi ressemble la sortie

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

[
  {
    "title": "Women's Christian Sweatshirt, Bible Verse Shirts, Faith Based Tshirts",
    "price": "13.85",
    "shop": "FaithfulThreadsCo",
    "rating": "4.8",
    "link": "https://www.etsy.com/listing/1234567890/womens-christian-sweatshirt"
  },
  {
    "title": "Thankful Super Soft Sweatshirt, Thanksgiving Sweatshirt, Friendsgiving Shirt",
    "price": "29.99",
    "shop": "CozyFallPrints",
    "rating": "4.9",
    "link": "https://www.etsy.com/listing/9876543210/thankful-super-soft-sweatshirt"
  }
]

Le prix est transmis comme la valeur brute en devise qu'Etsy affiche sur la carte, donc si vous souhaitez un nombre pour l'analyse, vous pouvez le convertir en float après avoir supprimé les séparateurs de milliers. Si vous préférez stocker les données dans un format interrogeable plutôt que dans des fichiers plats, les mêmes dictionnaires de lignes s'insèrent directement dans une table SQLite avec un court insert sqlite3, que l'ancien tutoriel couvrait comme alternative au CSV.

Mise à l'échelle sur plusieurs requêtes

Une requête de recherche est une démonstration ; un vrai travail de recherche en couvre beaucoup. Etsy sert une page de recherche pour n'importe quelle chaîne de requête, donc pour comparer des niches vous conservez une liste de requêtes et exécutez le scraper paginé sur chacune, en indexant la sortie par nom de requête. Pacez les requêtes pour ne pas tout crawler à pleine vitesse.

QUERIES = ["clothes", "ceramic mug", "leather wallet"]

def scrape_queries(queries, max_pages=3):
    everything = {}
    for query in queries:
        print(f"scraping: {query}")
        everything[query] = scrape_all_pages(query, max_pages=max_pages)
        time.sleep(3)
    return everything

Indexer la sortie par requête maintient chaque jeu de résultats séparé, ce qui est nécessaire pour comparer des catégories. Pour suivre les tendances dans le temps, exécutez le job selon un calendrier et horodatez chaque export, puis comparez les instantanés successifs pour voir comment les prix et les notes ont évolué. Pour un traitement plus approfondi de la transformation de ce type de flux en jeu de données de tarification, voir comment utiliser le scraping web pour l'intelligence des prix.

Rester non bloqué

Même avec le rendu géré, Etsy surveille le trafic ressemblant à un scraper. Quelques habitudes maintiennent une exécution saine, et elles s'appliquent à toute cible commerciale difficile.

• Pacez 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 travaux plus lourds pendant les heures creuses pour alléger la charge sur les serveurs Etsy.
• Misez sur la rotation. Un pool d'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 construisez votre propre infrastructure, c'est la partie à bien faire.
• Ne conservez que ce dont vous avez besoin. Stockez les champs d'annonces que votre projet utilise et supprimez le reste. Revérifiez périodiquement vos sélecteurs pour que le scraper suive les changements de balisage.

Pour le guide plus complet sur l'évitement des blocages, voir comment scraper des sites web sans être bloqué, et pour l'aspect analyse, le guide sur l'utilisation de BeautifulSoup en Python couvre la bibliothèque en profondeur. Si vous construisez vers un workflow de recherche complet, comment automatiser la recherche de produits e-commerce montre où un flux d'annonces comme celui-ci s'inscrit.

Est-il légal de scraper Etsy ?

La légalité du scraping d'Etsy dépend des Conditions d'utilisation d'Etsy, de votre juridiction et de ce que vous faites des données. Les conditions d'Etsy imposent des limites sur l'accès automatisé, donc le scraping peut aller à l'encontre de ces conditions quelle que soit la prudence de vos outils. Aucun code ici ne change cela ; il ne fait que rendre la partie technique fonctionnelle. Lisez les Conditions d'utilisation d'Etsy et son 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 sur votre cas spécifique est la démarche sensée.

Quelques lignes à respecter. Collectez uniquement des données publiques : les titres des annonces, les prix, les noms de boutiques, les notes et les liens d'annonces que tout le monde peut voir sur une page de recherche sans compte. Gardez votre volume de requêtes assez bas pour ne pas surcharger les serveurs d'Etsy, et respectez la vie privée des vendeurs : évitez les données personnelles, y compris tout ce qui est lié à des acheteurs ou vendeurs identifiables au-delà du nom de boutique public sur une annonce. Ne redistribuez pas les photos de produits ou les descriptions appartenant aux vendeurs, et ne tentez pas d'accéder à quoi que ce soit derrière une connexion ou de contourner l'authentification ou un défi que vous n'êtes pas autorisé à franchir.

Ce guide est délibérément limité aux annonces de recherche publiques Etsy parce que c'est la ligne qui rend le travail défendable. Pour un accès sous licence ou en volume, Etsy propose une Open API officielle pour les développeurs, qui est le bon outil quand vous avez besoin de grands volumes, d'une structure garantie ou de droits commerciaux. Si votre projet nécessite plus que des données d'annonces publiques, cette API officielle ou un accord de données est le chemin correct, pas un scraper plus ingénieux.

Foire aux questions

Pourquoi une requête simple ne retourne-t-elle aucune annonce depuis Etsy ?

Deux raisons. Etsy remplit une grande partie de la grille d'annonces côté client au chargement de la page, donc une requête brute obtient souvent une coquille à laquelle il manque la plupart des cartes. De plus, Etsy 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 résout les deux, ce qui explique pourquoi le scraper ici route sa requête via celle-ci avec ajax_wait et page_wait définis.

Comment scraper une requête de recherche Etsy spécifique ?

Chaque recherche Etsy possède sa propre URL indexée sur la requête, par exemple https://www.etsy.com/search?q=clothes. Modifiez la valeur de q pour la requête souhaitée, puis naviguez entre les pages de résultats en ajoutant &page=N. Pour couvrir de nombreuses requêtes, conservez-en une liste et parcourez le scraper paginé, en espacant les requêtes avec un court délai.

Quels champs puis-je extraire d'une carte d'annonce Etsy ?

De chaque carte de résultat de recherche, ce scraper extrait le titre du produit, le prix (la valeur en devise qu'Etsy affiche), le nom de la boutique, la note par étoiles et le lien de l'annonce. L'ancien tutoriel notait également les descriptions et images de produits comme disponibles sur Etsy ; vous pouvez les ajouter en inspectant la carte et en ajoutant les sélecteurs correspondants à l'étape d'analyse.

Comment gérer la pagination lors du scraping d'Etsy ?

Lisez le nombre total de pages depuis le contrôle de pagination sur la première page de résultats, puis bouclez de la page 2 jusqu'à ce total, en ajoutant &page=N à l'URL de recherche à chaque fois. Le scraper ici plafonne le nombre avec un argument max_pages pour qu'une exécution de test reste limitée, et fait une pause entre les requêtes pour ne pas bombarder Etsy dans une boucle serrée.

Comment sauvegarder les données Etsy extraites ?

Le script écrit à la fois un fichier JSON, qui conserve la structure pour le code, et un CSV construit depuis un DataFrame pandas, qui s'ouvre directement dans un tableur. Les mêmes dictionnaires de lignes s'insèrent également dans une table SQLite avec un court insert sqlite3 si vous souhaitez un stockage interrogeable plutôt que des fichiers plats.

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

Gardez votre taux de requêtes par IP bas, ajoutez un délai entre les pages et les requêtes, et routez via des IP résidentielles rotatives pour qu'aucune adresse 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.