How to Scrape App Store Reviews in 2026
Fetch public Apple App Store reviews as structured JSON with a practical API workflow for monitoring, research, and AI analysis.
App Store reviews are a useful public feedback source: they contain customer complaints, feature requests, release regressions, and the language users use to describe value. The hard part is turning that feedback into a repeatable dataset instead of manually opening product pages.
This guide shows how to fetch public App Store reviews as structured JSON, store them, and use them for monitoring or analysis.
Need a working endpoint first? Start with the FetchLayer App Store Reviews API or read the developer reference.
If you work in JavaScript or TypeScript, you can skip the raw fetch wrapper and install the official package: @fetchlayer/appstore. The SDK is open source on GitHub and includes typed responses for all endpoints.
What you can retrieve
The FetchLayer App Store reviews endpoint accepts an App Store app ID and returns public review data. A review record can include:
- Review ID
- Star rating
- Review title and text
- Reviewer display name
- Date
- Whether the reviewer edited it
You can also choose a country, language, platform, sort order, page count, and the number of reviews returned per page.
That makes the same workflow useful for your own app, a competitor, a category-research project, or an AI feedback pipeline.
1. Find the App Store ID
An App Store listing URL includes the app ID. For example, an address ending in id1234567890 has the app ID 1234567890.
If you only know the product name, use FetchLayer’s App Store search endpoint first:
curl -X POST https://api.fetchlayer.dev/appstore/search \
-H "Authorization: Bearer ss-your-key" \
-H "Content-Type: application/json" \
-d '{"query":"notion","country":"us"}'The response includes matching app IDs, names, developers, ratings, categories, and listing URLs.
2. Fetch public reviews
Use the ID with the reviews endpoint:
curl -X POST https://api.fetchlayer.dev/appstore/reviews \
-H "Authorization: Bearer ss-your-key" \
-H "Content-Type: application/json" \
-d '{
"appId": "1234567890",
"country": "us",
"pages": 2,
"reviewsPerPage": 20,
"sort": "recent"
}'Use recent when you are checking fresh feedback after a release. Use helpful when you want the reviews users have elevated most visibly.
The response is structured JSON, so you do not need to parse page HTML:
{
"reviews": [
{
"id": "14775527587",
"date": "2026-11-11T00:57:35Z",
"isEdited": false,
"rating": 1,
"title": "Latest update crashes",
"review": "It closes whenever I open the dashboard.",
"userName": "User123"
}
],
"pagesFetched": 2
}Review pages are billed only when fetched. Keep the pagesFetched value with your job output so your usage is easy to audit.
3. Fetch reviews in JavaScript
Here is a minimal Node.js or Bun example:
const response = await fetch('https://api.fetchlayer.dev/appstore/reviews', {
method: 'POST',
headers: {
Authorization: `Bearer ${process.env.FETCHLAYER_API_KEY}`,
'Content-Type': 'application/json',
},
body: JSON.stringify({
appId: '1234567890',
country: 'us',
pages: 1,
reviewsPerPage: 20,
sort: 'recent',
}),
});
if (!response.ok) throw new Error(`FetchLayer returned ${response.status}`);
const { reviews, pagesFetched } = await response.json();
console.log({ reviews, pagesFetched });Do not expose the API key in a browser bundle. Make this request from your server, worker, cron job, or trusted automation environment.
4. Build a review-monitoring job
Fetching reviews once is research. Monitoring means running the same request on a schedule and acting only on what is new: a one-star review in Germany the morning after a release, or a cluster of “crashes on launch” in the US.
The job has four parts:
Schedule → fetch reviews since the last run → skip IDs you have seen → alert on the ones that matterThis script does all four for one app in three storefronts. It keeps its state in a small JSON file, sends one- and two-star reviews to Slack (or prints them if no webhook is set), and on each run only asks for reviews since the previous one:
import json
import os
from datetime import date, timedelta
from pathlib import Path
import requests
APP_ID = "1232780281" # Notion
COUNTRIES = ["us", "gb", "de"]
STATE = Path("review-monitor-state.json")
SLACK = os.environ.get("SLACK_WEBHOOK_URL") # optional: without it, alerts are printed
state = json.loads(STATE.read_text()) if STATE.exists() else {"since": str(date.today() - timedelta(days=7)), "seen": []}
seen = set(state["seen"])
new = []
for country in COUNTRIES:
res = requests.post(
"https://api.fetchlayer.dev/appstore/reviews",
json={"appId": APP_ID, "country": country, "sort": "recent", "since": state["since"], "pages": 3},
headers={"Authorization": f"Bearer {os.environ['FETCHLAYER_API_KEY']}"},
timeout=120,
)
res.raise_for_status()
for review in res.json()["reviews"]:
if review["id"] not in seen: # since is inclusive, so the last day comes back again
seen.add(review["id"])
new.append({**review, "country": country})
for r in (r for r in new if r["rating"] <= 2):
text = f"{r['rating']}★ [{r['country']}] {r['title']}: {r['review'][:280]}"
if SLACK:
requests.post(SLACK, json={"text": text}, timeout=30)
else:
print("ALERT", text.replace("\n", " ")[:120])
# Next run starts from today; keep the newest IDs so the overlap day is not alerted twice.
STATE.write_text(json.dumps({"since": str(date.today()), "seen": list(seen)[-5000:]}))
print(len(new), "new reviews,", sum(r["rating"] <= 2 for r in new), "of them 1 or 2 stars")On our run (12 November 2026, Notion, US, UK and Germany), the first run found 12 new reviews from the past week and alerted on the 8 rated one or two stars. Run again straight away, it found 0, because every ID was already in the state file.
Run it daily with cron, a GitHub Actions schedule or any scheduler you already have:
0 7 * * * cd /opt/review-monitor && python monitor.pyA few decisions worth making up front:
- Which storefronts. Each country has its own reviews, so a problem that only affects one market only shows up if you watch that country.
- What counts as an alert. One- and two-star reviews are the usual start. Others that work: several new reviews mentioning the same bug, a jump in low ratings in the days after a release date, or a competitor collecting repeated requests for something you already do.
- Where history lives. The state file only remembers IDs. If you want trends, also write each new review (ID, country, rating, title, text, date) to a database or a CSV, as in the CSV export guide.
- Competitors. Reviews are public, so the same job works for any app ID. Add competitors to the list and tag each review with its app.
Cost stays small: with since and the default recent sort, a request stops paging once it passes the date, so a daily run usually costs one request per storefront. Three storefronts every day is about 90 requests a month, roughly $0.18 pay-as-you-go.
5. Analyze reviews with AI without losing evidence
An LLM is most useful when it works from the original review records, rather than only from a pre-written summary. Give it a constrained question and ask it to cite representative reviews.
For example:
Group these reviews into bugs, feature requests, pricing objections, and praise. For every theme, show the number of reviews, when each theme started, and representative review IDs.
That produces a brief a product team can verify. It is much more useful than a generic positive/negative sentiment score.
You can use REST directly or connect FetchLayer through MCP so an AI agent can retrieve the review data as part of a larger research task. Read more about analyzing App Store reviews.
If you do not want to write code, FetchLayer Research Chat can retrieve the reviews, analyze the themes, and produce a downloadable CSV or JSON file from a plain-English request. See the complete guide to exporting App Store reviews to CSV.
Already work in Claude, Codex, Hermes, or another MCP-compatible AI client? Connect FetchLayer’s MCP server, then give your own agent the review-analysis prompt and output format you prefer. It can retrieve the source reviews itself instead of asking you to copy data into a chat. Set up FetchLayer with your MCP client.
App Store Connect API versus public review data
Apple’s App Store Connect API is useful for apps in your own account, including responding to reviews. It is not the right source for competitor research because it is tied to the app owner’s App Store Connect access.
FetchLayer is designed for retrieving publicly available review data with one API key. Use the official API when you need privileged owner actions; use public review data when your job is research, monitoring, competitive analysis, or an independent feedback pipeline.
Next steps
- Get a free FetchLayer API key
- Explore the App Store Reviews API
- Read the App Store API reference
- Build an App Store review analysis workflow
- Export App Store reviews to CSV
- Google Play Reviews API: the same review pipeline for Android apps