Comment extraire des données de l'Apple App Storenotes, avis et métadonnées

L'Apple App Store contient des millions de fiches d'applications, et chaque fiche publique contient le type de détails structurés qui intéressent les équipes produit, les marketeurs et les analystes : le nom de l'application, son développeur, la note en étoiles, le nombre d'avis, la catégorie dans laquelle elle se trouve et le prix. Collecter ces données manuellement ne passe pas à l'échelle au-delà d'une poignée d'applications, donc la démarche pratique est de créer un extracteur App Store en Python qui récupère une page de fiche, parse les champs voulus et vous fournit un enregistrement propre.

Ce guide vous explique exactement comment faire. Vous allez récupérer des pages de fiches App Store rendues via la Crawling API en utilisant le client Python officiel crawlbase, parser le markup avec BeautifulSoup, et extraire une ligne structurée pour chaque application. Nous limitons l'ensemble de ce guide aux données de fiches publiques, et la section légalité vers la fin n'est pas du remplissage, alors lisez-la avant de pointer cet outil vers un volume réel.

Ce que vous allez construire

Un script Python qui prend une URL publique d'application App Store, récupère le HTML rendu via la Crawling API, et extrait un enregistrement structuré. Nous utiliserons une application gratuite bien connue comme exemple courant et extrairons ces champs :

• Nom de l'application le titre de la fiche, par exemple "Microsoft Authenticator".
• Développeur l'éditeur ou le vendeur, comme "Microsoft Corporation".
• Note la note moyenne en étoiles, comme "4.8".
• Nombre d'avis le nombre de notes derrière ce score.
• Catégorie la catégorie App Store dans laquelle l'application est classée.
• Prix le prix affiché, ou "Free" quand il n'y en a pas.

Pourquoi une simple requête échoue sur l'App Store

Si vous demandez une URL de fiche App Store avec un client HTTP basique, vous rencontrez deux problèmes. Premièrement, la page de fiche s'appuie sur JavaScript pour remplir certaines parties de son contenu, donc le HTML brut que vous obtenez peut manquer les champs recherchés. Deuxièmement, Apple surveille le trafic automatisé : les adresses IP de datacenters et les schémas de requêtes qui ne ressemblent pas à un vrai navigateur sont challengés ou limités avant d'atteindre le markup utile.

Un extracteur App Store fonctionnel a donc besoin de deux choses en une seule requête : un navigateur qui rend réellement la page, et une adresse IP que la plateforme identifie comme un vrai visiteur. Vous pouvez assembler cela vous-même avec un navigateur headless plus un pool de proxies résidentiels rotatifs, mais assembler ces éléments et les maintenir en bonne santé représente la majorité du travail. La Crawling API regroupe les deux en un seul appel : vous lui envoyez l'URL, elle rend la page derrière une IP fiable, et elle retourne du HTML fini à parser.

Prérequis

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

Python de base. Vous devez être à l'aise pour écrire et exécuter un script Python et installer des packages avec pip. Si vous êtes nouveau dans le langage, la documentation officielle Python et n'importe quel cours pour débutants vous amèneront au niveau que ce tutoriel suppose.

Python 3.8 ou plus récent. 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 et un token Crawlbase. Inscrivez-vous, ouvrez votre tableau de bord et copiez votre token depuis la page de documentation du compte. Utilisez le token JavaScript (JS) pour les fiches App Store. 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 deux bibliothèques dont l'extracteur a besoin.

python --version

python -m venv appstore_env
source appstore_env/bin/activate

pip install crawlbase beautifulsoup4

Sur Windows, activez l'environnement avec appstore_env\Scripts\activate au lieu de la ligne source. Deux dépendances font le travail : crawlbase est le client officiel pour la Crawling API, et beautifulsoup4 parse le HTML retourné pour que vous puissiez extraire des champs individuels par sélecteur CSS. Si vous voulez un rappel sur la bibliothèque de parsing, le guide BeautifulSoup en Python couvre les sélecteurs utilisés ci-dessous.

Étape 1 : Récupérer la fiche rendue

Commencez par obtenir la page finie. Importez la classe CrawlingAPI, initialisez-la avec votre token et demandez l'URL de l'application. Vérifier le code de statut avant de parser maintient les échecs visibles au lieu de les masquer.

from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_JS_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("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

if __name__ == "__main__":
    page_url = "https://apps.apple.com/us/app/microsoft-authenticator/id983156458"
    html = crawl(page_url)
    print(html[:500] if html else "No HTML returned")

Les deux options d'attente aident avec les éléments qui se rendent tardivement. ajax_wait indique à l'API d'attendre que le contenu asynchrone finisse de se charger, et page_wait attend un nombre fixe de millisecondes après le chargement pour que les parties à rendu tardif apparaissent avant que la page soit capturée. Trois secondes est un bon point de départ ; augmentez si des champs reviennent vides. Exécutez le script avec python scraper.py et vous devriez voir le vrai markup de la fiche, pas une coquille appauvrie. Cela confirme que le rendu fonctionne avant d'écrire un seul sélecteur.

Étape 2 : Parser les champs de l'application avec BeautifulSoup

Avec le HTML rendu en main, chargez-le dans BeautifulSoup et extrayez chaque champ par son sélecteur. Les fiches App Store présentent les détails essentiels dans une structure prévisible, vous pouvez donc mapper le nom, le développeur, la note, le nombre d'avis, la catégorie et le prix à des sélecteurs individuels. Encapsulez l'extraction dans des helpers pour qu'un champ manquant ne plante pas l'exécution.

from bs4 import BeautifulSoup

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

def scrape_app(html):
    soup = BeautifulSoup(html, "html.parser")

    rating_text = text_of(soup, ".we-rating-count.star-rating__count")
    stars, reviews = (rating_text.split(" • ") + [None, None])[:2] if rating_text else (None, None)

    return {
        "name": text_of(soup, ".product-header__title"),
        "developer": text_of(soup, ".product-header__identity a"),
        "rating": stars,
        "review_count": reviews,
        "category": text_of(soup, ".information-list__item__term:-soup-contains('Category') + dd a"),
        "price": text_of(soup, ".app-header__list__item--price"),
    }

Le helper text_of fait deux choses utiles à la fois : il interroge un seul élément et retourne None quand l'élément est absent, au lieu de planter sur un appel .get_text() sur rien. Cela rend l'extraction résistante quand un champ est absent d'une fiche donnée. La chaîne de note sur l'App Store regroupe à la fois le score en étoiles et le nombre d'avis dans une valeur séparée par une puce, donc nous la divisons une fois et attribuons les deux parties, avec None par défaut quand le format ne correspond pas.

Étape 3 : Tout assembler

Maintenant, reliez la récupération et le parsing en un seul script exécutable. Récupérez le HTML rendu, transmettez-le au parser et affichez l'enregistrement structuré.

import json
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_JS_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("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

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

def scrape_app(html):
    soup = BeautifulSoup(html, "html.parser")
    rating_text = text_of(soup, ".we-rating-count.star-rating__count")
    stars, reviews = (rating_text.split(" • ") + [None, None])[:2] if rating_text else (None, None)

    return {
        "name": text_of(soup, ".product-header__title"),
        "developer": text_of(soup, ".product-header__identity a"),
        "rating": stars,
        "review_count": reviews,
        "category": text_of(soup, ".information-list__item__term:-soup-contains('Category') + dd a"),
        "price": text_of(soup, ".app-header__list__item--price"),
    }

def main():
    page_url = "https://apps.apple.com/us/app/microsoft-authenticator/id983156458"
    html = crawl(page_url)
    if not html:
        return
    data = scrape_app(html)
    print(json.dumps(data, indent=2))

if __name__ == "__main__":
    main()

À quoi ressemble la sortie

Exécutez le script complet avec python scraper.py et vous obtenez un enregistrement structuré propre pour l'application, prêt à écrire en JSON, CSV ou dans une base de données.

{
  "name": "Microsoft Authenticator",
  "developer": "Microsoft Corporation",
  "rating": "4.8",
  "review_count": "339.5K Ratings",
  "category": "Productivity",
  "price": "Free"
}

Mise à l'échelle vers de nombreuses applications

Une seule fiche est une démonstration ; un vrai travail s'exécute sur une liste d'applications. La forme reste la même : gardez une liste d'URLs d'applications, récupérez chacune via la Crawling API, parsez-la avec la même fonction, et collectez les lignes. Parce que chaque fiche partage la même structure, le parser que vous avez déjà écrit fonctionne pour toutes sans modifications. Le détail qui compte à volume est le cadrage : espacez les requêtes pour ressembler à un flux de visiteurs normaux plutôt qu'à une boucle serrée.

import time

apps = [
    "https://apps.apple.com/us/app/microsoft-authenticator/id983156458",
    "https://apps.apple.com/us/app/google-authenticator/id388497605",
]

results = []
for url in apps:
    html = crawl(url)
    if html:
        results.append(scrape_app(html))
    time.sleep(2)

with open("apps.json", "w") as f:
    json.dump(results, f, indent=2)

L'appel time.sleep entre les requêtes est délibéré. Même si la Crawling API fait tourner les IPs pour vous, le cadrage maintient votre exécution polie et prévisible, et donne à chaque page rendue le temps de revenir sans empiler des requêtes les unes sur les autres. Si vous voulez aussi capturer les avis par application, le même schéma récupération-puis-parsing s'étend à la section des avis ; le guide pour extraire les avis clients couvre ce schéma plus en détail.

Données d'applications structurées sans scraping

Scraper la page de fiche publique est le bon outil quand vous avez besoin exactement de ce qu'un visiteur voit et qu'il n'existe pas d'API qui le retourne. Mais pour les métadonnées structurées simples d'applications, Apple propose des canaux officiels plus propres et plus stables que le parsing de markup, et vous devriez les préférer quand ils couvrent votre besoin.

• iTunes Search API et flux RSS de l'App Store. L'API publique iTunes Search d'Apple retourne les détails des applications (nom, développeur, note moyenne, nombre de notes, catégorie, prix, et plus) en JSON, et les flux RSS de l'App Store publient des listes classées des meilleures applications gratuites, payantes et tendances. Pour les métadonnées structurées au niveau de la fiche, ce sont les premières ressources à consulter.
• App Store Connect API. Si les applications sont les vôtres, l'App Store Connect API vous donne un accès en première partie à vos fiches, ventes et analyses sous votre compte développeur, sans aucun scraping.

Utilisez l'extracteur quand vous avez besoin de données que les flux officiels n'exposent pas, ou quand vous assemblez une vue sur de nombreuses fiches tierces. Pour tout ce que l'iTunes Search API et les flux RSS retournent déjà en JSON, utilisez-les en premier.

Rester non bloqué

Même avec le rendu géré, Apple surveille le trafic à l'aspect de scraper. Quelques habitudes gardent une exécution saine, et elles s'appliquent à toute cible commerciale difficile.

• Cadencez vos requêtes. Marteler des fiches dans une boucle serrée est le moyen le plus rapide d'être limité. Espacez les requêtes et variez vos cibles au lieu de crawler un seul chemin à pleine vitesse.
• Misez sur la rotation. Un pool d'IPs résidentielles répartit les requêtes sur de nombreuses adresses d'utilisateurs réels pour qu'aucune seule 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.
• Lisez les codes de statut. Une exécution qui commence à retourner des challenges ou des erreurs vous dit que le débit actuel ou le niveau d'IP n'est plus suffisant. Traitez cela comme un signal pour reculer, pas comme du bruit à ignorer.

Pour le playbook complet, consultez la plongée approfondie sur comment contourner les CAPTCHA lors du scraping web et le guide pour scraper des pages JavaScript avec Python. Si vous préférez router votre propre trafic via un pool rotatif plutôt que d'utiliser l'API gérée, le Smart AI Proxy (aussi appelé AI Proxy) vous offre la même rotation d'IPs résidentielles comme endpoint proxy drop-in.

Est-il légal de scraper l'App Store ?

Le fait que le scraping de l'App Store soit autorisé dépend des conditions d'utilisation d'Apple, de votre juridiction et de ce que vous faites avec les données. Les conditions d'Apple restreignent l'accès automatisé, donc le scraping peut aller à l'encontre de ces conditions, quelle que soit la prudence de votre outillage. Aucun des codes ici ne change cela ; ils font simplement fonctionner la partie technique. Lisez les Conditions d'utilisation d'Apple et le robots.txt de l'App Store, et traitez les deux comme la limite de ce que vous collectez.

Quelques lignes à respecter. Ne collectez que les données publiques des fiches : le nom de l'application, le développeur, la note, le nombre d'avis, la catégorie et le prix que tout le monde peut voir sans compte. Respectez les attentes déclarées d'Apple en matière de débit et gardez votre volume de requêtes suffisamment bas pour ne pas surcharger ses serveurs. Ce guide est délibérément limité aux pages de fiches publiques parce que c'est la ligne qui rend le travail défendable. Il ne couvre pas les données de compte ou personnelles, les pages derrière un login, ni toute tentative de contourner l'authentification. Ces sujets sont hors champ ici, et les atteindre va à l'encontre des conditions d'Apple.

Pour les données structurées d'applications, préférez les canaux officiels d'Apple. L'App Store Connect API donne un accès en première partie à vos propres applications, et la iTunes Search API publique et les flux RSS de l'App Store retournent les métadonnées des applications en JSON sans scraper une seule page. Quand un flux officiel couvre votre besoin, c'est le bon outil ; l'extracteur de ce guide est pour les données de fiches publiques que les flux n'exposent pas, rien de plus.

Foire aux questions

Pourquoi une simple récupération retourne-t-elle des données incomplètes de l'App Store ?

Parce que les fiches App Store rendent certaines parties de leur contenu côté client avec JavaScript. Une requête HTTP brute peut revenir avec la coquille de la page mais avec des champs manquants comme la note ou la catégorie, car ceux-ci ne se remplissent qu'après l'exécution des scripts de la page dans un navigateur. Le token JS de la Crawling API rend d'abord la page, donc les champs sont présents quand BeautifulSoup les parse.

Ai-je besoin du token normal ou du token JS pour l'App Store ?

Utilisez le token JS. Le token normal récupère du HTML statique, ce qui sur l'App Store peut laisser certains champs de fiches vides. Le token JS rend la page dans un vrai navigateur avant de retourner le HTML, donc le nom, le développeur, la note, le nombre d'avis, la catégorie et le prix sont présents quand vous parsez.

Apple dispose-t-il d'une API officielle pour les données d'applications ?

Oui. L'API publique iTunes Search retourne les détails des applications en JSON (nom, développeur, note moyenne, nombre de notes, catégorie, prix et plus), et les flux RSS de l'App Store publient des listes classées des meilleures applications. Pour vos propres applications, l'App Store Connect API donne un accès en première partie aux fiches et aux analyses. Préférez ces canaux officiels pour les métadonnées structurées, et utilisez le scraping uniquement quand vous avez besoin de données de fiches publiques que les flux n'exposent pas.

Mes sélecteurs retournent None. Qu'est-ce qui a changé ?

Presque certainement le markup d'Apple. Les marqueurs we-rating-count, les éléments product-header et les lignes de la liste d'informations changent sans préavis, donc les sélecteurs qui fonctionnaient le mois dernier peuvent être cassés. Ré-inspectez une fiche live dans les outils de développement de votre navigateur et mettez à jour les sélecteurs. La maintenance périodique des sélecteurs est normale pour tout extracteur en production.

Puis-je scraper les données de compte ou personnelles de l'App Store ?

Non, et ce guide ne le couvre pas. Les données de compte, l'historique des achats et tout ce qui est derrière un login ne sont pas des données publiques. Scraper du contenu protégé par connexion, ou contourner l'authentification pour y accéder, est hors champ ici et va à l'encontre des conditions d'Apple. Pour les données en première partie sur vos propres applications, l'App Store Connect API est la bonne voie.

Comment éviter d'être bloqué lors du scraping de l'App Store ?

Gardez votre débit de requêtes par IP bas, variez vos cibles au lieu de boucler sur un seul chemin, et routez via des IPs résidentielles rotatives pour qu'aucune adresse seule ne déclenche une limite de débit. La Crawling API gère la rotation et un pool d'IPs fiables pour vous ; si vous construisez votre propre stack, c'est la partie dans laquelle investir. Surveillez les codes de statut et reculez quand vous commencez à voir des challenges.

HI

Hamza Ikhlaq

Développeur logiciel · Crawlbase

Développeur logiciel chez Crawlbase, il rédige des guides pratiques sur le scraping de sites cibles, les proxys et la Crawling API.