So scrapen Sie den Apple App StoreBewertungen, Rezensionen und Metadaten

Der Apple App Store enthält Millionen von App-Einträgen, und jeder öffentliche Eintrag enthält die Art von strukturierten Details, die Produktteams, Marketingfachleute und Analysten interessieren: der App-Name, der Entwickler, die Sternebewertung, die Anzahl der Rezensionen, die Kategorie und der Preis. Diese Daten manuell abzurufen, skaliert nicht über eine Handvoll Apps hinaus. Der praktische Schritt ist daher, einen App Store Scraper in Python zu erstellen, der eine Eintragsseite abruft, die gewünschten Felder parst und einen sauberen Datensatz zurückliefert.

Diese Anleitung führt genau das durch. Sie rufen gerenderte App-Store-Eintragsseiten über die Crawling API mit dem offiziellen Python-Client crawlbase ab, parsen das Markup mit BeautifulSoup und extrahieren einen strukturierten Datensatz für jede App. Die gesamte Anleitung ist auf öffentliche Eintragssdaten beschränkt, und der rechtliche Abschnitt am Ende ist kein Boilerplate, also lesen Sie ihn, bevor Sie das Tool auf echtes Volumen anwenden.

Was Sie erstellen werden

Ein Python-Skript, das eine öffentliche App-Store-URL entgegennimmt, das gerenderte HTML über die Crawling API abruft und einen strukturierten Datensatz extrahiert. Wir verwenden eine bekannte kostenlose App als laufendes Beispiel und ziehen diese Felder heraus:

• App-Name der Eintragstitel, zum Beispiel "Microsoft Authenticator".
• Entwickler der Herausgeber oder Anbieter, wie "Microsoft Corporation".
• Bewertung der durchschnittliche Sternewert, etwa "4.8".
• Rezensionsanzahl die Anzahl der Bewertungen hinter diesem Wert.
• Kategorie die App-Store-Kategorie, unter der die App geführt wird.
• Preis der gelistete Preis oder "Kostenlos", wenn keiner vorhanden ist.

Warum ein einfacher Fetch beim App Store Schwierigkeiten macht

Wenn Sie eine App-Store-Eintrags-URL mit einem einfachen HTTP-Client abrufen, stoßen Sie auf zwei Probleme. Erstens setzt die Eintragsseite auf JavaScript, um Teile ihres Inhalts zu befüllen, sodass das zurückgegebene rohe HTML die gesuchten Felder fehlen lassen kann. Zweitens achtet Apple auf automatisierten Traffic: Datacenter-IPs und Anfragenmuster, die nicht wie ein echter Browser aussehen, werden herausgefordert oder gedrosselt, bevor das nützliche Markup erreicht wird.

Ein funktionierender App-Store-Scraper benötigt also zwei Dinge in einer Anfrage: einen Browser, der die Seite tatsächlich rendert, und eine IP, die die Plattform als echten Besucher einliest. Sie können das selbst mit einem Headless-Browser plus einem Pool rotierender residenzieller Proxys zusammensetzen, aber deren Zusammenspiel und Wartung ist der größte Teil der Arbeit. Die Crawling API vereint beides in einem einzigen Aufruf: Sie senden die URL, sie rendert die Seite hinter einer vertrauenswürdigen IP und gibt fertiges HTML zum Parsen zurück.

Voraussetzungen

Sie benötigen ein paar Dinge, bevor Sie Code schreiben. Keines davon dauert lange.

Grundlegende Python-Kenntnisse. Sie sollten mit dem Schreiben und Ausführen eines Python-Skripts sowie der Installation von Paketen mit pip vertraut sein. Wenn Sie neu in der Sprache sind, bringen Sie die offiziellen Python-Docs und ein Einsteigerkurs auf das Niveau, das dieses Tutorial voraussetzt.

Python 3.8 oder neuer. Prüfen Sie Ihre Version mit python --version. Falls nicht vorhanden, installieren Sie es von python.org oder über eine Distribution wie Anaconda.

Ein Crawlbase-Konto und Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihr Token von der Account-Docs-Seite. Verwenden Sie das JavaScript-Token (JS-Token) für App-Store-Einträge. Behandeln Sie das Token wie ein Passwort: Es authentifiziert Ihre Anfragen, halten Sie es also aus der Versionskontrolle heraus.

Das Projekt einrichten

Erstellen Sie eine virtuelle Umgebung, damit Projektabhängigkeiten isoliert bleiben, und installieren Sie dann die zwei Bibliotheken, die der Scraper benötigt.

python --version

python -m venv appstore_env
source appstore_env/bin/activate

pip install crawlbase beautifulsoup4

Unter Windows aktivieren Sie die Umgebung mit appstore_env\Scripts\activate anstelle der source-Zeile. Zwei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Client für die Crawling API, und beautifulsoup4 parst das zurückgegebene HTML, sodass Sie einzelne Felder per CSS-Selektor herausziehen können. Wenn Sie eine Auffrischung zur Parsing-Bibliothek möchten, behandelt der Leitfaden zu BeautifulSoup in Python die unten verwendeten Selektoren.

Schritt 1: Das gerenderte Listing abrufen

Beginnen Sie damit, die fertige Seite abzurufen. Importieren Sie die CrawlingAPI-Klasse, initialisieren Sie sie mit Ihrem Token und fordern Sie die App-URL an. Das Prüfen des Statuscodes vor dem Parsen macht Fehler laut statt stumm.

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

Die zwei Wait-Optionen helfen bei spät rendernden Elementen. ajax_wait weist die API an, auf das Beenden asynchroner Inhalte zu warten, und page_wait hält eine feste Anzahl Millisekunden nach dem Laden inne, damit spät rendernde Teile vor der Seitenerfassung erscheinen. Drei Sekunden sind ein vernünftiger Ausgangswert; erhöhen Sie ihn, wenn Felder leer zurückkommen. Führen Sie das Skript mit python scraper.py aus und Sie sollten echtes Eintragsinventar sehen, keine abgespeckte Hülle. Das bestätigt, dass das Rendering funktioniert, bevor Sie einen einzigen Selektor schreiben.

Schritt 2: Die App-Felder mit BeautifulSoup parsen

Mit gerendertem HTML in der Hand laden Sie es in BeautifulSoup und ziehen jedes Feld per Selektor heraus. App-Store-Einträge legen die Kerndetails in einer vorhersehbaren Struktur dar, sodass Sie Name, Entwickler, Bewertung, Rezensionsanzahl, Kategorie und Preis einzelnen Selektoren zuordnen können. Verpacken Sie die Extraktion in Hilfsfunktionen, damit ein fehlendes Feld nicht den gesamten Run zum Absturz bringt.

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"),
    }

Die Hilfsfunktion text_of erledigt zwei nützliche Dinge auf einmal: Sie fragt ein einzelnes Element ab und gibt None zurück, wenn das Element fehlt, anstatt bei einem .get_text()-Aufruf auf nichts eine Exception zu werfen. Das macht die Extraktion robust, wenn ein Feld in einem bestimmten Eintrag fehlt. Der Bewertungsstring im App Store packt sowohl den Sternewert als auch die Rezensionsanzahl in einen Wert, getrennt durch einen Mittelpunkt, sodass wir ihn einmal aufteilen und beide Teile zuweisen, mit None als Standardwert, wenn das Format nicht übereinstimmt.

Schritt 3: Alles zusammensetzen

Verdrahten Sie jetzt den Abruf und das Parsen in ein ausführbares Skript. Rufen Sie das gerenderte HTML ab, übergeben Sie es an den Parser und geben Sie den strukturierten Datensatz aus.

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

Wie die Ausgabe aussieht

Führen Sie das vollständige Skript mit python scraper.py aus und erhalten Sie einen sauberen, strukturierten Datensatz für die App, bereit zum Schreiben in JSON, CSV oder eine Datenbank.

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

Auf viele Apps skalieren

Ein Eintrag ist eine Demo; ein echter Job läuft über eine Liste von Apps. Die Form bleibt gleich: Behalten Sie eine Liste von App-URLs, rufen Sie jede über die Crawling API ab, parsen Sie sie mit derselben Funktion und sammeln Sie die Zeilen. Da jeder Eintrag dieselbe Struktur teilt, funktioniert der bereits geschriebene Parser für alle ohne Änderungen. Das Detail, das bei Volumen zählt, ist das Tempo: Verteilen Sie die Anfragen, damit Sie wie ein Strom normaler Besucher wirken und nicht wie eine enge Schleife.

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)

Der time.sleep-Aufruf zwischen Anfragen ist bewusst. Auch wenn die Crawling API IPs für Sie rotiert, hält das Tempo Ihren Run höflich und vorhersehbar, und es gibt jeder gerenderten Seite Zeit zurückzukommen, ohne Anfragen aufeinander zu stapeln. Wenn Sie auch App-Rezensionen erfassen möchten, erweitert sich dasselbe Fetch-then-Parse-Muster auf den Rezensionsabschnitt; der Leitfaden zum Scrapen von Kundenrezensionen behandelt diese Form ausführlicher.

Strukturierte App-Daten ohne Scraping

Das Scrapen der öffentlichen Eintragsseite ist das richtige Werkzeug, wenn Sie genau das brauchen, was ein Besucher sieht, und keine API das zurückgibt. Für reine strukturierte App-Metadaten bietet Apple jedoch offizielle Kanäle, die sauberer und stabiler als das Parsen von Markup sind, und Sie sollten diese bevorzugen, wenn sie Ihren Bedarf decken.

• iTunes Search API und App Store RSS-Feeds. Apples öffentliche iTunes Search API gibt App-Details (Name, Entwickler, Durchschnittsbewertung, Bewertungsanzahl, Kategorie, Preis und mehr) als JSON zurück, und die App-Store-RSS-Feeds veröffentlichen bewertete Listen der Top-kostenlosen, kostenpflichtigen und trendigen Apps. Für strukturierte Metadaten auf Eintragsebene sind diese der erste Griff.
• App Store Connect API. Wenn es sich um Ihre eigenen Apps handelt, gibt Ihnen die App Store Connect API First-Party-Zugriff auf Ihre Einträge, Verkäufe und Analysen unter Ihrem Entwicklerkonto, ohne Scraping.

Greifen Sie auf den Scraper zurück, wenn Sie Daten benötigen, die die offiziellen Feeds nicht bereitstellen, oder wenn Sie eine Ansicht über viele Einträge von Drittanbietern zusammenstellen. Für alles, was die iTunes Search API und RSS-Feeds bereits als JSON zurückgeben, nutzen Sie diese zuerst.

Nicht blockiert werden

Selbst mit gehandhabtem Rendering achtet Apple auf scraper-förmigen Traffic. Einige Gewohnheiten halten einen Run gesund und gelten für jedes schwierige kommerzielle Ziel.

• Tempo Ihrer Anfragen. Listings in einer engen Schleife zu hämmern ist der schnellste Weg, gedrosselt zu werden. Verteilen Sie Anfragen und variieren Sie Ihre Ziele, anstatt einen Pfad mit voller Geschwindigkeit zu crawlen.
• Auf Rotation setzen. Ein Pool residenzieller IPs verteilt Anfragen über viele echte Nutzeradressen, sodass keine einzelne ein Rate-Limit auslöst. Die Crawling API erledigt das für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, den Sie richtig machen müssen.
• Statuscodes lesen. Ein Run, der beginnt, Herausforderungen oder Fehler zurückzugeben, sagt Ihnen, dass die aktuelle Rate oder IP-Stufe nicht mehr ausreicht. Behandeln Sie das als Signal zum Zurückhalten, nicht als Rauschen, das Sie ignorieren können.

Für das breitere Playbook lesen Sie den tiefen Einblick in wie man CAPTCHAs beim Web Scraping umgeht und den Leitfaden zum Scrapen von JavaScript-Seiten mit Python. Wenn Sie lieber Ihren eigenen Traffic durch einen rotierenden Pool routen möchten, anstatt die verwaltete API zu verwenden, gibt Ihnen der Smart AI Proxy (auch als AI Proxy bezeichnet) dieselbe residenzielle IP-Rotation als Drop-in-Proxy-Endpunkt.

Ist es legal, den App Store zu scrapen?

Ob das Scrapen des App Store erlaubt ist, hängt von Apples Nutzungsbedingungen, Ihrer Gerichtsbarkeit und dem ab, was Sie mit den Daten tun. Apples Bedingungen schränken den automatisierten Zugriff ein, sodass Scraping unabhängig von der Sorgfalt Ihres Toolings gegen diese Bedingungen verstoßen kann. Keiner der hier stehenden Code ändert das; er macht nur den technischen Teil funktionsfähig. Lesen Sie Apples Nutzungsbedingungen und die App-Store-robots.txt und behandeln Sie beides als Grenze für das, was Sie sammeln.

Einige Linien, die es wert sind, eingehalten zu werden. Sammeln Sie nur öffentliche App-Eintragsdaten: den App-Namen, Entwickler, Bewertung, Rezensionsanzahl, Kategorie und Preis, die jeder ohne Konto sehen kann. Respektieren Sie Apples angegebene Rate-Erwartungen und halten Sie Ihr Anfragevolumen niedrig genug, dass Sie seine Server nicht belasten. Diese Anleitung ist bewusst auf öffentliche Eintragsseiten beschränkt, weil das die Linie ist, die die Arbeit verteidigbar hält. Sie behandelt keine Konto- oder persönlichen Daten, login-gesperrte Seiten, etwas hinter einem Sign-in oder jeden Versuch, die Authentifizierung zu umgehen. Diese sind hier außerhalb des Rahmens, und das Erreichen dieser Daten verstößt gegen Apples Bedingungen.

Für strukturierte App-Daten bevorzugen Sie Apples offizielle Kanäle. Die App Store Connect API gibt First-Party-Zugriff auf Ihre eigenen Apps, und die öffentliche iTunes Search API und App-Store-RSS-Feeds geben App-Metadaten als JSON zurück, ohne eine einzige Seite zu scrapen. Wenn ein offizieller Feed Ihren Bedarf deckt, ist er das richtige Werkzeug; der Scraper in dieser Anleitung ist für öffentliche Eintragsdaten, die die Feeds nicht bereitstellen, und nichts weiter.

Häufig gestellte Fragen

Warum gibt ein einfacher Fetch unvollständige Daten vom App Store zurück?

Weil App-Store-Einträge Teile ihres Inhalts clientseitig mit JavaScript rendern. Eine rohe HTTP-Anfrage kann mit der Seitenhülle, aber ohne Felder wie Bewertung oder Kategorie zurückkommen, da diese erst nach dem Ausführen der Skripte der Seite in einem Browser ausgefüllt werden. Das JS-Token der Crawling API rendert die Seite zuerst, sodass die Felder vorhanden sind, wenn BeautifulSoup sie parst.

Brauche ich das normale Token oder das JS-Token für den App Store?

Verwenden Sie das JS-Token. Das normale Token ruft statisches HTML ab, was im App Store einige Eintragsfelder leer lassen kann. Das JS-Token rendert die Seite in einem echten Browser, bevor es das HTML zurückgibt, sodass Name, Entwickler, Bewertung, Rezensionsanzahl, Kategorie und Preis beim Parsen vorhanden sind.

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

Ja. Die öffentliche iTunes Search API gibt App-Details als JSON zurück (Name, Entwickler, Durchschnittsbewertung, Bewertungsanzahl, Kategorie, Preis und mehr), und die App-Store-RSS-Feeds veröffentlichen bewertete Top-App-Listen. Für Ihre eigenen Apps gibt die App Store Connect API First-Party-Zugriff auf Einträge und Analysen. Bevorzugen Sie diese offiziellen Kanäle für strukturierte Metadaten, und greifen Sie auf Scraping zurück, wenn Sie öffentliche Eintragsdaten benötigen, die die Feeds nicht bereitstellen.

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

Höchstwahrscheinlich Apples Markup. Die we-rating-count-Marker, product-header-Elemente und Information-List-Zeilen ändern sich ohne Vorankündigung, sodass Selektoren, die letzten Monat funktioniert haben, brechen können. Überprüfen Sie einen Live-Eintrag in den Dev-Tools Ihres Browsers und aktualisieren Sie die Selektoren. Periodische Selektor-Wartung ist bei jedem Produktions-Scraper normal.

Kann ich Konto- oder persönliche Daten vom App Store scrapen?

Nein, und diese Anleitung behandelt das nicht. Kontodaten, Kaufhistorie und alles hinter einem Sign-in sind keine öffentlichen Daten. Das Scrapen von login-gesperrten Inhalten oder das Umgehen der Authentifizierung, um diese zu erreichen, ist hier außerhalb des Rahmens und verstößt gegen Apples Bedingungen. Für First-Party-Daten über Ihre eigenen Apps ist die App Store Connect API der richtige Weg.

Wie vermeide ich Blockierungen beim Scrapen des App Store?

Halten Sie Ihre Anfragerate pro IP niedrig, variieren Sie Ihre Ziele anstatt eine Schleife über einen Pfad zu drehen, und routen Sie über rotierende residenzielle IPs, sodass keine einzelne Adresse ein Rate-Limit auslöst. Die Crawling API verwaltet Rotation und einen vertrauenswürdigen IP-Pool für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, in den Sie investieren sollten. Beobachten Sie die Statuscodes und weichen Sie zurück, wenn Sie beginnen, Herausforderungen zu sehen.

HI

Hamza Ikhlaq

Softwareentwickler · Crawlbase

Softwareentwickler bei Crawlbase, der praxisnahe Anleitungen zum Scraping von Zielseiten, zu Proxys und zur Crawling API schreibt.