Comment télécharger des images depuis Amazondes URL d'images produit vers des fichiers locaux

Une fiche produit Amazon est construite autour de ses images : une photo principale, une galerie de vues sous différents angles, des photos lifestyle et des infographies qui détaillent les caractéristiques et les dimensions. Ces images sont publiques, et pouvoir les récupérer en masse est utile pour la constitution de catalogues, la recherche de produits, l'analyse concurrentielle et l'alimentation d'un jeu de données pour la classification d'images ou la recherche visuelle.

Ce guide vous montre comment télécharger des images depuis une page produit Amazon avec Python, de manière fiable. Vous construisez un petit scraper exécutable qui récupère une page produit rendue via la Crawling API, extrait les URL d'images (l'image principale plus la galerie et les miniatures), et enregistre chacune dans un fichier local. Tout le tutoriel reste limité aux images produit publiques, et la section sur la légalité, vers la fin, n'est pas du remplissage, alors lisez-la avant de pointer ceci vers un quelconque volume réel.

Ce que vous allez construire

Un script Python qui prend une URL de produit Amazon, récupère la page rendue via la Crawling API, collecte chaque URL d'image produit et télécharge chacune dans un dossier local. Nous utiliserons une seule page produit comme exemple fil rouge et extrairons ces sorties :

• Image principale l'image principale en haut de la fiche.
• Images de la galerie les vues sous différents angles et les photos lifestyle derrière la bande de miniatures.
• Miniatures les petites images d'aperçu qui correspondent à chaque photo de la galerie.
• URL d'images le lien direct, en pleine résolution, vers chaque fichier image.
• Fichiers locaux chaque image enregistrée sur disque dans un dossier par produit.

Pourquoi une simple requête échoue sur Amazon

Si vous demandez une URL de produit Amazon avec un client HTTP nu, vous obtenez rarement la galerie que vous êtes venu chercher. Deux choses jouent contre vous. D'abord, Amazon charge une grande partie de la galerie d'images côté client : les variantes haute résolution et la correspondance miniature-vers-principale sont remplies par JavaScript après l'arrivée du HTML initial, de sorte qu'une requête brute ne voit souvent qu'un substitut basse résolution ou un ensemble incomplet. Ensuite, Amazon repère vite le trafic automatisé. Les IP de datacenter et les schémas de requêtes qui ne ressemblent pas à un vrai navigateur sont confrontés à un CAPTCHA ou bloqués avant même d'atteindre la fiche rendue.

Un scraper d'images Amazon fonctionnel a donc besoin de deux choses dans une seule requête : un navigateur qui rend réellement la page, et une IP que la plateforme interprète comme un vrai acheteur. Vous pouvez assembler cela vous-même avec un navigateur sans interface plus un pool de proxys résidentiels rotatifs, mais les coudre ensemble et les garder en bonne santé représente l'essentiel du travail. La Crawling API regroupe les deux en un seul appel : vous lui envoyez l'URL avec un token JavaScript, elle rend la page derrière une IP résidentielle de confiance, et elle vous renvoie un HTML fini que vous pouvez analyser.

Prérequis

Vous avez besoin de quelques éléments en place avant d'écrire le moindre 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 le langage est nouveau pour vous, la documentation officielle de Python et n'importe quel cours pour débutants vous amèneront au niveau que ce tutoriel suppose acquis. Le guide compagnon sur comment télécharger des images avec Python couvre plus en profondeur la mécanique d'écriture des fichiers.

Python 3.8 ou ultérieur. Confirmez votre version avec python --version. Si vous ne l'avez pas, installez-le depuis python.org ou via une distribution comme Anaconda.

Un compte Crawlbase et un token JS. Inscrivez-vous, ouvrez votre tableau de bord et copiez votre token JavaScript (JS) depuis la page de documentation du compte. Vous obtenez jusqu'à 20 000 requêtes gratuites, et vous ne payez que pour celles qui réussissent. Traitez le token comme un mot de passe : il authentifie vos requêtes, donc gardez-le hors du 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 bibliothèques dont le scraper a besoin.

python --version

python -m venv amazon_env
source amazon_env/bin/activate

pip install crawlbase beautifulsoup4 requests

Sous Windows, activez l'environnement avec amazon_env\Scripts\activate au lieu de la ligne source. Trois dépendances font le travail : crawlbase est le client officiel de la Crawling API, beautifulsoup4 analyse le HTML renvoyé pour que vous puissiez en extraire les URL d'images par sélecteur, et requests télécharge chaque fichier image sur disque.

Comprendre la galerie d'images Amazon

Amazon affiche plusieurs types d'images sur une page produit, et il est utile de les connaître avant d'écrire des sélecteurs. L'image principale est la photo produit principale en haut de la fiche. Les images alternatives montrent différents angles ou caractéristiques. Les images lifestyle montrent le produit en utilisation réelle, et les infographies détaillent les caractéristiques, les dimensions ou les spécifications. Toutes se trouvent dans la même galerie et partagent le même hôte d'images.

Avant d'écrire des sélecteurs, ouvrez une page produit dans votre navigateur, faites un clic droit sur l'image principale et choisissez Inspecter. Vous verrez l'image principale à l'intérieur d'un conteneur avec un id stable de landingImage (également accessible via #imgTagWrapperId img), et la bande de miniatures rendue comme une liste de petites images avec l'id altImages. Amazon sert une variante dimensionnée de chaque image en encodant les dimensions dans le nom de fichier, de sorte qu'une URL de miniature et sa contrepartie en pleine résolution ne diffèrent que par ce jeton de taille. C'est ce détail qui vous permet de transformer un lien d'aperçu réduit en un téléchargement en haute résolution.

Étape 1 : Récupérer la page produit rendue

Commencez par obtenir la page finie. Importez la classe CrawlingAPI, initialisez-la avec votre token JS et demandez l'URL du produit. Vérifier le code de statut avant l'analyse garde les échecs bruyants plutôt que silencieux.

from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 4000}
    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__":
    product_url = "https://www.amazon.com/dp/B0CHX3QBCH"
    html = crawl(product_url)
    print(html[:500] if html else "No HTML returned")

Les deux options d'attente comptent pour une galerie rendue côté client comme celle-ci. ajax_wait indique à l'API d'attendre la fin du chargement du contenu asynchrone, et page_wait patiente un nombre fixe de millisecondes après le chargement pour que les variantes d'images au rendu tardif apparaissent avant la capture de la page. Quatre secondes constituent un point de départ raisonnable ; augmentez la valeur si la galerie revient maigre. Le corps est décodé en latin1 parce que les pages Amazon mêlent des caractères sur lesquels un décodage UTF-8 strict peut buter. Exécutez le script et vous devriez voir un véritable balisage de produit, ce qui confirme que le rendu fonctionne avant d'écrire le moindre sélecteur.

Étape 2 : Extraire les URL d'images

Avec le HTML rendu en main, chargez-le dans BeautifulSoup et extrayez les liens d'images. Lisez l'image principale depuis #landingImage, puis collectez la galerie depuis la bande de miniatures sous #altImages. Amazon stocke les miniatures à une petite taille, vous réécrivez donc chaque URL de miniature vers sa forme en pleine résolution en retirant le jeton de taille qu'Amazon encode dans le nom de fichier.

import re
from bs4 import BeautifulSoup

def full_res(url):
    # Amazon encodes a size token like _SX466_ or _AC_US40_ into the
    # filename; dropping it returns the full-resolution image.
    return re.sub(r"\._[^.]+_\.", ".", url)

def extract_image_urls(html):
    soup = BeautifulSoup(html, "html.parser")
    urls = []

    main = soup.select_one("#landingImage, #imgTagWrapperId img")
    if main and main.get("src"):
        urls.append(full_res(main["src"]))

    for thumb in soup.select("#altImages img"):
        src = thumb.get("src")
        if src and "images/I/" in src:
            urls.append(full_res(src))

    # De-duplicate while preserving order.
    seen = set()
    unique = []
    for u in urls:
        if u not in seen:
            seen.add(u)
            unique.append(u)
    return unique

L'assistant full_res est l'étape clé. Amazon sert la même image à de nombreuses tailles en insérant un jeton tel que ._SX466_ ou ._AC_US40_ entre l'id de l'image et l'extension du fichier ; l'expression régulière retire ce jeton pour que vous conserviez le fichier original en pleine résolution au lieu d'une miniature. L'image principale provient de #landingImage, avec #imgTagWrapperId img en repli, et la galerie provient des images de miniatures sous #altImages. Filtrer sur images/I/ dans la source écarte les sprites et icônes d'Amazon qui ne sont pas des photos de produit, et la passe finale de déduplication écarte le cas où l'image principale apparaît aussi comme la première miniature.

Étape 3 : Télécharger chaque image dans un fichier local

Maintenant, transformez les URL en fichiers. Pour chaque URL d'image, demandez les octets et écrivez-les dans un dossier par produit, en dérivant le nom de fichier de l'id de l'image dans l'URL. Acheminer le téléchargement via la Crawling API le garde sur le même chemin d'IP de confiance que la récupération de la page, ce qui évite qu'une requête séparée depuis votre propre IP soit bloquée.

import os
from urllib.parse import urlparse

def download_images(urls, folder="amazon_images"):
    os.makedirs(folder, exist_ok=True)
    saved = []
    for i, url in enumerate(urls):
        name = os.path.basename(urlparse(url).path) or f"image_{i}.jpg"
        path = os.path.join(folder, name)
        response = api.get(url)
        if response["status_code"] == 200:
            with open(path, "wb") as f:
                f.write(response["body"])
            saved.append(path)
            print(f"Saved {path}")
        else:
            print(f"Skipped {url}: {response['status_code']}")
    return saved

La fonction crée le dossier de sortie une fois avec exist_ok=True pour qu'une réexécution ne provoque pas d'erreur, puis parcourt la liste d'URL. Le nom de fichier provient du dernier segment de chemin de l'URL, qui pour Amazon est l'id unique de l'image, de sorte que deux photos différentes de la galerie n'entrent jamais en collision sur le disque. Chaque image est écrite en mode binaire, et une réponse non 200 est signalée et ignorée plutôt que de faire planter l'exécution. Comme la requête repasse par api.get, la récupération de l'image réutilise le même chemin d'IP de confiance que la récupération de la page.

Étape 4 : Tout assembler

Maintenant, câblez la récupération, l'extraction et le téléchargement dans un seul script exécutable.

import os
import re
import json
from urllib.parse import urlparse
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 4000}
    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 full_res(url):
    return re.sub(r"\._[^.]+_\.", ".", url)

def extract_image_urls(html):
    soup = BeautifulSoup(html, "html.parser")
    urls = []
    main = soup.select_one("#landingImage, #imgTagWrapperId img")
    if main and main.get("src"):
        urls.append(full_res(main["src"]))
    for thumb in soup.select("#altImages img"):
        src = thumb.get("src")
        if src and "images/I/" in src:
            urls.append(full_res(src))
    seen, unique = set(), []
    for u in urls:
        if u not in seen:
            seen.add(u)
            unique.append(u)
    return unique

def download_images(urls, folder="amazon_images"):
    os.makedirs(folder, exist_ok=True)
    saved = []
    for i, url in enumerate(urls):
        name = os.path.basename(urlparse(url).path) or f"image_{i}.jpg"
        path = os.path.join(folder, name)
        response = api.get(url)
        if response["status_code"] == 200:
            with open(path, "wb") as f:
                f.write(response["body"])
            saved.append(path)
            print(f"Saved {path}")
    return saved

def main():
    product_url = "https://www.amazon.com/dp/B0CHX3QBCH"
    html = crawl(product_url)
    if not html:
        return
    urls = extract_image_urls(html)
    print(json.dumps(urls, indent=2))
    download_images(urls)

if __name__ == "__main__":
    main()

Enregistrez ceci sous amazon_images.py, insérez votre token et exécutez python amazon_images.py. Le script affiche la liste des URL d'images en pleine résolution, puis télécharge chacune dans un dossier amazon_images à côté du script. Si vous scrapez aussi les champs produit structurés (titre, prix, ASIN, et ainsi de suite), le guide compagnon sur comment scraper les données produit d'Amazon étend cette même récupération en un enregistrement complet.

À quoi ressemble la sortie

La liste affichée est l'ensemble des URL d'images que l'analyseur a trouvées, dans l'ordre de la galerie, et le dossier se remplit d'un fichier par URL.

[
  "https://m.media-amazon.com/images/I/71xKDtMfaZL.jpg",
  "https://m.media-amazon.com/images/I/61hr19MzN3L.jpg",
  "https://m.media-amazon.com/images/I/71f7tsamQ4L.jpg",
  "https://m.media-amazon.com/images/I/81Qj0nFLanL.jpg"
]

Sur le disque, vous obtenez les fichiers correspondants, chacun nommé par son id d'image :

amazon_images/
  71xKDtMfaZL.jpg
  61hr19MzN3L.jpg
  71f7tamQ4L.jpg
  81Qj0nFLanL.jpg

Passer à l'échelle de nombreux produits

Un produit est une démo ; un vrai travail s'exécute sur une liste de produits. Comme chaque étape est une fonction simple, vous passez à l'échelle en bouclant sur une liste d'URL de produits et en donnant à chacune son propre dossier de sortie pour que les fichiers ne se mélangent jamais. Cadencez la boucle avec un court délai pour ne pas marteler Amazon dans un cycle serré, ce qui est le moyen le plus rapide de se faire limiter.

import time

def scrape_many(product_urls):
    for url in product_urls:
        asin = url.rstrip("/").split("/")[-1]
        html = crawl(url)
        if not html:
            continue
        urls = extract_image_urls(html)
        download_images(urls, folder=f"amazon_images/{asin}")
        print(f"{asin}: {len(urls)} images")
        time.sleep(2)

Chaque produit obtient un dossier nommé par son ASIN, le dernier segment de chemin d'une URL /dp/ASIN, de sorte qu'un lot de produits reste proprement séparé sur le disque. Le time.sleep(2) entre les produits cadence l'exécution. Pour dériver et valider cet ASIN à partir de n'importe quelle URL Amazon, le guide sur comment trouver et scraper l'ASIN Amazon va plus en profondeur.

Rester débloqué

Même avec le rendu pris en charge, Amazon surveille le trafic en forme de scraper. Quelques habitudes maintiennent une exécution saine, et elles s'appliquent à toute cible commerciale difficile.

• Espacez vos requêtes. Répartissez les requêtes avec un délai entre les produits et évitez de scraper la même fiche dans une boucle serrée. Le time.sleep dans la boucle de lot est le plancher, pas le plafond.
• Appuyez-vous sur la rotation. Un pool d'IP résidentielles répartit les requêtes sur de nombreuses adresses de vrais utilisateurs pour qu'aucune seule ne déclenche une limite de débit. La Crawling API s'en charge pour vous ; si vous montez votre propre pile, c'est la partie à réussir.
• Lisez les codes de statut. Une exécution qui se met à renvoyer des défis ou des erreurs vous indique que le débit actuel ou le palier d'IP ne suffit plus. Traitez cela comme un signal pour lever le pied, pas comme du bruit à ignorer.

Pour le manuel plus large, voyez le guide sur comment scraper des sites web sans se faire bloquer. Le même motif récupération-puis-téléchargement fonctionne aussi sur d'autres sites riches en images ; le tutoriel compagnon sur le scraping d'images depuis DeviantArt l'applique à une disposition de galerie très différente.

Est-il légal de scraper les images d'Amazon ?

Que le téléchargement des images d'Amazon soit autorisé dépend des conditions d'utilisation d'Amazon, de votre juridiction et de ce que vous faites des images. Les Conditions d'utilisation d'Amazon restreignent l'accès automatisé et posent des limites claires sur la réutilisation de son contenu, donc le scraping peut aller à l'encontre de ces conditions, quelle que soit la prudence de votre outillage. Aucun code ici ne change cela ; il fait simplement fonctionner la partie technique. Lisez les Conditions d'utilisation d'Amazon et son robots.txt, et traitez les deux comme la limite de ce que vous collectez.

Le point le plus important est l'usage en aval. Les images de produits sur Amazon sont presque toujours protégées par le droit d'auteur, détenues par la marque, le vendeur ou le photographe, pas par vous et pas par Amazon pour les concéder en licence à votre tour. Collecter des images publiques pour analyse est une chose : les alimenter dans la classification d'images, constituer une référence de catalogue interne, ou comparer des variantes entre fiches. Redistribuer ou republier ces images, les faire passer pour les vôtres, ou les réutiliser dans votre propre boutique est une tout autre affaire et peut enfreindre le droit d'auteur. Ne redistribuez pas les images de produits protégées par le droit d'auteur, et ne retirez ni n'altérez les filigranes. En cas de doute, obtenez l'autorisation du titulaire des droits.

Ce guide est délibérément limité aux images de produits publiques, car c'est la ligne qui maintient le travail défendable. Il ne couvre rien derrière une connexion, les données de compte ou de commande, les informations personnelles, ni aucune tentative de contourner l'authentification. Pour un accès sous licence ou en masse, Amazon propose la Product Advertising API et des programmes pour vendeurs, et c'est le bon outil quand vous avez besoin de grands volumes, d'une structure garantie ou de droits commerciaux sur les médias. Si votre projet a besoin de plus que des images publiques pour votre propre analyse, une API officielle ou un accord direct avec le titulaire des droits est le bon chemin, pas un scraper plus astucieux.

Foire aux questions

Pourquoi une simple requête renvoie-t-elle une galerie basse résolution ou incomplète ?

Parce qu'Amazon remplit les variantes d'images haute résolution et la correspondance des miniatures avec JavaScript après le chargement du HTML initial. Une requête HTTP brute voit la page avant l'exécution de ces scripts, donc elle obtient souvent un substitut ou un ensemble partiel. Rendre la page d'abord, ce que fait le token JS de la Crawling API, vous donne la galerie complète avant que vous ne l'analysiez.

Comment obtenir l'image en pleine résolution plutôt qu'une miniature ?

Amazon encode la taille demandée dans le nom de fichier avec un jeton comme ._SX466_ ou ._AC_US40_ entre l'id de l'image et l'extension. Retirer ce jeton avec une petite expression régulière renvoie le fichier original en pleine résolution. L'assistant full_res de ce guide fait exactement cela pour l'image principale et chaque miniature.

Quels sélecteurs contiennent les images de produit Amazon ?

L'image principale se trouve à #landingImage (également accessible via #imgTagWrapperId img), et les vues alternatives, lifestyle et infographies proviennent de la bande de miniatures sous #altImages. Filtrer sur images/I/ dans la source écarte les sprites et les icônes. Ces ids sont durables mais pas permanents, alors réinspectez la page en direct si la liste revient vide.

Puis-je scraper les images d'Amazon sans me faire bloquer ?

Gardez un débit de requêtes faible, ajoutez un délai entre les produits, et acheminez via des IP résidentielles rotatives pour qu'aucune seule adresse ne déclenche une limite de débit. La Crawling API gère la rotation et un pool d'IP de confiance pour vous ; si vous construisez votre propre pile, c'est la partie dans laquelle investir. Surveillez les codes de statut et levez le pied dès que vous commencez à voir des défis.

Est-il légal de télécharger des images depuis Amazon ?

Collecter des images de produits publiques pour votre propre analyse est généralement à faible risque, mais les images elles-mêmes sont généralement protégées par le droit d'auteur de la marque, du vendeur ou du photographe. Les redistribuer, les republier ou les réutiliser commercialement peut enfreindre ce droit d'auteur, et l'accès automatisé peut aller à l'encontre des conditions d'Amazon de toute façon. Lisez les Conditions d'utilisation d'Amazon et le robots.txt, ne redistribuez pas les images protégées par le droit d'auteur, et préférez la Product Advertising API officielle pour un accès sous licence.

Puis-je télécharger les images pour une liste entière de produits d'un coup ?

Oui. Comme chaque étape est une fonction simple, vous bouclez sur une liste d'URL de produits, donnez à chacune son propre dossier nommé par son ASIN pour que les fichiers ne se mélangent pas, et ajoutez un court délai entre les produits pour cadencer l'exécution. L'assistant scrape_many de ce guide est un point de départ fonctionnel pour ce travail par lot.

SR

Sidrah Ramzan

Rédactrice de contenu technique · Crawlbase

Rédactrice de contenu technique chez Crawlbase, elle couvre les proxys résidentiels et mobiles, la rotation et comment choisir un réseau qui tient sous une vraie charge de scraping.