So crawlen Sie Apple App Store-DatenApps, Bewertungen und Rezensionen mit Node

Der Apple App Store ist einer der größten öffentlichen Softwarekataloge im offenen Web. Jede App-Seite trägt einen einheitlichen Block strukturierter Details: den App-Namen, wer sie entwickelt hat, in welcher Kategorie sie liegt, ihre öffentliche Sternebewertung und Bewertungsanzahl, den Preis und die kanonische URL. Entwickler verfolgen diese Daten, um Wettbewerber zu vergleichen, Analysten untersuchen Kategorietrends, und Produktteams beobachten, wie sich Bewertungen im Zeitverlauf bewegen. All das steht auf der öffentlichen Produktseite in einem vorhersehbaren Layout, das jeder ohne Anmeldung öffnen kann.

Dieser Leitfaden zeigt Ihnen, wie Sie Apple App Store-Daten crawlen mit JavaScript und Node.js unter Verwendung von Cheerio. Sie bauen einen kleinen, lauffähigen Scraper, der eine öffentliche App-Seite über die Crawling API abruft, die öffentlichen Metadatenfelder parst und das Ergebnis als JSON exportiert. Die gesamte Anleitung bleibt auf öffentliche App-Metadaten beschränkt. Sie erfasst oder profiliert keine einzelnen Rezensenten, und der Abschnitt zur Rechtslage gegen Ende ist kein Standardtext, lesen Sie ihn also, bevor Sie das auf echtes Volumen richten.

Was Sie bauen werden

Ein Node.js-Skript, das eine öffentliche App Store-Produkt-URL entgegennimmt, das gerenderte HTML über die Crawling API abruft und einen strukturierten Datensatz der öffentlichen Metadaten der App extrahiert. Wir verwenden Google Authenticator als durchgängiges Beispiel und ziehen diese Felder heraus:

• App-Name der oben auf der Seite angezeigte Produkttitel.
• Entwickler der Name des Anbieters oder Studios, das die App veröffentlicht.
• Kategorie die App Store-Kategorie, unter der die App gelistet ist, zum Beispiel "Utilities".
• Bewertung die öffentliche durchschnittliche Sternebewertung, die Apple für die App anzeigt.
• Bewertungsanzahl die öffentliche Anzahl der Bewertungen hinter diesem Durchschnitt.
• Preis der ausgewiesene Preis, oder "Free", wenn die App keine Vorabkosten hat.
• App-URL die kanonische öffentliche URL der Produktseite.

Warum eine einfache Anfrage im App Store scheitert

Wenn Sie eine App Store-Produkt-URL mit einem nackten HTTP-Client anfragen, erhalten Sie selten brauchbares Markup zurück. Zwei Dinge arbeiten gegen Sie. Erstens rendert Apple einen Großteil der Produktseite im Browser, sodass das anfängliche HTML eine dünne Hülle ist, bis die Skripte der Seite laufen und den Header, die Bewertungen und die Metadatenblöcke befüllen. Zweitens markiert der App Store automatisierten Traffic: Rechenzentrums-IPs und Anfragemuster, die nicht wie ein echter Browser aussehen, werden gedrosselt oder blockiert, bevor sie den gerenderten Inhalt erreichen.

Ein funktionierender App Store-Scraper braucht also zwei Dinge in einer Anfrage: einen Browser, der die Seite tatsächlich rendert, und eine IP, die die Plattform als echten Besucher liest. Sie können das selbst mit einem Headless-Browser plus einem Pool rotierender Residential-Proxys zusammenstellen, aber diese zusammenzufügen und gesund zu halten ist der Großteil der Arbeit. Die Crawling API fasst beides in einem einzigen Aufruf zusammen: Sie senden ihr die URL, sie rendert die Seite hinter einer vertrauenswürdigen IP, und sie gibt fertiges HTML zurück, das Sie mit Cheerio parsen können.

Voraussetzungen

Sie brauchen ein paar Dinge, bevor Sie überhaupt Code schreiben. Keines davon dauert lange.

Grundlegende JavaScript- und Node.js-Kenntnisse. Sie sollten damit vertraut sein, ein Node-Skript zu schreiben und auszuführen und Pakete mit npm zu installieren. Wenn Sie neu bei Node sind, bringen Sie die offiziellen Dokumente und jeder Anfängerkurs auf das Niveau, das dieses Tutorial voraussetzt. Für eine ausführlichere Anleitung deckt unser Leitfaden zum Bauen eines Web-Scrapers mit Node.js die Grundlagen ab.

Node.js 16 oder neuer. Überprüfen Sie Ihre Version mit node --version. Falls Sie es nicht haben, installieren Sie es von der Node.js-Website oder über einen Versionsmanager wie nvm.

Ein Crawlbase-Konto und Token. Melden Sie sich an, öffnen Sie Ihr Dashboard und kopieren Sie Ihr JavaScript-Token von der Account-Docs-Seite. Die kostenlose Stufe gibt Ihnen bis zu 20.000 Anfragen ohne Karte, und Sie zahlen nur für erfolgreiche Anfragen. Behandeln Sie das Token wie ein Passwort: Es authentifiziert Ihre Anfragen, halten Sie es also aus der Versionsverwaltung heraus.

Das Projekt einrichten

Erstellen Sie einen Projektordner, initialisieren Sie ihn und installieren Sie die beiden Bibliotheken, die der Scraper braucht.

node --version

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

npm install crawlbase cheerio

Zwei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Node-Client für die Crawling API, und cheerio parst das zurückgegebene HTML mit einer jQuery-artigen API, sodass Sie einzelne Felder per CSS-Selektor herausziehen können. Erstellen Sie in diesem Ordner eine Datei namens scraper.js und fügen Sie den Code aus den Schritten unten hinzu.

Schritt 1: Die gerenderte App-Seite abrufen

Beginnen Sie damit, die fertige Seite zu holen. Importieren Sie die CrawlingAPI-Klasse, initialisieren Sie sie mit Ihrem JavaScript-Token und fragen Sie eine öffentliche App Store-Produkt-URL ab. Den Statuscode zu prüfen, bevor Sie parsen, hält Fehler laut statt still.

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));

Führen Sie das Skript mit node scraper.js aus, und Sie sollten echtes App Store-Produkt-Markup am Anfang des Bodys sehen, keine abgespeckte Hülle. Das bestätigt, dass das Rendern funktioniert, bevor Sie einen einzigen Selektor schreiben. Die Crawling API verwendet das JavaScript-Token, das Sie angegeben haben, um die Seite in einem echten Browser zu rendern, sodass der Header, die Bewertungen und die Metadatenblöcke im HTML vorhanden sind, das Sie zurückbekommen.

Schritt 2: Die öffentlichen Metadaten mit Cheerio parsen

Mit gerendertem HTML in der Hand laden Sie es in Cheerio und lesen die Felder aus dem Header- und dem Bewertungsblock heraus. Der Produkt-Header enthält den App-Namen, den Entwickler, die Kategorie und den Preis; das Bewertungs-Widget enthält die durchschnittliche Sternebewertung und die Bewertungsanzahl. Jedes Feld defensiv zu lesen verhindert, dass ein fehlender Wert den Lauf abstürzen lässt.

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,
  };
}

Ein paar Details halten dies der Seite treu. Der App-Name kommt aus .app-header__title, wobei das kleine Produkttitel-Badge abgestreift wird, sodass Sie nur den Namen behalten. Der Entwickler liest sich aus .app-header__identity, und die Kategorie wird aus dem Text von .product-header__list__item a.inline-list__item geparst, der sich nach dem Wort "in" wie "Utilities" liest. Der Preis kommt aus .app-header__list__item--price. Für den Bewertungsblock wird der Durchschnitt aus dem aria-label des .we-star-rating-Widgets gelesen, und die öffentliche Bewertungsanzahl wird aus .we-rating-count nach ihrem Trennzeichen genommen. Jedes Feld wird defensiv gelesen, sodass eine fehlende Bewertung oder ein fehlender Preis null zurückgibt, anstatt eine Ausnahme zu werfen.

Schritt 3: Das vollständige Skript mit JSON-Export zusammenfügen

Verdrahten Sie nun das Abrufen und das Parsen zu einem lauffähigen Skript und schreiben Sie den Datensatz dann als JSON auf die Festplatte. Ein einfaches Skript hält die beweglichen Teile gering; Sie können es später in einen Endpunkt einpacken, wenn Sie einen wollen.

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();

Fügen Sie die parseAppMetadata-Funktion aus Schritt 2 in dieselbe Datei ein, damit main sie aufrufen kann. Führen Sie es mit node scraper.js aus, und Sie erhalten eine app.json-Datei mit dem vollständigen strukturierten Datensatz. Der crawl-Helfer prüft den Statuscode und gibt bei einer fehlgeschlagenen Anfrage null zurück, sodass main sauber stoppt, anstatt eine kaputte Seite zu parsen.

Wie die Ausgabe aussieht

Die JSON-Datei enthält ein Objekt mit den öffentlichen Metadaten der App: ihren Namen, Entwickler, ihre Kategorie, durchschnittliche Bewertung, Bewertungsanzahl, ihren Preis und die kanonische URL.

{
  "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"
}

Dieser eine Datensatz ist eine solide Grundlage für weitere Analysen, Berichte oder Visualisierungen. Wenn Sie Datensätze wie diesen über die Zeit speichern, können Sie verfolgen, wie sich die Bewertung und die Bewertungsanzahl einer App bewegen, was oft der Sinn der Übung ist.

Auf viele Apps skalieren

Eine App-Seite ist eine Demo; ein echter Auftrag zieht eine Liste von Apps. Der App Store stellt keinen einzelnen öffentlichen Index aller Apps bereit, also bauen Sie Ihre eigene Liste von Produkt-URLs, durchlaufen sie dann in einer Schleife, rufen jede über die Crawling API ab, parsen sie mit derselben Funktion und sammeln die Datensätze. Da jede Produktseite dieselbe Header- und Bewertungsstruktur teilt, funktioniert der Parser, den Sie bereits geschrieben haben, über alle hinweg ohne Änderungen.

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;
}

Die wichtigen Gewohnheiten übertragen sich auf jedes Ziel: Sammeln Sie zuerst eine saubere Liste von URLs, parsen Sie jede mit derselben Funktion und setzen Sie eine kurze Verzögerung zwischen die Anfragen, damit Sie die Seite nicht überlasten. Für mehr zu gerenderten, JavaScript-lastigen Seiten wie dieser sehen Sie sich unseren Leitfaden zum Crawlen von JavaScript-Websites an.

Unblockiert bleiben

Selbst wenn das Rendern erledigt ist, achtet der App Store auf scraper-förmigen Traffic. Ein paar Gewohnheiten halten einen Lauf gesund, und sie gelten für jedes harte kommerzielle Ziel.

• Geben Sie Ihren Anfragen ein Tempo. Führen Sie eine Verzögerung zwischen den Seitenabrufen ein, anstatt den Store in einer engen Schleife zu hämmern. Das Verteilen der Anfragen ist der mit Abstand größte Faktor, um unter den Rate-Limits zu bleiben.
• Setzen Sie auf Rotation. Ein Pool von Residential-IPs verteilt Anfragen über viele echte Nutzeradressen, sodass keine einzelne ein Limit oder einen Block auslöst. Die Crawling API erledigt das für Sie; wenn Sie Ihren eigenen Stack bauen, ist das der Teil, den Sie richtig hinbekommen müssen.
• Lesen Sie die Statuscodes. Ein Lauf, der anfängt, Nicht-200-Antworten zurückzugeben, sagt Ihnen, dass die aktuelle Rate- oder IP-Stufe nicht mehr ausreicht. Behandeln Sie das als Signal zum Zurückfahren, nicht als Rauschen, das man ignoriert.

Für das umfassendere Playbook sehen Sie, wie man Websites scrapt, ohne blockiert zu werden. Wenn Sie ein fertiges Werkzeug für genau dieses Ziel wollen, deckt unsere Anleitung zum Apple App Store-Scraper denselben Boden aus einem anderen Blickwinkel ab.

Ist es legal, den Apple App Store zu scrapen?

Ob das Scrapen des App Store erlaubt ist, hängt von Apples Bedingungen, Ihrer Rechtsordnung und davon ab, was Sie mit den Daten tun. Apples Nutzungsbedingungen schränken automatisierten Zugriff ein, sodass Scraping diesen Bedingungen zuwiderlaufen kann, egal wie sorgfältig Ihr Werkzeug ist. Nichts vom Code hier ändert das; er bringt nur den technischen Teil zum Laufen. Lesen Sie Apples Bedingungen und die robots.txt des App Store, respektieren Sie alle Rate-Erwartungen, die sie angeben, halten Sie Ihr Anfragevolumen angemessen und behandeln Sie beides als Grenze dafür, was Sie erfassen.

Dieser Leitfaden ist bewusst auf öffentliche App-Metadaten beschränkt: den App-Namen, Entwickler, die Kategorie, öffentliche durchschnittliche Bewertung, öffentliche Bewertungsanzahl, den Preis und die kanonische URL, die jeder auf einer Produktseite ohne Anmeldung sehen kann. Das unterscheidet sich von den personenbezogenen Daten auf der Plattform. Einzelne Rezensionen und die Menschen, die sie geschrieben haben, sind personenbezogene Daten. Nutzen Sie Bewertungsanzahlen und Durchschnitte als aggregiertes Signal über eine App, stellen Sie niemals Profile einzelner Rezensenten zusammen, und veröffentlichen Sie die Rezension einer Person nicht erneut, verknüpft mit ihrer Identität. Alles, was hinter einem Apple-Konto liegt, in großem Maßstab gescrapt wird oder identifizierbare Personen betrifft, zieht Datenschutzrecht wie GDPR und CCPA mit hinein, und das liegt hier klar außerhalb des Geltungsbereichs. Behandeln Sie urheberrechtlich geschützte Screenshots, Symbole und Beschreibungstexte als Eigentum von Apple und des Entwicklers, nicht als Ihres zur Weiterverbreitung.

Wenn Ihr Projekt mehr als öffentliche Metadaten braucht, ist der richtige Weg ein genehmigter, kein cleverer Scraper. Apple betreibt offizielle Programme für diese Daten. App Store Connect macht Ihnen als Entwickler die Daten Ihrer eigenen App zugänglich, und die öffentliche iTunes Search API gibt strukturierte App-Metadaten zurück, darunter Name, Entwickler, Kategorie, Preis und Bewertungen, unter dokumentierten Bedingungen. Diese offiziellen APIs sind die richtigen Werkzeuge, wenn Sie große Mengen, garantierte Struktur oder das Recht brauchen, die Daten kommerziell wiederzuverwenden. Wenn Sie unsicher sind, ob eine Nutzung erlaubt ist, holen Sie sich eine Erlaubnis oder nutzen Sie die genehmigte API, anstatt anzunehmen, dass Schweigen Zustimmung bedeutet.

Häufig gestellte Fragen

Kann ich jede App im App Store scrapen?

Sie können die öffentliche Produktseite jeder App abrufen, solange Sie ihre URL haben. Apple veröffentlicht keinen vollständigen öffentlichen Index aller Apps, also bauen Sie Ihre eigene Liste von Produkt-URLs aus Suchergebnissen, Charts oder Links, die Sie bereits haben, und durchlaufen dann diese Liste in einer Schleife. Halten Sie Ihr Volumen angemessen und bleiben Sie bei den hier behandelten öffentlichen Metadatenfeldern.

Warum gibt eine einfache Anfrage unvollständige Daten vom App Store zurück?

Weil Apple einen Großteil der Produktseite im Browser rendert und automatisierten Traffic herausfordert. Eine rohe HTTP-Anfrage von einer Rechenzentrums-IP gibt normalerweise eine dünne Hülle zurück statt des Header- und Bewertungsinhalts. Um eine vollständige Seite zu erhalten, müssen Sie sie hinter einer vertrauenswürdigen IP rendern, was die Crawling API für Sie erledigt, wenn Sie das JavaScript-Token verwenden.

Meine Selektoren geben leere Werte zurück. Was hat sich geändert?

Mit ziemlicher Sicherheit Apples Markup. Klassennamen wie app-header__title und we-rating-count sind Teil eines Layouts, das sich im Lauf der Zeit ändert, sodass Selektoren, die letzten Monat funktionierten, brechen können. Inspizieren Sie eine Live-Seite in den Dev-Tools Ihres Browsers erneut, aktualisieren Sie die Selektoren in parseAppMetadata, und Sie sind wieder im Geschäft. Regelmäßige Selektorpflege ist für jeden produktiven Scraper normal.

Kann ich einzelne App Store-Rezensionen und Rezensentennamen scrapen?

Das liegt außerhalb des Geltungsbereichs dieses Leitfadens, und das aus gutem Grund. Einzelne Rezensionen und die Menschen, die sie geschrieben haben, sind personenbezogene Daten, was Datenschutzrecht wie GDPR und CCPA mit hineinzieht. Nutzen Sie die öffentliche Bewertungsanzahl und den Durchschnitt als aggregiertes Signal über eine App, bauen Sie keine Profile einzelner Rezensenten, und veröffentlichen Sie die Rezension einer Person nicht erneut, verknüpft mit ihrer Identität. Für alles jenseits öffentlicher Metadaten nutzen Sie Apples offizielle APIs.

Hat Apple eine offizielle API für App-Daten?

Ja. App Store Connect gibt Entwicklern Zugriff auf die Daten ihrer eigenen App, und die öffentliche iTunes Search API gibt strukturierte Metadaten für Apps zurück, darunter Name, Entwickler, Kategorie, Preis und Bewertungen, unter dokumentierten Bedingungen. Wenn Sie große Mengen, garantierte Struktur oder das Recht brauchen, die Daten kommerziell wiederzuverwenden, sind diese genehmigten Wege die richtige Wahl. Dieser Scraper für öffentliche Metadaten eignet sich am besten für Recherche, Prototyping und kleinere Analysen, bei denen eine offizielle Vereinbarung nicht gerechtfertigt ist.

Kann ich einen App Store-Scraper in einer anderen Sprache als JavaScript bauen?

Ja. Dieser Leitfaden verwendet JavaScript mit Cheerio, aber derselbe Ansatz funktioniert in jeder Sprache. Die Crawling API hat Bibliotheken und SDKs für mehrere Sprachen, sodass Sie das gerenderte HTML auf dieselbe Weise abrufen und es mit einem beliebigen HTML-Parser parsen, den Ihr Stack bevorzugt, wie etwa BeautifulSoup in Python. Die Selektoren und Felder bleiben gleich; nur die Parsing-Syntax ändert sich.

IK

Ian Kalvin

Technical Support Engineer · Crawlbase

Technical Support Engineer bei Crawlbase, der von der Front darüber schreibt, was beim Scraping und bei Proxy-Setups im Produktivbetrieb tatsächlich kaputtgeht.

NZ

Neil Zamora

Senior Architect · Crawlbase

Senior Architect bei Crawlbase mit Fokus auf den Systemen hinter großflächigem Crawling: Proxy-Rotation, Anti-Bot-Resilienz und den APIs, die diese Komplexität verbergen.