iOS & Android Review Tracker — SensorTower Alt $0.003/app

🧩 Part of the harvestlab MCP suite — 36 RAG-ready, AI-agent-payment-ready Apify actors covering ecommerce, social, travel, news, jobs, EU B2B, dev-tools, and government data. See the full suite →

🤖 MCP-Ready — works as a tool for Claude, Cursor, ChatGPT, and other AI agents via the Apify MCP Server. Typed inputs + structured outputs (dataset_schema) deployed in Cycle 73.

🧰 Works with: LangChain · LangGraph · CrewAI · LlamaIndex · PydanticAI · Mastra AI · Bee AI — call this actor as a tool from any Apify MCP or actor-templates-backed AI framework.

💰 Pay-per-result, not per compute unit — you know your cost BEFORE pressing Run. No surprise compute charges, no monthly minimums, no SaaS subscription. Compare to Apify's default $0.20/CU model where cost depends on actor runtime, memory, and data volume.

🔁 Apify rental alternative — Apify is sunsetting the rental pricing model in October 2026. This Actor is already 100% pay-per-event: drop in as a 1:1 replacement for any rental-based competitor without a contract or monthly minimum.

Both stores in one run. $0.003 per app. No SaaS subscription.

Scrape app listings from the Apple App Store and Google Play in a single run. Extract names, ratings, reviews, prices, install counts, developer info, screenshots, and 30+ structured fields per app. Search by keyword or scrape specific app URLs directly.

The only dual-platform scraper that covers both iOS App Store (official iTunes API — fast, structured) and Google Play (HTML scraping) natively, with free per-review sentiment tagging, reputation-delta watch mode for tracking rating changes across runs, and optional AI-powered ASO analysis.

Why this vs SaaS app-intelligence tools

Tool	Starting price	Dual-store	Per-review sentiment	Reputation deltas	Pay per result
This actor	$0.003 / app	Yes	Yes (free, no LLM)	Yes (built-in)	Yes
SensorTower	$499 / month	Yes	Add-on	Add-on	No (subscription)
AppFigures	$199 / month	Yes	No	Limited	No (subscription)
Appradar	$99 / month	Yes	Add-on	Add-on	No (subscription)
data.ai (App Annie)	Quote-only enterprise	Yes	Add-on	Add-on	No

A weekly reputation watch on 10 competitor apps with 100 reviews each runs $1.40 / month here vs $99–$499 / month for a SaaS seat you don't fully use. Cancel any time — there is no seat, no contract, and the data lands in your Apify dataset as JSON / CSV / Excel.

What it does

App Store Scraper collects app metadata, ratings, and user reviews from both the Apple App Store (via the official iTunes Search API) and Google Play (HTML scraping) in a single run. Search by keyword or supply direct app URLs; results include name, developer, price, rating, install count, screenshots, release notes, and version history.

The scraper delivers three layers of intelligence on top of raw listing data — all without requiring an LLM API key:

Free per-review tagging. Every review is automatically graded for sentiment (positive/neutral/negative), tagged with topics (crash, login, pricing, feature_request, ux, performance, privacy, ads, update, praise, support), assigned an urgency level (low/medium/high), and flagged for churn signal. A review_sentiment_summary roll-up is attached to each app. This runs deterministically with no AI credits spent.

Reputation-delta watch mode. Enable trackReputation=true to persist sentiment history across scheduled runs in a named key-value store. Each subsequent run computes deltas — negative_rate_delta, churn_signal_delta, emerging and fading topic tags — and emits a reputation_change_digest row. Schedule weekly runs against your app and top competitors to get a rolling reputation watchdog without building any infrastructure.

AI ASO analysis. Activate enableAiAnalysis with any of five LLM providers (OpenRouter, Anthropic, Google AI, OpenAI, Ollama) to get keyword opportunities, competitive positioning, market gap analysis, and optimization recommendations.

Mobile marketers, product managers, and competitive intelligence teams use it to monitor app reputation, track competitor reviews at scale, and feed ASO workflows — at $0.003 per app and $0.001 per review.

Features

• Dual store coverage: Scrape both Apple App Store and Google Play in a single run, or target one store — the only actor that covers both platforms natively
• 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 targeted extraction
• Apple App Store (iTunes API): Uses the official iTunes Search API — fast, reliable, returns structured JSON with 30+ fields per app including bundle ID, screenshots, languages, and version history
• Google Play (HTML scraping): Server-rendered HTML extraction with rating, install count, developer, in-app-purchase flag, ad flag, and metadata
• User reviews: Scrape up to 500 reviews per Apple app (via iTunes RSS pagination) or visible Google Play reviews — configurable via maxReviews. Apple supports both mostRecent and mostHelpful sort orders.
• Per-review sentiment + topic + urgency (free, no LLM needed): Every review is automatically annotated with sentiment_label (positive/neutral/negative), sentiment_score (−1.0 to +1.0), 12 possible topic_tags, urgency (low/medium/high), and is_churn_signal (true/false). A per-app review_sentiment_summary rollup includes counts, negative_rate, urgency_high_count, churn_signal_count, and top topic tags. Runs deterministically with no API key.
• 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), plus a reputation_change_digest summary row.
• AI ASO analysis: Competitive analysis, keyword opportunities, market gaps, and optimization recommendations
• Five LLM providers: OpenRouter (recommended — 300+ models), Anthropic (Claude), Google AI (Gemini), OpenAI (GPT), or Ollama (self-hosted)
• Global coverage: Search any country's app store with the country parameter (US, UK, DE, JP, and more)
• Pay-per-result pricing: Only pay for apps and reviews successfully scraped

Use Cases

• App Market Research: Analyze competitor apps by category, ratings, and pricing across both iOS and Android in one dataset
• ASO (App Store Optimization): Study keyword trends, app titles, and descriptions to identify optimization opportunities and gaps
• Reputation Monitoring: Schedule weekly watch-mode runs against your app and top competitors — get delta alerts when a competitor's negative rate spikes or a new complaint topic emerges
• Investment Due Diligence: Research app ratings, review trends, and market positioning before investing in a mobile-first company
• Competitive Intelligence: Track competitor apps for version updates, rating changes, new features, and shifts in user sentiment
• Lead Generation: Build lists of app developers and companies for B2B outreach by category and rating threshold
• Churn Risk Detection: Use free per-review sentiment + churn-signal flags to surface at-risk users before they leave — no LLM key required
• Academic Research: Collect app ecosystem data for studies on mobile app markets, pricing dynamics, and technology adoption
• Product Management: Feed review_sentiment_summary and reputation deltas into PM dashboards for competitor sentiment feeds without building infrastructure

Input

Search Parameters

• Search Query (searchQuery): Keywords to search for (e.g., "fitness tracker", "photo editor", "vpn"). Supports CLI aliases query, q, search, keyword, searchTerm.
• App URLs (appUrls): Direct Apple App Store or Google Play URLs to scrape specific apps. Supports CLI aliases urls, links.
• App Store (store): Which store to search — both (default), apple, or google. Searches both simultaneously when set to both.
• Country (country): Country code for regional results — us, gb, de, jp, fr, etc. (default: us)
• Max Apps (maxApps): Maximum number of apps to scrape per store (1–200, default: 25). CLI aliases: maxResults, maxItems.
• Include Reviews (includeReviews): Scrape user reviews per app (default: off).
• Max Reviews (maxReviews): How many reviews to pull per app (1–500, default: 10). Apple iTunes RSS supports up to 500 via 10-page pagination; Google Play is limited by initial HTML (typically 40–80).
• Review Sort (reviewSort, 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 (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 tracking campaigns don't overwrite each other.

AI Analysis Settings

• Enable AI Analysis (enableAiAnalysis): Toggle AI-powered ASO analysis (default: off). Requires an LLM API key.
• LLM Provider (llmProvider): OpenRouter (recommended — 300+ models), Anthropic (Claude), Google AI (Gemini), OpenAI, or Ollama (self-hosted).
• API Keys: openrouterApiKey, anthropicApiKey, googleApiKey, openaiApiKey — supply the key for your chosen provider.
• Model Override (llmModel): Optional custom model selection (e.g., gpt-4o, claude-opus-4-5). Leave blank for provider default.

Proxy Settings

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

Output

Apple App Store Fields

Field	Description
store	"apple"
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
seller_name	Legal seller name from the iTunes API
price	Numeric price (0.0 for free apps, null if not extracted)
is_free	true if the app is free
formatted_price	Display price string (e.g., "Free", "$4.99")
currency	ISO 4217 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 only
current_version_rating_count	Rating count 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 (512 px)
screenshots	Up to 5 iPhone screenshot URLs
ipad_screenshots	Up to 3 iPad screenshot URLs
in_app_purchases	Whether the app has in-app purchases
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 (ISO 8601)
updated_date	Last update date (ISO 8601)
url	Portfolio-standard direct link to the App Store listing
app_url	Legacy alias for url (kept for backward compatibility)
search_query	The search query used (empty when scraping direct URLs)
country	Country code used for the request
scraped_at	ISO 8601 timestamp of when this record was scraped

Google Play Fields

Field	Description
store	"google"
app_id	Package name (e.g., com.example.app)
name	App name
developer	Developer/publisher name
developer_url	Link to developer's Google Play page
rating	Average user rating (out of 5)
rating_count	Total number of ratings
installs	Install count string (e.g., "10M+")
price	Numeric price (0.0 for free apps, null if not extracted)
is_free	true if the app is free
formatted_price	Display price string (e.g., "Free", "$2.99")
currency	ISO 4217 currency code
description	App description (first 1000 characters)
version	App version (when available from structured data)
icon_url	App icon image URL
screenshots	Screenshot image URLs
size	Size string (e.g., "45 MB") or "Not provided"
size_bytes	Size in bytes parsed from size, or null
primary_genre	Main category
content_rating	Content rating label
requires_android	Minimum Android version (when available)
updated_date	Last update date
in_app_purchases	Whether app has in-app purchases
contains_ads	Whether app contains ads
url	Portfolio-standard direct link to the Google Play listing
app_url	Legacy alias for url (kept for backward compatibility)
search_query	The search query used (empty when scraping direct URLs)
country	Country code used for the request
scraped_at	ISO 8601 timestamp of when this record was scraped

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 (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 from: crash, bug, login, pricing, feature_request, ux, performance, ads, privacy, update, praise, support
urgency	low / medium / high — escalation priority
is_churn_signal	true if the review 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}
    ]
}

Reputation-Delta Watch Mode Fields (when trackReputation: true)

Added to every app on every run after the first:

Field	Description
negative_rate_delta	Current − previous negative rate (float)
urgency_high_delta	Current − previous high-urgency count (int)
churn_signal_delta	Current − previous churn-signal count (int)
new_topic_tags_emerged	Topic tags new in this run vs. prior history
fading_topic_tags	Topic tags seen in history but absent this run
sentiment_trend	improving / declining / stable / unknown
reputation_change_detected	true when any threshold crossed
change_kind	new / negative_rate_up / urgency_up / churn_up / new_topics / none
reputation_delta_tracked	true when this app was enrolled in watch mode this run

One reputation_change_digest row per run summarises the biggest movers.

Pricing

Event	Price	Notes
App scraped	$0.003 per app	$3 per 1,000 apps
Review scraped	$0.001 per review	Only billed when includeReviews is on
Reputation delta tracked	$0.005 per app	Only when trackReputation is on
AI analysis completed	$0.05 per run	One flat charge per dataset

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 — $0.14/run
• 25 apps + 100 reviews each (2,500 reviews) + AI — $0.625

vs. commercial alternatives: AppFollow charges $31+/mo and Sensor Tower uses premium subscription pricing for App Store and Google Play data APIs. This actor uses pay-per-event with no subscription: $0.003/app, $0.001/review and zero monthly fees.

Output Example

{
    "store": "apple",
    "app_id": "389801252",
    "bundle_id": "com.burbn.instagram",
    "name": "Instagram",
    "developer": "Instagram, Inc.",
    "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...",
    "primary_genre": "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"
}

Quick Start

Scrape the top apps from both stores in 2 minutes:

{
    "searchQuery": "productivity apps",
    "store": "both",
    "country": "us",
    "maxApps": 10,
    "proxyConfiguration": {"useApifyProxy": true}
}

Returns 10 apps per store (20 total) with ratings, pricing, and metadata. Cost: $0.06.

Search with reviews and sentiment tagging:

{
    "searchQuery": "fitness tracker",
    "store": "both",
    "country": "us",
    "maxApps": 25,
    "includeReviews": true,
    "maxReviews": 20,
    "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"
    ],
    "includeReviews": true,
    "maxReviews": 50,
    "proxyConfiguration": {"useApifyProxy": true}
}

Reputation watch mode (weekly schedule 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 — exactly the signal feed a PM needs when a competitor ships an update that tanks their reviews.

Search with AI ASO analysis:

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

Search Google Play in Japan:

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

Reputation Watch — 10 competitor apps for ~$3/mo

Schedule a daily run on 10 competitor apps to track rating drift, review-volume spikes, and reputation deltas. Each subsequent run emits negative_rate_delta, new_topic_tags_emerged, sentiment_trend, and a reputation_change_digest summary row when scores change vs prior runs.

{
  "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",
    "https://play.google.com/store/apps/details?id=com.duolingo",
    "https://play.google.com/store/apps/details?id=com.babbel.mobile.android.en",
    "https://play.google.com/store/apps/details?id=com.busuu.android.enc",
    "https://apps.apple.com/us/app/memrise-language-learning/id635966718",
    "https://apps.apple.com/us/app/drops-language-learning/id939540320",
    "https://apps.apple.com/us/app/lingq-language-learning/id468560794",
    "https://apps.apple.com/us/app/rosetta-stone-learn-languages/id435588892"
  ],
  "country": "us",
  "includeReviews": true,
  "maxReviews": 50,
  "trackReputation": true,
  "watchLabel": "language-learning-apps",
  "enableAiAnalysis": false
}

Setup:

1. Replace the placeholder app URLs with real competitor App Store / Google Play listings.
2. Save & Build.
3. Schedule daily 8am: cron 0 8 * * *.
4. Wire reputation-change digest items into Slack / email via Apify's native integrations (the actor itself does not POST to webhooks).
5. After day-1 baseline, day-2+ runs surface reputation-delta fields on every app plus a reputation_change_digest summary row.

Cost math: Per run: 10 apps × $0.003 + ~500 reviews × $0.001 + ~3 deltas × $0.005 = ~$0.545/day. Annual: ~$199/yr. AppFigures: $199/mo = $2,388/yr — savings of $2,189.

MCP Quickstart — call this actor from Claude / Cursor / ChatGPT

Install the Apify MCP server in your AI agent of choice:

# Claude Code
claude mcp add apify -- npx -y @apify/actors-mcp-server --token YOUR_APIFY_TOKEN

# Claude Desktop / Cursor (add to mcp.json):
{"mcpServers":{"apify":{"command":"npx","args":["-y","@apify/actors-mcp-server","--token","YOUR_APIFY_TOKEN"]}}}

Then prompt the agent:

"Use the harvestlab/app-store-scraper actor on Apify to monitor reputation deltas across 10 competitor productivity apps on iOS + Google Play, daily, with churn-signal alerts. Push the results back as JSON."

The agent will discover the actor's dataset_schema.json, generate the right input, run it, and pipe the typed output back into your conversation.

Use with AI agents

app-store-scraper's output is agent-ready — every run returns iOS + Google Play listings, ratings, version history, per-review sentiment / topic / urgency tags, and an optional reputation_change_digest watch row as structured JSON. Wrap this actor as a tool inside an ASO agent, app-product-management workflow, or reputation-monitoring pipeline and replace a SensorTower ($499/mo) / AppFigures ($199/mo) / Appradar ($99/mo) seat at $0.003 per app — the only dual-store option in the bunch.

LangChain — track_app_reputation tool (SensorTower\AppFigures\Appradar alternative):

from langchain.tools import Tool
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

def track_app_reputation(params: dict) -> list:
    run = client.actor("harvestlab/app-store-scraper").call(run_input={
        "appUrls": params["appUrls"],
        "includeReviews": params.get("includeReviews", True),
        "maxReviews": params.get("maxReviews", 100),
        "trackReputation": params.get("trackReputation", True),
        "watchLabel": params.get("watchLabel", "agent-watch"),
    })
    return list(client.dataset(run["defaultDatasetId"]).iterate_items())

track_app_reputation_tool = Tool(
    name="track_app_reputation",
    description="Track iOS + Google Play app reputation: ratings, versions, per-review sentiment, and cross-run rating/topic deltas.",
    func=track_app_reputation,
)
# agent.invoke({"input": "Watch reputation across our top 5 competitor apps on iOS and Android"})

LangGraph — node in a reputation-watch graph:

from langgraph.graph import StateGraph
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

def reputation_node(state: dict) -> dict:
    run = client.actor("harvestlab/app-store-scraper").call(run_input={
        "appUrls": state["appUrls"],
        "includeReviews": True,
        "maxReviews": 100,
        "trackReputation": True,
        "watchLabel": state.get("watchLabel", "reputation-watch"),
    })
    items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
    digest = next((i for i in items if i.get("reputation_change_digest")), {})
    complaints = [t for app in items for t in app.get("review_sentiment_summary", {}).get("top_topic_tags", [])]
    return {**state, "rating_delta_alert": bool(digest), "key_complaints": complaints[:5]}

graph = StateGraph(dict)
graph.add_node("reputation", reputation_node)
# wire into downstream PM-digest / Slack-alert / changelog-diff nodes

See Apify's actor-templates/js-langchain and js-langgraph-agent for full reference setups.

Troubleshooting

Reviews not loading for an app Some apps disable reviews in certain regions. Set country to us (App Store) or leave blank (Google Play) for maximum review availability. Google Play reviews behind a sign-in wall are not scraped — only publicly visible reviews are collected.

App search returns wrong region's apps Set country to the 2-letter ISO code matching your target store region (e.g., gb for UK, de for Germany, jp for Japan). App Store and Google Play catalogs differ per region — an app available in the US may not appear in the German store.

Reputation delta watch mode shows no changes Watch mode compares each run against the persisted snapshot. On the first run there are no deltas (it's the baseline). Deltas appear from the second run onward. If deltas still show zero after multiple runs, the app's ratings genuinely haven't changed — that is correct behavior. For stable signals, bump maxReviews to 100+ (small samples under 20 produce noisy negative_rate deltas).

AI ASO analysis fails Verify that enableAiAnalysis: true and that you have supplied an API key for your chosen provider (e.g., openrouterApiKey). AI analysis is optional — set enableAiAnalysis: false to collect app data without ASO recommendations.

App not found / 404 for a specific URL The app may have been removed from the store or the URL format may be incorrect. Verify the URL opens in your browser. For iOS, use the numeric app ID (e.g., id284882215). For Google Play, use the com.package.name format.

Review scraping stops before reaching maxReviews Some apps have fewer published reviews than the limit you set, or the store's pagination stops early. The actor emits all available reviews and exits cleanly. Try switching reviewSort to mostRecent to capture the latest reviews first.

Google Play fields show "Not provided" Google Play moved size, version, and requires_android behind a client-side RPC in 2023; these fields return empty on most pages. This is a Google Play platform limitation, not an actor bug.

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, and local equivalents)
• 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 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 1–3 second delays between requests and respects rate-limit signals (429/403) with exponential backoff.

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.

Related Actors

• Product Hunt Scraper — track mobile app launches on Product Hunt to catch upcoming iOS/Android releases before they hit the stores at scale.
• Reddit Scraper — pull mobile-app subreddit sentiment (r/iosgaming, r/androidapps, app-specific subs) to triangulate review-store ratings with community discussion.
• Google Search Scraper — run mobile-app SEO/ASO research by mapping how target apps rank for category and competitor queries on Google SERP.