Der Apple App Store ist eine digitale Plattform, auf der Nutzer Apps auf ihren Apple-Geräten, einschließlich iPhones und iPads, durchsuchen, herunterladen und installieren können. Er bietet Millionen von Apps – von nervtötenden Spielen über Produktivitäts-Apps bis hin zu anderen Unterhaltungsangeboten, die uns fesseln.

Wenn Sie selbst Apps entwickeln, etwas vermarkten möchten oder einfach nur Markttrends recherchieren, können Informationen aus dem App Store sehr hilfreich sein. Der eigentliche Trick besteht darin, Ihren Scraping-Ansatz richtig einzurichten, damit Sie alle Daten in etwas umwandeln können, das Ihnen tatsächlich hilft, intelligentere Entscheidungen zu treffen.

In diesem Blog zeigen wir Ihnen, wie Sie Apple App Store-Daten crawlen und scrapen können mit Crawlbase Crawling API und JavaScript. Diese Kombination funktioniert überraschend gut, um Details zu erfassen, beispielsweise das Ranking von Apps, die Versprechen ihrer Beschreibungen und die tatsächlichen Aussagen echter Benutzer in Bewertungen.

Wie kann man Apple App Store-Daten scrapen?

Unser erster Schritt ist die Erstellung eines Kontos bei Crawlbase, die es uns ermöglichen wird, die Crawling API und dienen uns als Plattform zum zuverlässigen Abrufen von Daten aus dem App Store.

Erstellen einer Crawlbase Konto

  1. Melden Sie sich für ein Crawlbase Konto und logge dich ein.
  2. Nach der Registrierung erhalten Sie 1,000 kostenlose Anfragen. Fügen Sie Ihre Rechnungsdetails hinzu bevor Sie eines der kostenlosen Guthaben verwenden, um zusätzliche 9,000 Anfragen zu erhalten.
  3. Gehen Sie zu Ihrem Kontodokumente und speichern Sie Ihr Normal Request-Token für die Zwecke dieses Blogs.

Einrichten der Umgebung

Stellen Sie als Nächstes sicher, dass Node.js auf Ihrem Gerät installiert ist, da es das Rückgrat unseres Scraping-Skripts bildet und eine schnelle JavaScript-Laufzeit sowie Zugriff auf wichtige Bibliotheken bietet.

Node unter Windows installieren:

  1. Gehen Sie zur offizielle Node.js-Website und laden Sie die Long-Term Support (LTS)-Version für Windows herunter.
  2. Starten Sie das Installationsprogramm und folgen Sie den Anweisungen. Behalten Sie die Standardoptionen bei.
  3. Überprüfen Sie die Installation, indem Sie eine neue Eingabeaufforderung öffnen und die folgenden Befehle ausführen:
1
2
Knoten -v
npm -v

Für macOS:

  1. Gehe zu [https://nodejs.org](https://nodejs.org/) und laden Sie das macOS-Installationsprogramm (LTS) herunter.
  2. Folgen Sie dem Installationsassistenten.
  3. Öffnen Sie das Terminal und bestätigen Sie die Installation:
1
2
Knoten -v
npm -v

Für Linux (Ubuntu/Debian):

  1. Öffnen Sie Ihr Terminal, um das NodeSource-Repository hinzuzufügen und Node.js zu installieren:
1
2
curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt-get install -y Knotenjs
  1. Überprüfen Sie Ihre Installation:
1
2
Knoten -v
npm -v

Skript abrufen

Holen Sie sich das Skript unten und speichern Sie es mit einem .js Erweiterung, jede IDE oder eine beliebige Programmierumgebung. Überprüfen Sie nach dem Speichern, ob alle erforderlichen Abhängigkeiten in Ihrem Node.js-Setup installiert sind. Danach sollte alles bereit sein.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
importieren { CrawlingAPI } von „Crawlbase“;

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

async Funktion crawlAppStore() {
  const API = neu CrawlingAPI({ Zeichen: CRAWLBASE_NORMAL_TOKEN });
  const Optionen = {
    Benutzeragent: „Mozilla/5.0 (Windows NT 6.2; rv:20.0) Gecko/20121202 Firefox/30.0“,
  };

  const Antwort = – warten auf Sie! api.bekommen(URL, Optionen);

  if (Antwort.Statuscode ! == 200) {
    werfen neu Fehler(`Anforderung fehlgeschlagen mit Statuscode: ${response.statusCode}`);
  }

  Rückkehr Antwort.Körper;
}

WICHTIG: Stellen Sie sicher, zu ersetzen <Normal requests token> mit Ihrem tatsächlichen Crawlbase normales Anforderungstoken vor dem Ausführen des Skripts.

Dieses Skript zeigt, wie man Crawlbase Crawling API zum Abrufen von HTML-Inhalten aus dem Apple App Store ohne blockiert zu werden. Beachten Sie, dass die Antwort noch nicht gescraped wurde. Wir müssen noch unnötige Elemente entfernen, die Daten bereinigen und eine analysierte, strukturierte Antwort erstellen.

Auffinden bestimmter CSS-Selektoren

Nachdem Sie nun wissen, wie Sie mit Node.js eine einfache API-Anfrage senden, suchen wir die benötigten Daten aus unserer Ziel-URL, damit wir später Code zum Bereinigen und Analysieren schreiben können.

Das Erste, was Ihnen auffällt, ist der Hauptabschnitt oben. Dort finden wir in der Regel die wichtigsten Details. Er ist in der Regel gut strukturiert und somit ein ideales Ziel für Scraping.

Öffnen Sie Ihre Ziel-URL und suchen Sie die einzelnen Selektoren. Suchen wir beispielsweise nach dem Titel:

Ein Bild der Chrome Browser Developer Tools mit hervorgehobenem Inhaltsheaderelement.

Beachten Sie die .app-header__title und das gleiche für subtitle, seller, category, stars, ratingund price. Sobald dies erledigt ist, ist dieser Abschnitt abgeschlossen.

Der Vorgang ist für den Rest der Seite weitgehend identisch. Hier ein weiteres Beispiel: Wenn Sie die durchschnittliche Kundenbewertung im Bereich „Bewertungen und Rezensionen“ anzeigen möchten, klicken Sie mit der rechten Maustaste auf die Daten und wählen Sie „Untersuchen“:

Ein Bild der Chrome-Browser-Entwicklertools, das das Element zur Inhaltsbewertung hervorhebt.

Sie kennen das Wesentliche. Jetzt sollte es für Sie ein Kinderspiel sein, die restlichen benötigten Daten zu finden.

Analysieren des HTML in Node.js

Nachdem Sie nun ein Experte im Extrahieren der CSS-Selektoren sind, ist es an der Zeit, den Code zum Parsen des HTML-Codes zu erstellen. Hier Tschüs kommt ins Spiel. Es ist eine leichte und leistungsstarke Bibliothek, die es uns ermöglicht, relevante Daten aus dem HTML-Quellcode innerhalb von Node.js auszuwählen.

Beginnen Sie mit der Erstellung Ihres Projektordners und führen Sie Folgendes aus:

1
2
npm init -y
npm install crawlbase lodash casenator cheerio

Importieren der erforderlichen Bibliotheken

Dann in Ihrem .js Importieren Sie die erforderlichen Bibliotheken für dieses Projekt, einschließlich Cheerio:

1
2
3
4
importieren _ von 'lodash';
importieren { CrawlingAPI } von „Crawlbase“;
importieren { toCamelCase } von 'Kasenator';
importieren * as Tschüs von "Tschüs";

Vergessen Sie nicht, die Crawling API sowie die Zielwebsite:

1
2
const CRAWLBASE_NORMAL_TOKEN = ' ';
const URL = 'https://apps.apple.com/us/app/google-authenticator/id388497605';

Funktionen zum Scraping von Apple Store-Daten

Hier verwenden wir die CSS-Selektoren, die wir zuvor gesammelt haben. Schreiben wir den Codeteil, der die Informationen von der App Store-Seite abruft.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Funktion scrapePrimaryAppDetails($) {
  lassen Titel = $('.app-header__title').Text().trimmen();
  const TitelBadge = $('.badge--Produkttitel').Text().trimmen();
  Titel = Titel.ersetzen(Titelabzeichen, '').trimmen();
  const Untertitel = $('.app-header__subtitle').Text().trimmen();
  const Verkäufer = $('.app-header__identity').Text().trimmen();
  lassen Kategorie = null;
  versuchen {
    Kategorie = $('.product-header__list__item a.inline-list__item').Text().trimmen().gespalten('In')[1].trimmen();
  } Fang {
    Kategorie = null;
  }
  const Sterne = $('.we-star-rating').attr(„Arien-Etikett“);
  const Bewertung = $('.we-rating-count').Text().trimmen().gespalten('•')[1].trimmen();
  const Preis = $(„.app-header__list__item--Preis“).Text().trimmen();

  Rückkehr { Titel, Untertitel, Verkäufer, Kategorie, Sterne, Bewertung, Preis };
}

Auf diese Weise werden Titel, Untertitel, Verkäufer, Kategorie, Sternebewertung, Gesamtbewertung und Preis extrahiert.

Von hier aus können Sie für jeden Abschnitt der Seite weitere Funktionen hinzufügen. Sie können das Vorschaubild und die Beschreibung sowie Benutzerbewertungen usw. hinzufügen.

Alles in einer Funktion vereinen

Sobald der Scraper fertig ist, müssen wir alles in einer Funktion kombinieren und das Ergebnis ausdrucken:

1
2
3
4
5
6
7
8
9
10
Funktion scrapeAppStore(html) {
  const $ = Prost.Belastung(html);
  Rückkehr {
    primäreAppDetails: scrapePrimaryAppDetails($),
    appPreviewAndDescription: scrapeAppPreviewAndDescription($),
    Bewertungen und Rezensionen: { Rezensionen: scrapeRatingsAndReviews($) },
    Informationsabschnitt: scrapeInformationSection($),
    Verwandte Apps und Empfehlungen: scrapeRelatedAppsAndRecommendations($),
  };
}

Vollständiger Code zum Scrapen von Apple App Store-Daten

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
importieren _ von 'lodash';
importieren { CrawlingAPI } von „Crawlbase“;
importieren { toCamelCase } von 'Kasenator';
importieren * as Tschüs von "Tschüs";

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

async Funktion crawlAppStore() {
  const API = neu CrawlingAPI({ Zeichen: CRAWLBASE_NORMAL_TOKEN });
  const Optionen = {
    Benutzeragent: „Mozilla/5.0 (Windows NT 6.2; rv:20.0) Gecko/20121202 Firefox/30.0“,
  };

  const Antwort = – warten auf Sie! api.bekommen(URL, Optionen);

  if (Antwort.Statuscode ! == 200) {
    werfen neu Fehler(`Anforderung fehlgeschlagen mit Statuscode: ${response.statusCode}`);
  }
  Rückkehr Antwort.Körper;
}

Funktion scrapePrimaryAppDetails($) {
  lassen Titel = $('.app-header__title').Text().trimmen();
  const TitelBadge = $('.badge--Produkttitel').Text().trimmen();
  Titel = Titel.ersetzen(Titelabzeichen, '').trimmen();
  const Untertitel = $('.app-header__subtitle').Text().trimmen();
  const Verkäufer = $('.app-header__identity').Text().trimmen();
  lassen Kategorie = null;
  versuchen {
    Kategorie = $('.product-header__list__item a.inline-list__item').Text().trimmen().gespalten('In')[1].trimmen();
  } Fang {
    Kategorie = null;
  }
  const Sterne = $('.we-star-rating').attr(„Arien-Etikett“);
  const Bewertung = $('.we-rating-count').Text().trimmen().gespalten('•')[1].trimmen();
  const Preis = $(„.app-header__list__item--Preis“).Text().trimmen();

  Rückkehr { Titel, Untertitel, Verkäufer, Kategorie, Sterne, Bewertung, Preis };
}

Funktion scrapeAppPreviewAndDescription($) {
  const Quellen = $('Quelle').zuArray();
  const Bild-URL =
    Quellen
      .Karte((Element) => $(Element).attr('Quellensatz'))
      .Filter((srcset) => Quellsatz)
      .Karte((srcset) => Quellsatz.gespalten(',')[0].trimmen().gespalten('')[0])
      .gefunden((URL) => URL) || null;
  lassen App-Beschreibung = $('.Abschnitt__Beschreibung').Text().trimmen();
  appDescription = App-Beschreibung.ersetzen(/^Beschreibung\s*/, '');

  Rückkehr { Bild-URL, Anwendungsbeschreibung };
}

Funktion scrapeRatingsAndReviews($) {
  const Bewertungen = [];
  $(„.wir-Kundenbewertung“).jeder((Index, Element) => {
    const Sterne = $(Element).gefunden('.we-star-rating').attr(„Arien-Etikett“);
    const Gutachtername = $(Element).gefunden('.wir-kundenbewertung__benutzer').Text().trimmen();
    const Bewertungstitel = $(Element).gefunden('.we-customer-review__title').Text().trimmen();
    const fullReviewText = $(Element).gefunden('.we-customer-review__body').Text().trimmen();
    const Überprüfungsdatum = $(Element).gefunden('.we-customer-review__date').attr('Datum/Uhrzeit');
    Bewertungen.drücken({Sterne, Name des Rezensenten, Titel der Rezension, vollständiger Rezensionstext, Datum der Rezension});
  });

  Rückkehr Bewertungen;
}

Funktion scrapeInformationSection($) {
  const Informationen = {};
  $('dl.information-list dt').jeder((Index, Element) => {
    const Schlüssel = $(Element).Text().trimmen();
    const Wert = $(Element).weiter('tt').Text().trimmen();
    if (Schlüssel && Wert) {
      const camelKey = toCamelCase(Schlüssel);
      if (camelKey === „Sprachen“) {
        Informationen[camelKey] = _.uniq(Wert.gespalten(',').Karte((ausgleichen ) => Artikel.trimmen())).sortieren();
      } sonst if (camelKey === 'Kompatibilität') {
        Informationen[camelKey] = _.uniq(
          Wert
            .gespalten('\n')
            .Karte((ausgleichen ) => Artikel.trimmen())
            .Filter((ausgleichen ) => Artikel),
        ).sortieren();
      } sonst {
        Informationen[camelKey] = Wert;
      }
    }
  });

  Rückkehr Information;
}

Funktion scrapeRelatedAppsAndRecommendations($) {
  Funktion extractAppsFromSection(ÜberschriftText) {
    const Ergebnisse = [];
    $('h2.Abschnitt__Überschrift').jeder((Index, Element) => {
      const aktuellerÜberschriftText = $(Element).Text().trimmen();
      if (aktuellerÜberschrifttext === Überschriftentext) {
        const übergeordnetes Element = $(Element).Elternteil();
        const nächstesGeschwister = Elternteil.weiter();
        nächstesGeschwister.gefunden(„a.we-lockup--in-app-shelf“).jeder((appIndex, appElement) => {
          const Anwendungstitel = $(Anwendungselement).gefunden('.we-lockup__title').Text().trimmen();
          const appUrl = $(appElement).attr('href');
          if (Anwendungstitel && Anwendungs-URL) {
            Ergebnisse angezeigtdrücken({
              Titel: App-Titel,
              URL: appUrl,
            });
          }
        });
      }
    });

    Rückkehr Ergebnisse;
  }

  Rückkehr {
    Entwickler-Apps: extractAppsFromSection(„Mehr von diesem Entwickler“),
    verwandte Apps: extractAppsFromSection(„Das könnte Ihnen auch gefallen“),
  };
}

Funktion scrapeAppStore(html) {
  const $ = Prost.Belastung(html);
  const Daten = {
    primäreAppDetails: {
      ...scrapePrimaryAppDetails($),
    },
    appPreviewAndDescription: {
      ...scrapeAppPreviewAndDescription($),
    },
    Bewertungen und Rezensionen: {
      Rezensionen: scrapeRatingsAndReviews($),
    },
    Informationsabschnitt: {
      ...scrapeInformationSection($),
    },
    Verwandte Apps und Empfehlungen: {
      ...scrapeRelatedAppsAndRecommendations($),
    },
  };

  Rückkehr Daten;
}

const html = – warten auf Sie! crawlAppStore();
const Daten = scrapeAppStore(html);
trösten.Log(JSON.stringifizieren(Daten, null, 2));

Und wenn Sie Ihr Skript ausführen:

1
npm-Lauf crawlen

Sie sehen die Ausgabe in dieser Struktur:

Ein Bild, das eine strukturierte JSON-Ausgabe zeigt, die durch Scraping des Apple App Store erhalten wurde.

Diese organisierte Struktur bietet eine solide Grundlage für weitere Analysen, Berichte oder Visualisierungen, unabhängig von Ihrem Endziel.

Entdecken Sie unsere vollständiger Code in unserem GitHub-Repository für diesen Blog.

Scrapen Sie Apple Store-Daten mit Crawlbase

Das Scraping des Apple App Store kann wertvolle Einblicke in die Präsentation von Apps, die Nutzerreaktionen und die Leistung der Konkurrenz liefern. Mit Crawlbase und einem soliden HTML-Parser wie Cheerio können Sie die Extraktion von Apple-Daten automatisieren und in etwas Verwertbares umwandeln.

Mit dieser Konfiguration können Sie Zeit und Mühe sparen und gleichzeitig die benötigten Daten erhalten, wenn Sie Bewertungen verfolgen, Preise vergleichen oder einfach das App-Ökosystem erkunden möchten.

Starten Sie jetzt Ihr nächstes Scraping-Projekt mit Crawlbase Smart AI Proxy und Crawling API um eine Blockierung zu vermeiden!

Häufig gestellte Fragen

F: Kann ich jede App im App Store scrapen?

A. Ja, sofern Sie die öffentliche URL der App haben. Apple stellt keinen vollständigen öffentlichen Index zur Verfügung, daher müssen Sie Ihre Liste selbst erstellen oder Links aus anderen Quellen sammeln.

A. Es ist normalerweise akzeptabel, öffentliche Daten für Forschungszwecke oder den persönlichen Gebrauch zu scrapen, aber stellen Sie sicher, dass Ihre Nutzung den Apples Servicebedingungen. Vermeiden Sie übermäßiges Scraping und Nutzungsbeschränkungen.

F: Was passiert, wenn ich blockiert oder meine Geschwindigkeit eingeschränkt werde?

A. Wenn zu viele Anfragen von derselben IP-Adresse gesendet werden oder das Verhalten automatisiert erscheint, können Scraping-Websites blockiert oder ihre Raten begrenzt werden. Um solche Probleme zu vermeiden, können Sie Folgendes verwenden: Crawlbase Crawling API und Smart AI ProxySie umfassen Antiblockierungsfunktionen wie IP-Geolokalisierung und -Rotation, die die Wahrscheinlichkeit einer Blockierung erheblich verringern und eine genauere Datenerfassung ermöglichen.