App Store Scraper - iOS & Google Play Apps & Reviews

Scrape app listings from Apple App Store and Google Play Store. Extract app names, ratings, reviews, prices, download counts, developer info, screenshots, and more. Search by keyword or scrape specific app URLs directly.

Optionally generate AI-powered ASO (App Store Optimization) analysis with keyword opportunities, competitor benchmarking, market positioning, and actionable recommendations for mobile marketers.

Features

• Dual store support: Scrape both Apple App Store and Google Play in a single run, or target one store
• Search scraping: Enter keywords like "fitness tracker" or "photo editor" to find and scrape matching apps
• Direct URL scraping: Provide specific App Store or Google Play URLs for detailed extraction
• Apple App Store: Uses the official iTunes Search API — fast, reliable, returns structured JSON with 30+ fields per app
• Google Play: Server-rendered HTML scraping with rating, install count, developer, and metadata extraction
• User reviews: Scrape up to 500 reviews per Apple app (via iTunes RSS paging) or visible Google Play reviews — configurable via maxReviews. Apple supports both mostRecent and mostHelpful sort orders.
• Per-review sentiment + topic + urgency (free): Every review is automatically graded with sentiment (positive/neutral/negative), topic tags (crash, bug, login, pricing, feature_request, ux, performance, ads, privacy, update, praise, support), urgency (low/medium/high), and a churn-signal flag — with a per-app roll-up (review_sentiment_summary). Free, deterministic, runs without any LLM API key. Turns the scraper into a PM + churn-alert tool on top of the raw listing data.
• Reputation-delta watch mode: Opt in with trackReputation=true to persist per-app sentiment history across runs in a named key-value store. Each subsequent run computes negative_rate_delta, urgency_high_delta, churn_signal_delta, new_topic_tags_emerged, fading_topic_tags, and a sentiment_trend (improving/declining/stable), and emits a single reputation_change_digest summary row so PM dashboards can pivot on the biggest shifts. Pair with a scheduled weekly run against your app + top-N competitors to turn the scraper into a reputation watchdog.
• AI ASO analysis: Competitive analysis, keyword opportunities, market gaps, and optimization recommendations
• Multi-LLM support: Choose between OpenRouter (recommended — 300+ models), Anthropic (Claude), Google AI (Gemini), OpenAI, or Ollama (self-hosted) for AI analysis
• Global coverage: Search any country's app store with country code parameter (US, UK, DE, JP, etc.)
• Pay-per-result pricing: Only pay for apps successfully scraped

Data Extracted

Apple App Store Fields

Field	Description
app_id	Numeric App Store ID
bundle_id	App bundle identifier (e.g., com.example.app)
name	App name
developer	Developer/publisher name
developer_id	Developer's App Store ID
developer_url	Link to developer's App Store page
price	Numeric price (0 for free apps)
formatted_price	Display price string (e.g., "Free", "$4.99")
currency	Currency code (USD, EUR, etc.)
rating	Average user rating (out of 5)
rating_count	Total number of ratings
current_version_rating	Rating for the current version
description	App description (first 1000 characters)
release_notes	Latest version release notes
version	Current version number
icon_url	App icon image URL (512px)
screenshots	Up to 5 iPhone screenshot URLs
size_bytes	App download size in bytes
primary_genre	Main category (Games, Productivity, etc.)
genres	All categories the app belongs to
content_rating	Age rating (4+, 9+, 12+, 17+)
minimum_os_version	Minimum iOS version required
supported_devices	Number of supported device types
languages	Supported language codes
release_date	Original release date
updated_date	Last update date
app_url	Direct link to the App Store listing (legacy — prefer url)
url	Portfolio-standard direct link (same value as app_url)

Google Play Fields

Field	Description
app_id	Package name (e.g., com.example.app)
name	App name
developer	Developer/publisher name
rating	Average user rating (out of 5)
rating_count	Total number of ratings
installs	Install count range (e.g., "10M+")
price	Numeric price (0 for free apps)
description	App description
icon_url	App icon image URL
screenshots	Screenshot image URLs
primary_genre	Main category
content_rating	Content rating label
requires_android	Minimum Android version
updated_date	Last update date
in_app_purchases	Whether app has in-app purchases
contains_ads	Whether app contains ads
app_url	Direct link to the Google Play listing (legacy — prefer url)
url	Portfolio-standard direct link (same value as app_url)

Review Fields (when includeReviews: true)

Each review in reviews[] carries:

Field	Description
author	Reviewer display name
rating	Star rating 1-5
title	Review title (Apple only)
text	Review body text
date	Review date (Apple; ISO 8601)
version	App version reviewed (Apple)
vote_count / vote_sum	Helpful votes (Apple)
sentiment_label	positive / neutral / negative — heuristic classifier
sentiment_score	Float in [-1.0, 1.0] (rating-weighted + lexicon blend)
sentiment_signal	rating / lexicon / both — which signal drove the score
topic_tags	List of tags: crash, bug, login, pricing, feature_request, ux, performance, ads, privacy, update, praise, support
urgency	low / medium / high — escalation priority (high = negative + crash/bug/pricing/login/privacy OR churn signal)
is_churn_signal	true if the review explicitly signals uninstall / unsubscribe / switching

Per-App review_sentiment_summary

When reviews are scraped, each app also gets a rollup object:

"review_sentiment_summary": {
    "review_count": 100,
    "sentiment_counts": {"positive": 58, "neutral": 15, "negative": 27},
    "negative_rate": 0.27,
    "urgency_high_count": 12,
    "churn_signal_count": 5,
    "top_topic_tags": [
        {"tag": "crash", "count": 18},
        {"tag": "pricing", "count": 11},
        {"tag": "praise", "count": 9}
    ]
}

Point a PM dashboard at negative_rate / urgency_high_count / churn_signal_count for each app in your competitive set and you have a churn-risk + complaint-ticker feed, no LLM required.

Reputation-Delta Watch Mode (optional, trackReputation=true)

Adds these fields to every app on every run AFTER the first:

Field	Description
reputation_delta_tracked	true when this app had its sentiment compared against history
negative_rate_previous / negative_rate_delta	Prior run's negative rate + current - previous (float)
urgency_high_previous / urgency_high_delta	Prior high-urgency count + delta (int)
churn_signal_previous / churn_signal_delta	Prior churn-signal count + delta (int)
new_topic_tags_emerged	Topic tags present in this run that were NEVER in prior history
fading_topic_tags	Topic tags seen in prior history but absent this run
sentiment_trend	improving / declining / stable / unknown (vs prior-history mean negative_rate)
reputation_change_detected	true when any threshold (8pp negative-rate / 2 urgency / 2 churn / new topics) crossed
change_kind	new / negative_rate_up / negative_rate_down / urgency_up / urgency_down / churn_up / churn_down / new_topics / none
history_sample_count	Number of prior snapshots stored for this app
first_seen_at / last_seen_at	Earliest + most recent prior snapshot timestamps (ISO 8601)

One reputation_change_digest row per run summarises the biggest movers:

{
    "type": "reputation_change_digest",
    "watch_label": "duolingo",
    "total_apps": 5,
    "apps_tracked": 5,
    "apps_with_history": 3,
    "changes_detected": 2,
    "top_negative_rate_movers": [...],
    "newly_emerged_topics": [...],
    "churn_and_urgency_risers": [...]
}

History is stored in a named Apify key-value store (app-store-reputation-history), keyed by watch label, capped at 52 snapshots per app (roughly one year at weekly cadence). Use distinct watchLabel values to track unrelated keyword clusters without cross-contamination (e.g., my-app, competitor-audit-q2).

Input Configuration

Search Parameters

• Search Query: Keywords to search for (e.g., "fitness tracker", "photo editor", "vpn")
• App URLs: Direct Apple App Store or Google Play URLs to scrape specific apps
• App Store: Which store to search — Both Stores, Apple App Store only, or Google Play only (default: both)
• Country: Country code for regional results — us, gb, de, jp, fr, etc. (default: us)
• Max Apps: Maximum number of apps to scrape per store (1-200, default: 25)
• Include Reviews: Scrape user reviews per app (default: off)
• Max Reviews: How many reviews to pull per app when reviews are included (1-500, default: 10). Apple iTunes RSS supports up to 500 via 10-page pagination; Google Play is limited to what's rendered in the initial HTML (typically 40-80).
• Review Sort (Apple only): mostRecent (default) for fresh user feedback, or mostHelpful for the most-upvoted opinions.

Reputation Watch Mode

• Track Reputation Deltas (trackReputation): Persist per-app sentiment history across runs in a named key-value store (default: off). Auto-enables includeReviews.
• Watch Label (watchLabel): Custom label used as the history slot key. Defaults to searchQuery or first app URL. Use distinct labels (e.g. my-app, duolingo-competitors) so separate tracking campaigns don't overwrite each other.

AI Analysis Settings

• Enable AI Analysis: Toggle AI-powered ASO analysis (default: off)
• LLM Provider: OpenRouter (recommended — 300+ models), Anthropic (Claude), Google AI (Gemini), or Ollama (self-hosted)
• API Key: Your chosen provider's API key
• Model Override: Optional custom model selection

Proxy Settings

Datacenter proxies generally work for both app stores. Apple's iTunes API is public and rarely blocks. Google Play may occasionally require residential proxies for high-volume scraping.

AI ASO Analysis

When enabled, the AI analysis provides:

• Market Overview: Category distribution, pricing trends, average ratings, competitive density
• Keyword Opportunities: High-potential keywords with low competition, long-tail phrases, trending terms
• Competitive Benchmarks: Rating distributions, pricing strategy patterns, feature comparisons across top apps
• Monetization Insights: Free vs. paid vs. freemium ratios, price point analysis, in-app purchase prevalence
• ASO Recommendations: Title optimization suggestions, description keyword placement, screenshot strategy, localization priorities

Example Usage

Search both stores

{
    "searchQuery": "fitness tracker",
    "store": "both",
    "country": "us",
    "maxApps": 25,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
}

Scrape specific app URLs

{
    "appUrls": [
        "https://apps.apple.com/us/app/instagram/id389801252",
        "https://play.google.com/store/apps/details?id=com.instagram.android"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
}

Search with AI analysis

{
    "searchQuery": "meditation app",
    "store": "apple",
    "maxApps": 50,
    "enableAiAnalysis": true,
    "llmProvider": "openrouter",
    "openrouterApiKey": "sk-or-...",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
}

Reputation watch mode (weekly scheduled run against your app + competitors)

{
    "appUrls": [
        "https://apps.apple.com/us/app/duolingo-language-lessons/id570060128",
        "https://apps.apple.com/us/app/babbel-language-learning/id829587759",
        "https://apps.apple.com/us/app/busuu-language-learning/id379968583"
    ],
    "includeReviews": true,
    "maxReviews": 100,
    "reviewSort": "mostRecent",
    "trackReputation": true,
    "watchLabel": "language-learning-apps",
    "proxyConfiguration": {"useApifyProxy": true}
}

Run this on a weekly schedule. Every subsequent run surfaces negative_rate_delta, new_topic_tags_emerged, sentiment_trend, and a reputation_change_digest summary row — exactly the signal feed a PM needs when a competitor ships an update that tanks their reviews.

Search Google Play in Japan

{
    "searchQuery": "ゲーム",
    "store": "google",
    "country": "jp",
    "maxApps": 25,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
}

Pricing

This actor uses pay-per-event pricing — only pay for the results you receive:

Event	Price	Notes
App scraped	$0.003 per app	$3 per 1,000 apps
Review scraped	$0.0002 per review	Only billed when includeReviews is on. Apple feed supports up to 500 reviews/app; $0.10 for a full 500-review pull.
Reputation delta tracked	$0.005 per app	Only billed when trackReputation is on. Covers persistent-history read + delta computation + new-topic detection + digest row.
AI analysis completed	$0.05 per analysis	One flat charge per dataset, regardless of app count.

Cost examples

• 50 apps, no reviews, no AI — $0.15
• 50 apps + 20 reviews each (1,000 reviews), no AI — $0.35
• 5 apps + 100 reviews each + reputation watch (weekly cadence) — $0.14/run (scrape + reviews + reputation)
• 100 apps + AI ASO analysis — $0.35
• 25 apps + 100 reviews each (2,500 reviews) + AI — $0.625

Technical Details

• Apple App Store data comes from the official iTunes Search API — public, no authentication required, returns structured JSON
• Google Play data is extracted from server-rendered HTML pages using BeautifulSoup
• Proxy rotation on each request for resilience against rate limiting
• Polite crawling with 1-3 second delays between Google Play requests
• Exponential backoff with jitter on 403/429 responses
• URL parsing supports both apps.apple.com/*/app/*/id{ID} and play.google.com/store/apps/details?id={ID} formats
• Lightweight httpx-based actor — runs on 256 MB memory

Output Example

{
    "store": "apple",
    "app_id": "389801252",
    "bundle_id": "com.burbn.instagram",
    "name": "Instagram",
    "developer": "Instagram, Inc.",
    "app_url": "https://apps.apple.com/us/app/instagram/id389801252",
    "price": 0.0,
    "currency": "USD",
    "rating": 4.7,
    "rating_count": 28500000,
    "description": "Bringing you closer to the people and things you love...",
    "category": "Photo & Video",
    "content_rating": "12+",
    "version": "325.0.0",
    "release_date": "2010-10-06",
    "size_bytes": 256000000,
    "minimum_os_version": "16.0",
    "languages": ["EN", "AR", "DE", "ES", "FR", "JA", "KO", "ZH"],
    "icon_url": "https://is1-ssl.mzstatic.com/image/...",
    "screenshots": ["https://..."],
    "scraped_at": "2026-04-12T10:30:00Z"
}

Use Cases

• App Market Research: Analyze competitor apps by category, ratings, and pricing across both stores
• ASO (App Store Optimization): Study keyword trends, app titles, and descriptions for optimization strategies
• Investment Due Diligence: Research app ratings, review trends, and market positioning before investing
• Competitive Intelligence: Monitor competitor apps for version updates, rating changes, and new features
• Lead Generation: Build lists of app developers and companies for B2B outreach
• Academic Research: Collect app ecosystem data for studies on mobile app markets and technology adoption

Integration & Export

Export data in multiple formats from Apify:

• JSON — structured data for APIs and analytics platforms
• CSV — import into Google Sheets, Excel, or databases
• Excel — ready for business reporting and presentations

Integrate with 2,000+ apps via Apify connectors: Google Sheets, Slack, Zapier, Make (Integromat), webhooks, and Amazon S3. Schedule recurring runs to monitor app store changes over time.

Frequently Asked Questions

Does this scrape both iOS and Android apps? Yes. Set the store parameter to "both" (default) to search both Apple App Store and Google Play simultaneously for any keyword. You can also set "apple" or "google" to target one store.

Are the reviews included? Yes — set includeReviews: true and configure maxReviews (default 10, up to 500 on Apple). On Apple you can also choose reviewSort: "mostHelpful" for the most-upvoted reviews. Review extraction is billed separately at $0.0002/review so "apps only" runs stay cheap.

What is per-review sentiment and how is it scored? When includeReviews: true, every review is automatically annotated with sentiment_label (positive/neutral/negative), sentiment_score (-1.0 to +1.0), 12 possible topic_tags (crash, bug, login, pricing, feature_request, ux, performance, ads, privacy, update, praise, support), urgency (low/medium/high), and is_churn_signal (true/false). The sentiment score blends the star rating (70%) with a lexicon polarity signal (30%); urgency is rule-based (negative + crash/bug/pricing/login/privacy → high). This layer is deterministic and runs free — no LLM key required. Each app also gets a review_sentiment_summary rollup with counts, negative_rate, urgency_high_count, churn_signal_count, and top topic tags, so you can pipe the dataset straight into a PM / churn dashboard.

How does reputation-delta watch mode work? Set trackReputation: true. The first run stores a per-app sentiment snapshot (negative rate, urgency counts, churn counts, top topic tags) in a named Apify key-value store (app-store-reputation-history). Every subsequent run compares against prior snapshots and annotates each app with negative_rate_delta, urgency_high_delta, churn_signal_delta, new_topic_tags_emerged, fading_topic_tags, a sentiment_trend (improving / declining / stable vs. history mean), and a change_kind tag when a threshold is crossed (8 percentage-point negative-rate swing, or ≥2 urgency / churn count change). One reputation_change_digest summary row is also pushed per run listing the top movers. Use watchLabel to keep separate tracking campaigns in separate history slots. The feature auto-enables includeReviews since it needs review sentiment as input.

Can I scrape apps from different countries? Yes. Set the country parameter to any ISO country code (us, gb, de, jp, kr, etc.) to get localized app listings and pricing.

How accurate are the ratings? Apple App Store ratings come directly from the official iTunes API and are highly accurate. Google Play ratings are extracted from the HTML and may have minor rounding differences.

Limitations

• Apple iTunes Search API returns a maximum of 200 results per query
• Google Play search results are limited by what's rendered in the initial HTML (typically 40-60 apps)
• Google Play HTML structure may change without notice, potentially affecting extraction accuracy
• Apple reviews: up to 500 per app via iTunes RSS pagination (10 pages × ~50); older reviews beyond that are not feed-exposed
• Google Play reviews: only the reviews rendered in the initial HTML are available (typically 40-80); the full review corpus loads via a client-side RPC and is not publicly scrapable without a full browser
• Google Play size, version, and requires_android moved behind a client-side batchexecute RPC in 2023; they return "Not provided" / empty on most pages today
• Per-review sentiment / topic / urgency is a deterministic heuristic layer (lexicon + regex) — great for dashboards and alerting, not a replacement for LLM-grade nuance
• Reputation watch mode needs at least two runs before deltas are meaningful; the first run stores history only (change_kind: "new", history_sample_count: 0). Small review samples (<20 reviews) produce noisy negative_rate deltas — bump maxReviews to 100+ for stable trend signals.
• Some app metadata (exact download numbers, revenue) is not publicly available
• Google Play may serve different content based on geographic IP location

Legal and Compliance

This actor is provided as a technical tool. Users are responsible for ensuring their use complies with:

• Apple Media Services Terms and Conditions — including rules on automated access and redistribution of catalog data
• Google Play Terms of Service
• Applicable data protection laws (GDPR, CCPA, etc.)
• Local laws regarding web scraping and data collection

Data sources used:

• Apple App Store data is fetched via the public iTunes Search API — a documented endpoint Apple provides for third-party use (notably by the Apple Search Partners program). Requires no authentication and returns structured JSON.
• Google Play Store data is extracted from publicly visible storefront HTML. No authenticated account, session cookie, or private endpoint is used.

This actor does not collect or return facial images, private user data, or any content behind a login. The actor implements polite crawling practices with delays between requests and respects rate-limit signals from the target stores.

For questions or concerns, please open an issue on the GitHub repository.

The developer of this actor is not responsible for any misuse or legal consequences arising from its use.