Comment crawler les données de l'Apple App Storeapplications, notes et avis avec Node

L'Apple App Store est l'un des plus grands catalogues publics de logiciels sur le web ouvert. Chaque page d'application contient un bloc cohérent de détails structurés : le nom de l'application, son créateur, la catégorie dans laquelle elle se trouve, sa note publique et son nombre d'évaluations, le prix et l'URL canonique. Les développeurs suivent ces données pour évaluer les concurrents, les analystes étudient les tendances par catégorie, et les équipes produit observent l'évolution des notes dans le temps. Tout cela se trouve sur la page produit publique dans une mise en page prévisible que n'importe qui peut ouvrir sans se connecter.

Ce guide vous montre comment crawler les données de l'Apple App Store avec JavaScript et Node.js en utilisant Cheerio. Vous construisez un petit scraper exécutable qui récupère une page d'application publique via la Crawling API, analyse les champs de métadonnées publiques, et exporte le résultat en JSON. L'ensemble du tutoriel se limite aux métadonnées publiques d'application. Il ne collecte ni ne profile des évaluateurs individuels, et la section légalité vers la fin n'est pas du remplissage, donc lisez-la avant de pointer ceci vers un volume réel.

Ce que vous allez construire

Un script Node.js qui prend une URL de produit App Store publique, récupère le HTML rendu via la Crawling API, et extrait un enregistrement structuré des métadonnées publiques de l'application. Nous utilisons Google Authenticator comme exemple courant et extrayons ces champs :

• Nom de l'application le titre du produit affiché en haut de la page.
• Développeur le nom du vendeur ou du studio qui publie l'application.
• Catégorie la catégorie App Store dans laquelle l'application est répertoriée, par exemple « Utilitaires ».
• Note la note moyenne publique en étoiles qu'Apple affiche pour l'application.
• Nombre d'évaluations le nombre public d'évaluations derrière cette moyenne.
• Prix le prix affiché, ou « Gratuit » quand l'application n'a pas de coût initial.
• URL de l'application l'URL canonique publique de la page produit.

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

Si vous demandez une URL de produit App Store avec un simple client HTTP, vous obtenez rarement du balisage utilisable en retour. Deux choses jouent contre vous. Premièrement, Apple rend une grande partie de la page produit dans le navigateur, donc le HTML initial est une coquille mince jusqu'à ce que les scripts de la page s'exécutent et peuplent les blocs d'en-tête, de notes et de métadonnées. Deuxièmement, l'App Store signale le trafic automatisé : les IPs de datacenter et les schémas de requêtes qui ne ressemblent pas à un vrai navigateur sont throttlés ou bloqués avant qu'ils n'atteignent le contenu rendu.

Ainsi, un scraper App Store fonctionnel a besoin de deux choses en une seule requête : un navigateur qui rend réellement la page, et une IP que la plateforme lit comme un vrai visiteur. Vous pouvez assembler cela vous-même avec un navigateur sans interface plus un pool de proxies résidentiels tournants, mais assembler ces éléments et les maintenir en bonne santé représente l'essentiel 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 de confiance, et vous renvoie le HTML fini à analyser avec Cheerio.

Prérequis

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

JavaScript et Node.js de base. Vous devez être à l'aise pour écrire et exécuter un script Node et installer des packages avec npm. Si vous êtes nouveau sur Node, la documentation officielle et n'importe quel cours débutant vous amèneront au niveau que ce tutoriel suppose. Pour un tutoriel plus complet, notre guide sur la construction d'un scraper web avec Node.js couvre les bases.

Node.js 16 ou version ultérieure. Confirmez votre version avec node --version. Si vous ne l'avez pas, installez-le depuis le site Node.js ou via un gestionnaire de versions comme nvm.

Un compte Crawlbase et un token. Inscrivez-vous, ouvrez votre tableau de bord et copiez votre token JavaScript depuis la page de documentation du compte. Le forfait gratuit vous donne jusqu'à 20 000 requêtes sans carte, et vous ne payez que pour les requêtes réussies. 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 dossier de projet, initialisez-le, et installez les deux bibliothèques dont le scraper a besoin.

node --version

mkdir appstore-scraper && cd appstore-scraper
npm init -y

npm install crawlbase cheerio

Deux dépendances font le travail : crawlbase est le client Node officiel pour la Crawling API, et cheerio analyse le HTML renvoyé avec une API de style jQuery pour que vous puissiez extraire des champs individuels par sélecteur CSS. Créez un fichier nommé scraper.js dans ce dossier et ajoutez le code des étapes ci-dessous.

Étape 1 : Récupérer la page d'application rendue

Commencez par obtenir la page finie. Importez la classe CrawlingAPI, initialisez-la avec votre token JavaScript, et demandez une URL de produit App Store publique. Vérifier le code de statut avant d'analyser rend les échecs bruyants plutôt que silencieux.

const { CrawlingAPI } = require('crawlbase');

const api = new CrawlingAPI({ token: 'YOUR_CRAWLBASE_TOKEN' });

const appURL =
  'https://apps.apple.com/us/app/google-authenticator/id388497605';

api
  .get(appURL)
  .then((response) => {
    if (response.statusCode === 200) {
      console.log(response.body.slice(0, 500));
    }
  })
  .catch((error) => console.error('API request error:', error));

Exécutez le script avec node scraper.js et vous devriez voir du vrai balisage produit App Store en haut du corps, pas une coquille allégée. Cela confirme que le rendu fonctionne avant d'écrire un seul sélecteur. La Crawling API utilise le token JavaScript que vous avez fourni pour rendre la page dans un vrai navigateur, de sorte que les blocs d'en-tête, de notes et de métadonnées sont présents dans le HTML que vous récupérez.

Étape 2 : Analyser les métadonnées publiques avec Cheerio

Avec le HTML rendu en main, chargez-le dans Cheerio et lisez les champs depuis les blocs d'en-tête et de notes. L'en-tête produit contient le nom de l'application, le développeur, la catégorie et le prix ; le widget de notes contient la note moyenne et le nombre d'évaluations. Lire chaque champ de manière défensive empêche une valeur manquante de faire planter l'exécution.

const cheerio = require('cheerio');

function parseAppMetadata(html, sourceUrl) {
  const $ = cheerio.load(html);

  // App name lives in the product header title
  let name = $('.app-header__title').text().trim();
  const titleBadge = $('.badge--product-title').text().trim();
  if (titleBadge) name = name.replace(titleBadge, '').trim();

  // Developer / seller
  const developer = $('.app-header__identity').text().trim();

  // Category, parsed from the "... in <Category>" header item
  let category = null;
  try {
    category = $('.product-header__list__item a.inline-list__item')
      .text()
      .trim()
      .split('in')[1]
      .trim();
  } catch {
    category = null;
  }

  // Price, or "Free" when there is no upfront cost
  const price = $('.app-header__list__item--price').text().trim();

  // Public average rating from the star widget's aria-label
  const rating = $('.we-star-rating').attr('aria-label') || null;

  // Public rating count, after the "•" separator
  let ratingCount = null;
  try {
    ratingCount = $('.we-rating-count')
      .text()
      .trim()
      .split('•')[1]
      .trim();
  } catch {
    ratingCount = null;
  }

  return {
    name,
    developer,
    category,
    rating,
    ratingCount,
    price,
    appUrl: sourceUrl,
  };
}

Quelques détails rendent ceci fidèle à la page. Le nom de l'application provient de .app-header__title, avec le petit badge de titre de produit retiré pour que vous gardiez juste le nom. Le développeur se lit depuis .app-header__identity, et la catégorie est analysée depuis le texte de .product-header__list__item a.inline-list__item, qui se lit comme « Utilitaires » après le mot « in ». Le prix vient de .app-header__list__item--price. Pour le bloc de notes, la moyenne est lue depuis l'aria-label du widget .we-star-rating, et le nombre public d'évaluations est pris depuis .we-rating-count après son séparateur. Chaque champ est lu de manière défensive, donc une note ou un prix manquant renvoie null au lieu de lever une exception.

Étape 3 : Assembler le script complet avec export JSON

Maintenant, reliez la récupération et l'analyse en un seul script exécutable, puis écrivez l'enregistrement sur disque en JSON. Un script simple maintient les pièces mobiles au minimum ; vous pouvez l'envelopper dans un point d'entrée plus tard si vous en voulez un.

const fs = require('fs');
const { CrawlingAPI } = require('crawlbase');
const cheerio = require('cheerio');

const api = new CrawlingAPI({ token: 'YOUR_CRAWLBASE_TOKEN' });

async function crawl(appUrl) {
  const response = await api.get(appUrl);
  if (response.statusCode === 200) return response.body;
  console.error(`Request failed: ${response.statusCode}`);
  return null;
}

async function main() {
  const appUrl =
    'https://apps.apple.com/us/app/google-authenticator/id388497605';
  const html = await crawl(appUrl);
  if (!html) return;

  const app = parseAppMetadata(html, appUrl);
  fs.writeFileSync('app.json', JSON.stringify(app, null, 2));
  console.log(`Saved metadata for ${app.name}`);
}

main();

Collez la fonction parseAppMetadata de l'étape 2 dans le même fichier pour que main puisse l'appeler. Exécutez-le avec node scraper.js et vous obtenez un fichier app.json avec l'enregistrement structuré complet. L'assistant crawl vérifie le code de statut et renvoie null sur une requête échouée, donc main s'arrête proprement plutôt que d'analyser une page cassée.

À quoi ressemble la sortie

Le fichier JSON contient un objet avec les métadonnées publiques de l'application : son nom, son développeur, sa catégorie, sa note moyenne, son nombre d'évaluations, son prix et son URL canonique.

{
  "name": "Google Authenticator",
  "developer": "Google LLC",
  "category": "Utilities",
  "rating": "4.7 out of 5",
  "ratingCount": "1.2M Ratings",
  "price": "Free",
  "appUrl": "https://apps.apple.com/us/app/google-authenticator/id388497605"
}

Cet enregistrement unique est une base solide pour une analyse, un rapport ou une visualisation ultérieurs. Si vous stockez des enregistrements comme celui-ci au fil du temps, vous pouvez suivre l'évolution de la note et du nombre d'évaluations d'une application, ce qui est souvent l'objectif de l'exercice.

Mise à l'échelle vers de nombreuses applications

Une page d'application est une démonstration ; un vrai travail récupère une liste d'applications. L'App Store n'expose pas un index public unique de toutes les applications, donc vous construisez votre propre liste d'URLs de produits, puis bouclez dessus, récupérez chacune via la Crawling API, analysez-la avec la même fonction, et collectez les enregistrements. Comme chaque page produit partage la même structure d'en-tête et de notes, l'analyseur que vous avez déjà écrit fonctionne sur toutes sans changements.

async function scrapeMany(appUrls) {
  const records = [];

  for (const url of appUrls) {
    const html = await crawl(url);
    if (!html) continue;

    records.push(parseAppMetadata(html, url));
    console.log(`Parsed ${url}`);

    // Pace requests so you stay under the rate limit
    await new Promise((r) => setTimeout(r, 2000));
  }

  return records;
}

Les bonnes habitudes s'appliquent à n'importe quelle cible : collectez d'abord une liste propre d'URLs, analysez chacune avec la même fonction, et mettez un court délai entre les requêtes pour ne pas marteler le site. Pour en savoir plus sur les pages rendues lourdes en JavaScript comme celle-ci, voir notre guide sur le crawling de sites JavaScript.

Rester non bloqué

Même avec le rendu géré, l'App Store surveille le trafic ressemblant à des scrapers. Quelques habitudes maintiennent une exécution en bonne santé, et elles s'appliquent à n'importe quelle cible commerciale difficile.

• Rythmez vos requêtes. Introduisez un délai entre les récupérations de pages plutôt que de marteler le store dans une boucle serrée. Étaler les requêtes est le facteur unique le plus important pour rester sous les limites de débit.
• Appuyez-vous sur la rotation. Un pool d'IPs résidentielles répartit les requêtes sur de nombreuses adresses d'utilisateurs réels afin qu'aucune ne déclenche une limite ou un blocage. La Crawling API gère cela pour vous ; si vous construisez votre propre pile, c'est la partie à bien faire.
• Lisez les codes de statut. Une exécution qui commence à renvoyer des réponses non 200 vous indique que le débit ou le niveau d'IP actuel n'est plus suffisant. Traitez cela comme un signal de ralentissement, pas du bruit à ignorer.

Pour le guide plus complet, voir comment scraper des sites sans être bloqué. Si vous voulez un outil prêt à l'emploi pour cette cible spécifique, notre tutoriel scraper de l'Apple App Store couvre le même terrain sous un angle différent.

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

Savoir si le scraping de l'App Store est autorisé dépend des conditions d'Apple, de votre juridiction et de ce que vous faites des données. Les conditions d'utilisation d'Apple restreignent l'accès automatisé, donc le scraping peut aller à l'encontre de ces conditions quelle que soit la précision de vos outils. Aucun code ici ne change cela ; il fait juste fonctionner la partie technique. Lisez les conditions d'Apple et le robots.txt de l'App Store, respectez toutes les attentes de débit qu'ils indiquent, gardez votre volume de requêtes raisonnable, et traitez les deux comme la limite de ce que vous collectez.

Ce guide est délibérément limité aux métadonnées publiques d'application : le nom de l'application, le développeur, la catégorie, la note moyenne publique, le nombre public d'évaluations, le prix et l'URL canonique que n'importe qui peut voir sur une page produit sans se connecter. C'est différent des données personnelles sur la plateforme. Les avis individuels et les personnes qui les ont écrits sont des données personnelles. Utilisez les nombres d'évaluations et les moyennes comme signal agrégé sur une application, n'assemblez jamais de profils d'évaluateurs individuels, et ne republiez pas l'avis d'une personne lié à son identité. Tout ce qui se trouve derrière un compte Apple, scraté à grande échelle, ou impliquant des individus identifiables relève des lois sur la vie privée comme le RGPD et le CCPA, et c'est clairement hors de portée ici. Traitez les captures d'écran, icônes et textes de description protégés par le droit d'auteur comme la propriété d'Apple et du développeur, pas la vôtre à redistribuer.

Si votre projet a besoin de plus que des métadonnées publiques, la bonne voie est une voie sanctionnée, pas un scraper plus habile. Apple gère des programmes officiels pour ces données. App Store Connect vous expose les données de votre propre application en tant que développeur, et l'API de recherche iTunes publique renvoie des métadonnées d'application structurées, y compris nom, développeur, catégorie, prix et notes, sous des conditions documentées. Ces API officielles sont les bons outils quand vous avez besoin de volumes importants, d'une structure garantie ou du droit de réutiliser les données commercialement. Quand vous n'êtes pas sûr qu'une utilisation est autorisée, obtenez la permission ou utilisez l'API sanctionnée plutôt que de supposer que le silence est un consentement.

Foire aux questions

Puis-je scraper n'importe quelle application sur l'App Store ?

Vous pouvez récupérer la page produit publique de n'importe quelle application tant que vous avez son URL. Apple ne publie pas d'index public complet de toutes les applications, donc vous construisez votre propre liste d'URLs de produits à partir des résultats de recherche, des classements ou des liens que vous avez déjà, puis bouclez sur cette liste. Gardez votre volume raisonnable et restez sur les champs de métadonnées publiques couverts ici.

Pourquoi une requête ordinaire renvoie-t-elle des données incomplètes depuis l'App Store ?

Parce qu'Apple rend une grande partie de la page produit dans le navigateur et remet en question le trafic automatisé. Une requête HTTP brute depuis une IP de datacenter renvoie généralement une coquille mince plutôt que le contenu d'en-tête et de notes. Pour obtenir une page complète, vous devez la rendre derrière une IP de confiance, ce que la Crawling API gère pour vous quand vous utilisez le token JavaScript.

Mes sélecteurs renvoient des valeurs vides. Qu'est-ce qui a changé ?

Très certainement le balisage d'Apple. Les noms de classes comme app-header__title et we-rating-count font partie d'une mise en page qui change au fil du temps, donc les sélecteurs qui fonctionnaient le mois dernier peuvent se casser. Réinspectez une page en direct dans les outils de développement de votre navigateur, mettez à jour les sélecteurs dans parseAppMetadata, et vous êtes de nouveau en affaires. La maintenance périodique des sélecteurs est normale pour tout scraper en production.

Puis-je scraper les avis individuels et les noms d'évaluateurs de l'App Store ?

C'est hors de portée de ce guide, et pour une bonne raison. Les avis individuels et les personnes qui les ont écrits sont des données personnelles, ce qui relève des lois sur la vie privée comme le RGPD et le CCPA. Utilisez le nombre public d'évaluations et la moyenne comme signal agrégé sur une application, ne construisez pas de profils d'évaluateurs individuels, et ne republiez pas l'avis d'une personne lié à son identité. Pour tout ce qui dépasse les métadonnées publiques, utilisez les API officielles d'Apple.

Apple a-t-elle une API officielle pour les données d'application ?

Oui. App Store Connect donne aux développeurs accès aux données de leur propre application, et l'API de recherche iTunes publique renvoie des métadonnées structurées pour les applications, y compris nom, développeur, catégorie, prix et notes, sous des conditions documentées. Si vous avez besoin de volumes importants, d'une structure garantie ou du droit de réutiliser les données commercialement, ces voies sanctionnées sont le bon choix. Ce scraper de métadonnées publiques est le mieux adapté à la recherche, au prototypage et à l'analyse à plus petite échelle où un accord officiel n'est pas justifié.

Puis-je construire un scraper App Store dans un autre langage que JavaScript ?

Oui. Ce guide utilise JavaScript avec Cheerio, mais la même approche fonctionne dans n'importe quel langage. La Crawling API dispose de bibliothèques et de SDK pour plusieurs langages, donc vous récupérez le HTML rendu de la même façon et l'analysez avec l'analyseur HTML que préfère votre pile, comme BeautifulSoup en Python. Les sélecteurs et les champs restent les mêmes ; seule la syntaxe d'analyse change.

IK

Ian Kalvin

Ingénieur support technique · Crawlbase

Ingénieur support technique chez Crawlbase, il écrit depuis la première ligne de ce qui casse réellement en production, sur les configurations de scraping et de proxys.

NZ

Neil Zamora

Architecte senior · Crawlbase

Architecte senior chez Crawlbase, axé sur les systèmes derrière le crawling à grande échelle : rotation de proxys, résilience anti-bot et les API qui masquent cette complexité.