Comment scraper les données d'audiolivres Audibleconstruire une mini bibliothèque d'audiolivres

Audible est le service d'audiolivres d'Amazon, et son catalogue public compte des centaines de milliers de titres couvrant tous les genres, chacun répertorié avec son auteur, son narrateur, sa durée, sa note et son prix. Ces pages de recherche et de catégorie sont l'une des vues les plus claires du marché des audiolivres sur le web ouvert, ce pourquoi des analystes, des bibliothécaires et des passionnés les parcourent pour suivre les prix, constituer des listes de lecture et étudier ce qui se vend.

Ce guide vous montre comment scraper des données d'audiolivres Audible avec Python et assembler les résultats dans un petit fichier de « mini bibliothèque ». Vous construisez un scraper fonctionnel qui récupère une page de recherche ou de catégorie Audible via la Crawling API, parse un enregistrement propre par audiolivre, gère la pagination et exporte l'ensemble en JSON et CSV. L'ensemble du guide reste limité aux données de catalogue public : les titres, auteurs, narrateurs, durées, notes et prix que tout le monde peut voir sur une page de résultats sans se connecter. Il ne touche jamais l'audio lui-même.

Ce que vous allez construire

Un script Python qui prend une URL de recherche ou de catégorie Audible, récupère la liste rendue via la Crawling API et extrait un enregistrement structuré par audiolivre. Nous utilisons une page de résultats de catégorie comme exemple courant et extrayons ces champs de chaque fiche produit :

• Titre le nom de l'audiolivre tel qu'il apparaît sur la fiche de listing.
• Auteur l'écrivain crédité sur le titre, « By: ... » sur la fiche.
• Narrateur l'interprète vocal, « Narrated by: ... » sur la fiche.
• Durée la durée totale, par exemple « 10 hrs and 32 mins ».
• Note la note moyenne en étoiles quand le titre en a une.
• Prix le prix affiché, quand la fiche en montre un.
• Lien l'URL vers la page de détail propre à l'audiolivre.

Pourquoi une requête simple échoue sur Audible

Si vous pointez un client HTTP nu vers une URL de résultats Audible, vous obtenez rarement le listing que vous cherchez. Deux choses jouent contre vous. Premièrement, Audible rend une grande partie de la grille de produits côté client : il envoie une coquille légère et remplit les fiches au fur et à mesure que le JavaScript de la page s'exécute, de sorte que le HTML initial manque souvent les durées, prix et notes que vous voulez. Deuxièmement, en tant que propriété Amazon, Audible signale rapidement le trafic automatisé. Les plages d'IP de datacenter et les patterns de requêtes qui ne ressemblent pas à un vrai navigateur sont accueillis par un CAPTCHA, un interstitiel de « vérification robot » ou un blocage pur et simple avant que vous n'atteigniez la liste.

Un scraper Audible fonctionnel a donc besoin de deux choses en une requête : un navigateur qui rend la page, et une IP qu'Audible lit comme un vrai visiteur. Vous pouvez assembler cela vous-même avec un navigateur headless et un pool de proxies résidentiels rotatifs, mais maintenir cette stack en bonne santé représente l'essentiel du travail. La Crawling API regroupe les deux en un seul appel : vous lui envoyez l'URL des résultats, elle rend la page derrière une IP résidentielle de confiance, gère la rotation et la résolution des CAPTCHA, et retourne le HTML terminé pour que vous le parsiez.

Prérequis

Vous avez besoin de quelques éléments en place avant d'écrire du code. Aucun ne prend longtemps.

Python basique. Vous devez être à l'aise pour écrire et exécuter un script Python et installer des packages avec pip. Si vous êtes novice dans le langage, la documentation officielle Python ou n'importe quel cours débutant couvre le niveau que ce tutoriel suppose.

Python 3.8 ou ultérieur. Confirmez votre version avec python --version (ou python3 --version). Si vous ne l'avez pas, installez-le depuis python.org et assurez-vous que Python figure dans le PATH de votre système.

Un compte Crawlbase et un token. Inscrivez-vous pour un compte gratuit, ouvrez votre dashboard et copiez votre token. Le forfait gratuit inclut jusqu'à 20 000 requêtes sans carte de crédit, ce qui est largement suffisant pour construire et tester ce scraper. Traitez le token comme un mot de passe et gardez-le hors du contrôle de version.

Mettre en place le projet

Créez un environnement virtuel pour que les dépendances du projet restent isolées, puis installez les deux bibliothèques dont le scraper a besoin. crawlbase est le client officiel pour la Crawling API, et beautifulsoup4 parse le HTML retourné pour que vous puissiez extraire chaque champ des fiches de listing par sélecteur CSS.

python --version

python -m venv audible_env
source audible_env/bin/activate

pip install crawlbase beautifulsoup4

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

touch audible_library.py

Comprendre la page de résultats Audible

Audible organise son catalogue comme une bibliothèque, avec des catégories qui se chevauchent et auxquelles un titre peut appartenir à plusieurs en même temps. Chaque catégorie et chaque recherche se trouve à une URL stable, par exemple https://www.audible.com/search?node=18573211011 pour un noeud de catégorie ou https://www.audible.com/search?keywords=science+fiction pour une recherche par mot-clé. Les deux rendent le même type de grille de résultats : une liste ordonnée de fiches produits, une par audiolivre, chacune portant un titre, une ligne d'auteur, une ligne de narrateur, une durée, une note et un prix.

Avant d'écrire des sélecteurs, ouvrez une page de résultats dans votre navigateur, faites un clic droit sur une fiche produit et choisissez Inspecter. Audible enveloppe chaque résultat dans un élément de liste marqué li.productListItem, met le titre dans un lien h3.bc-heading, et étiquette les lignes d'auteur et de narrateur avec li.authorLabel et li.narratorLabel. La durée se trouve dans li.runtimeLabel et la note dans li.ratingsLabel. Ce sont les éléments que vous ciblez. Les noms de classes utilitaires d'Audible changent dans le temps, donc appuyez-vous sur les classes d'étiquette plus durables plutôt que sur une chaîne fragile de noms générés.

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

Commencez par obtenir la page terminée. Importez la classe CrawlingAPI, initialisez-la avec votre token, définissez l'URL des résultats et demandez-la. Vérifier le code de statut avant de parser 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__":
    results_url = "https://www.audible.com/search?keywords=science+fiction"
    html = crawl(results_url)
    print(html[:500] if html else "No HTML returned")

Les deux options d'attente comptent pour une grille qui se remplit au chargement de la page. ajax_wait indique à l'API d'attendre que le contenu asynchrone se termine, et page_wait maintient un nombre fixe de millisecondes après le chargement pour que les fiches à rendu tardif apparaissent avant que la page ne soit capturée. Le corps est décodé en latin1 car les pages Audible mélangent des caractères qui peuvent faire échouer un décodage UTF-8 strict. Exécutez le script et vous devriez voir un vrai balisage de listing, pas une coquille de vérification robot. Cela confirme que le rendu fonctionne avant d'écrire un seul sélecteur.

Étape 2 : Parser les fiches d'audiolivres avec BeautifulSoup

Avec du HTML rendu en main, chargez-le dans BeautifulSoup, trouvez chaque fiche produit et extrayez chaque champ par son sélecteur. Audible enveloppe chaque résultat dans li.productListItem, met le titre dans le lien de titre, et étiquette les lignes d'auteur, narrateur, durée et note avec leurs propres classes. Lisez le lien de la page de détail depuis l'ancre du titre. Enveloppez chaque fiche dans un try/except pour qu'un listing malformé ne fasse pas planter l'exécution.

from bs4 import BeautifulSoup

BASE = "https://www.audible.com"

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

def strip_label(value, label):
    if value and value.startswith(label):
        return value[len(label):].strip()
    return value

def parse_link(card):
    a = card.select_one("h3.bc-heading a[href]")
    if not a:
        return None
    href = a["href"].split("?")[0]
    return href if href.startswith("http") else BASE + href

def scrape_audiobooks(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select("li.productListItem")
    results = []
    for card in cards:
        try:
            author = text_of(card, "li.authorLabel")
            narrator = text_of(card, "li.narratorLabel")
            results.append({
                "title": text_of(card, "h3.bc-heading a"),
                "author": strip_label(author, "By:"),
                "narrator": strip_label(narrator, "Narrated by:"),
                "length": strip_label(text_of(card, "li.runtimeLabel"), "Length:"),
                "rating": text_of(card, "li.ratingsLabel span.bc-text"),
                "price": text_of(card, "p.buybox-regular-price span.bc-text"),
                "link": parse_link(card),
            })
        except Exception as e:
            print(f"Skipped a card: {e}")
    return results

Le helper text_of interroge un élément dans une fiche et retourne None quand il est absent, au lieu de lancer une exception sur un appel .get_text() contre rien. Cela garde l'extraction résiliente quand un champ est absent, ce qui est courant puisque tous les titres n'affichent pas un prix ou une note. Le helper strip_label supprime les préfixes By:, Narrated by: et Length: qu'Audible imprime dans ces lignes d'étiquette pour que vous stockiez des valeurs propres. Le lien est lu depuis l'ancre du titre, sa chaîne de requête est supprimée, et il est normalisé en URL absolue puisqu'Audible sert un href relatif.

Étape 3 : Gérer la pagination, assembler et exporter

Une page de résultats est une démo ; une vraie mini bibliothèque s'étend sur toute la catégorie. Audible pagine ses pages de recherche et de catégorie avec un paramètre ?page=, donc vous parcourez les pages dans l'ordre, parsez chacune et arrêtez quand une page ne retourne aucune fiche. Ensuite, câblez la récupération et le parsing dans un seul script fonctionnel et écrivez les enregistrements en JSON et CSV pour pouvoir les charger dans un notebook ou un tableur.

import csv
import json
import time
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})
BASE = "https://www.audible.com"
FIELDS = ["title", "author", "narrator", "length", "rating", "price", "link"]

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 text_of(card, selector):
    el = card.select_one(selector)
    return el.get_text(strip=True) if el else None

def strip_label(value, label):
    if value and value.startswith(label):
        return value[len(label):].strip()
    return value

def parse_link(card):
    a = card.select_one("h3.bc-heading a[href]")
    if not a:
        return None
    href = a["href"].split("?")[0]
    return href if href.startswith("http") else BASE + href

def scrape_audiobooks(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select("li.productListItem")
    results = []
    for card in cards:
        try:
            author = text_of(card, "li.authorLabel")
            narrator = text_of(card, "li.narratorLabel")
            results.append({
                "title": text_of(card, "h3.bc-heading a"),
                "author": strip_label(author, "By:"),
                "narrator": strip_label(narrator, "Narrated by:"),
                "length": strip_label(text_of(card, "li.runtimeLabel"), "Length:"),
                "rating": text_of(card, "li.ratingsLabel span.bc-text"),
                "price": text_of(card, "p.buybox-regular-price span.bc-text"),
                "link": parse_link(card),
            })
        except Exception as e:
            print(f"Skipped a card: {e}")
    return results

def build_library(search_url, max_pages=5):
    library = []
    for page in range(1, max_pages + 1):
        sep = "&" if "?" in search_url else "?"
        page_url = f"{search_url}{sep}page={page}"
        html = crawl(page_url)
        if not html:
            break
        found = scrape_audiobooks(html)
        if not found:
            break
        library.extend(found)
        print(f"Page {page}: {len(found)} audiobooks")
        time.sleep(2)
    return library

def export(rows, name="audible_library"):
    with open(f"{name}.json", "w", encoding="utf-8") as f:
        json.dump(rows, f, indent=2, ensure_ascii=False)
    with open(f"{name}.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=FIELDS)
        writer.writeheader()
        writer.writerows(rows)
    print(f"Saved {len(rows)} audiobooks to {name}.json and {name}.csv")

def main():
    url = "https://www.audible.com/search?keywords=science+fiction"
    library = build_library(url, max_pages=5)
    if library:
        export(library)

if __name__ == "__main__":
    main()

Exécutez le script complet avec python audible_library.py. Il parcourt jusqu'à cinq pages de résultats, parse une ligne par audiolivre, et écrit à la fois audible_library.json et audible_library.csv. L'arrêt sur résultats vides vous arrête tôt quand la catégorie manque de pages, le time.sleep(2) entre les requêtes rythme l'exécution pour ne pas être signalé pour du trafic rapide, et la liste FIELDS partagée garde l'ordre des colonnes CSV en phase avec les clés du dictionnaire pour que les deux exports ne divergent jamais.

À quoi ressemble la sortie

Vous obtenez une liste propre d'enregistrements d'audiolivres, dans l'ordre de listing, prêts à être écrits en JSON, CSV ou base de données. C'est votre mini bibliothèque.

[
  {
    "title": "Project Hail Mary",
    "author": "Andy Weir",
    "narrator": "Ray Porter",
    "length": "16 hrs and 10 mins",
    "rating": "4.9 out of 5 stars",
    "price": "$24.49",
    "link": "https://www.audible.com/pd/Project-Hail-Mary-Audiobook/B08G9PRS1K"
  },
  {
    "title": "Dune",
    "author": "Frank Herbert",
    "narrator": "Scott Brick, Orlagh Cassidy, Euan Morton",
    "length": "21 hrs and 2 mins",
    "rating": "4.6 out of 5 stars",
    "price": "$29.65",
    "link": "https://www.audible.com/pd/Dune-Audiobook/B002V1OF70"
  }
]

De là, la mini bibliothèque est à vous. Chargez le CSV dans un tableur pour trier par durée ou note, filtrez le JSON pour les titres en dessous d'un plafond de prix, ou alimentez l'ensemble dans une liste de recommandations. Comme chaque enregistrement porte le lien de la page de détail, vous pouvez faire un suivi plus tard et scraper la page d'un seul titre pour la description complète ou l'éditeur quand vous avez besoin de plus que les champs de listing.

Mise à l'échelle sur plusieurs catégories

Une recherche est un point de départ ; une bibliothèque plus complète couvre plusieurs catégories. Audible expose une page de résultats pour chaque noeud de catégorie et chaque recherche par mot-clé, chacune à sa propre URL, donc vous pouvez garder une carte de noms vers URLs et exécuter la même routine build_library sur chacune, en clé-isant la sortie par catégorie. Rythmez les requêtes avec le délai déjà dans la boucle, et limitez max_pages pour qu'une exécution large ne gonfle pas. Pour suivre les tendances de prix et de note dans le temps, exécutez le job selon un calendrier, horodatez chaque export et faites un diff des instantanés successifs pour voir ce qui a bougé. La même approche alimente tout projet de scraping e-commerce qui surveille un catalogue dans le temps.

Rester non bloqué

Même avec le rendu géré, Audible surveille le trafic à l'allure d'un scraper. Quelques bonnes pratiques gardent une exécution en bonne santé, et elles s'appliquent à toute cible commerciale difficile.

• Rythmez vos requêtes. Espacez les requêtes avec un délai entre pages et catégories plutôt que de tout crawler à pleine vitesse. Planifiez les jobs plus lourds pendant les heures creuses pour alléger la charge sur les serveurs d'Audible.
• Appuyez-vous sur la rotation. Un pool d'IP résidentielles répartit les requêtes sur de nombreuses adresses d'utilisateurs réels pour qu'aucune ne déclenche une limite de débit. La Crawling API gère cela pour vous ; si vous construisez votre propre stack, c'est la partie à bien faire.
• Ne conservez que ce dont vous avez besoin. Stockez les champs de catalogue que votre projet utilise et jetez le reste. Vérifiez vos sélecteurs périodiquement pour que le scraper suive les changements de balisage.

Pour le guide complet sur l'évitement des blocages, voir comment scraper des sites web sans être bloqué. Si vous voulez approfondir le côté parsing, le guide sur utiliser BeautifulSoup en Python couvre la bibliothèque en détail, et pour une cible de catalogue apparentée, le guide sur scraper les notes et commentaires Goodreads se marie naturellement avec un ensemble d'audiolivres.

Est-il légal de scraper Audible ?

Si le scraping d'Audible est autorisé dépend des Conditions d'utilisation d'Audible et d'Amazon, de votre juridiction et de ce que vous faites des données. Ces conditions restreignent l'accès automatisé, donc le scraping peut aller à leur encontre quelle que soit la prudence de vos outils. Aucun du code ici ne change cela ; il fait seulement fonctionner la partie technique. Lisez les Conditions d'utilisation d'Audible et son robots.txt, et traitez les deux comme la limite 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 le bon choix.

Quelques lignes à tenir. Ne collectez que des données de catalogue public : les titres, auteurs, narrateurs, durées, notes, prix et liens de listing que tout le monde peut voir sur une page de résultats sans compte. Ce guide ne touche jamais l'audio lui-même, qui est un contenu protégé par le droit d'auteur que vous n'avez pas le droit de télécharger ou de redistribuer, et il reste à l'écart de tout ce qui se trouve derrière une connexion, données de compte ou d'achat, et informations personnelles sur des auditeurs ou critiques identifiables. Gardez votre volume de requêtes suffisamment bas pour ne pas solliciter les serveurs d'Audible, et si vous prévoyez de réutiliser les données commercialement, obtenez une permission ou un accord officiel plutôt que de supposer que le silence est un consentement.

Ce guide est délibérément limité aux pages de recherche et de catégorie publiques parce que c'est la ligne qui rend le travail défendable. Pour un accès sous licence ou en masse, Amazon propose l'API Product Advertising et d'autres programmes officiels, et c'est le bon outil quand vous avez besoin de grands volumes, d'une structure garantie ou de droits commerciaux. Si votre projet a besoin de plus que des métadonnées de catalogue public, une API officielle ou un accord de données est le bon chemin, pas un scraper plus ingénieux, et c'est toujours le meilleur choix quand il en existe un.

Foire aux questions

Pourquoi une requête simple ne retourne-t-elle aucun audiolivre d'Audible ?

Deux raisons. Audible remplit une grande partie de la grille de produits côté client au chargement de la page, donc une requête brute obtient souvent une coquille manquant les durées, notes et prix. De plus, en tant que propriété Amazon, Audible 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 à travers elle.

Quels champs puis-je scraper depuis un listing Audible ?

Depuis une fiche de résultats de recherche ou de catégorie, vous pouvez extraire le titre, l'auteur, le narrateur, la durée totale, la note moyenne, le prix et le lien vers la page de détail de l'audiolivre. Ce sont les champs de listing publics. Si vous avez besoin de la description complète, de l'éditeur ou de la date de sortie, suivez le lien de chaque fiche et scrapez la page de détail individuelle, qui expose plus de métadonnées.

Comment scraper une catégorie Audible spécifique ?

Chaque catégorie et recherche a sa propre URL, par exemple /search?keywords=science+fiction pour une recherche par mot-clé ou /search?node=... pour un noeud de catégorie. Pointez le scraper vers l'URL que vous voulez. Pour couvrir plusieurs catégories, gardez une carte de noms vers URLs et bouclez dessus, en rythmant les requêtes avec un court délai.

Comment fonctionne la pagination sur Audible ?

Audible ajoute un paramètre ?page= (ou &page= quand l'URL a déjà une chaîne de requête) pour parcourir les pages de résultats. Le script incrémente le numéro de page, parse chaque page et s'arrête quand une page ne retourne aucune fiche produit, ce qui est le signal que vous avez atteint la fin de la catégorie.

Puis-je télécharger les audiolivres eux-mêmes ?

Non, et vous ne devriez pas essayer. Les fichiers audio sont du contenu protégé par le droit d'auteur lié aux comptes et achats Audible, et ce guide s'en tient délibérément à l'écart. Il ne collecte que les métadonnées de catalogue public, les titres, auteurs, narrateurs, durées, notes et prix qui apparaissent sur les pages de listing, jamais l'audio.

Comment éviter d'être bloqué en scrapant Audible ?

Gardez votre taux de requêtes par IP bas, ajoutez un délai entre pages et catégories, 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 stack, c'est là que vous devez investir. Surveillez les codes de statut et reculez quand vous commencez à voir des challenges.

BA

Bilal Ahmed

Ingénieur logiciel · Crawlbase

Ingénieur logiciel auteur de certains des articles les plus lus du blog Crawlbase, sur le web scraping, les proxys et l'outillage de données.