How to Scrape App Store Reviews in 2026

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:

Star rating
Review title and body text
Reviewer display name
App version
Date
Helpful count
Review ID

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": "r123",
      "rating": 1,
      "title": "Latest update crashes",
      "body": "It closes whenever I open the dashboard.",
      "author": "User123",
      "version": "4.2.0",
      "date": "2026-07-28T12:00:00Z",
      "helpfulCount": 12
    }
  ],
  "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 a page once is useful for research. Monitoring means repeating the retrieval and deciding what changed.

The basic workflow is:

Scheduled job → Fetch recent reviews → Store unseen IDs → Classify or alert → Keep source review

Store the review ID, rating, text, version, date, storefront, and retrieval timestamp. The review ID lets you avoid alerting on the same review every time the job runs.

Useful alert rules include:

New one-star or two-star review
Multiple new reviews mentioning the same bug
A complaint that starts after a specific app version
A competitor receiving repeated requests for a capability you provide

For the full workflow, see App Store review monitoring.

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, the app versions mentioned, 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.