App Store review sentiment analysis should do more than label reviews positive, negative, or neutral. A one-star review about a crash needs a different response from a one-star review about pricing, onboarding, login, or a missing feature.

The useful output is a feedback map: what customers are saying, how often they say it, when it started, and what the product team should do next.

With FetchLayer, you can either retrieve the reviews through the App Store Reviews API or ask Research Chat to analyze and export the result without code.

For JavaScript and TypeScript, the official @fetchlayer/appstore npm package provides typed access to the endpoints. It is open source on GitHub.

What App Store review sentiment analysis can reveal

Public app reviews are especially valuable because they combine a rating, written feedback, and a date. That makes it possible to answer questions such as:

  • Did complaints increase after a release?
  • Which bugs are affecting the most users?
  • What are customers repeatedly asking for?
  • Is a competitor’s dissatisfaction an opportunity for us?
  • Do highly rated reviews praise a feature we should emphasize?
  • Are low ratings about the product itself or a specific support, billing, or onboarding issue?

Sentiment is one input. Theme, severity, timing, and supporting evidence make it actionable.

Start with the right review data

For each review, keep these fields:

FieldWhy it matters
RatingA fast severity signal, not the entire analysis
Title and review textThe evidence behind every classification
DateShows change over time and lines feedback up with your release dates
Country and languageSeparates regional patterns
Review IDLets you deduplicate monitoring runs

Fetch recent reviews when investigating a launch. Sort by helpful when you want the reviews Apple ranks as most helpful. For a repeatable workflow, store the retrieval time too.

Use a classification framework that leads to decisions

Ask an AI model—or build your own rules—to classify every review on more than one axis:

DimensionExample labels
SentimentPositive, negative, mixed, neutral
ThemeReliability, performance, onboarding, billing, UX, feature request, support
SeverityBlocker, high, medium, low
Evidence typeBug report, request, praise, question, comparison
Action ownerEngineering, product, support, marketing

The labels should match your actual operating model. A theme called “other” may be unavoidable, but it should not become the largest bucket. Revisit the taxonomy when it does.

A prompt that produces useful analysis

Avoid asking only, “What is the sentiment?” It invites a shallow answer. Instead, give the model clear output requirements:

Analyze these App Store reviews. Classify each review by sentiment, theme, severity, and action owner. Group recurring issues, show the review count and date range for every theme, and cite representative review IDs. Keep the original review text in the export.

This produces both an executive summary and an auditable dataset. The summary may say “crashes reported since the 4 November release are the highest-risk theme”; the CSV lets a PM or engineer read the supporting reviews.

Analyze reviews with no code

FetchLayer Research Chat can run the retrieval and analysis together. Start with an app name, App Store URL, or app ID, then ask for the output you need.

Useful follow-ups include:

  • Export only one-star and two-star reviews.
  • Compare the two weeks after the latest release with the two weeks before it.
  • Separate feature requests from defects.
  • Add a confidence score for every classification.
  • Create a weekly summary with evidence links.
  • Export the review-level analysis as CSV.

This is especially useful when a PM, founder, or researcher needs to investigate feedback now and does not want to wait for an engineering pipeline.

Open App Store review analysis in Research Chat

Use your own AI through MCP

Research Chat is for an immediate no-code analysis. If you already use Claude, Codex, Hermes, or another MCP-compatible AI client, connect it to FetchLayer instead and keep the work in your preferred AI environment.

Retrieve recent App Store reviews for this app. Classify sentiment with confidence, group defects and feature requests by theme and week, retain representative review IDs and text as evidence, then export the dataset as CSV.

Connect FetchLayer to your MCP client so the agent retrieves the source reviews directly rather than working from a pasted sample.

Analyze App Store reviews with AI, in code

The script below does the part that doesn’t need a model: it fetches recent reviews from two storefronts, tags each one with a quick keyword pass, counts themes against low ratings, and writes one review per line to a JSONL file your model can read with the review IDs intact.

import json
import os
import re
from collections import Counter

import requests

APP_ID = "1232780281"  # Notion
COUNTRIES = ["us", "gb"]
THEMES = {  # a cheap first pass; your model refines it
    "crashes": r"crash|freez|clos(es|ing)|won.?t open",
    "sync": r"sync|offline|lost|disappear",
    "speed": r"slow|lag|load",
    "AI": r"\bai\b|assistant",
    "pricing": r"price|pay|subscri|expensive",
    "login": r"log ?in|sign ?in|account",
}

reviews = []
for country in COUNTRIES:
    res = requests.post(
        "https://api.fetchlayer.dev/appstore/reviews",
        json={"appId": APP_ID, "country": country, "sort": "recent", "pages": 5},
        headers={"Authorization": f"Bearer {os.environ['FETCHLAYER_API_KEY']}"},
        timeout=120,
    )
    res.raise_for_status()
    reviews += [{**r, "country": country} for r in res.json()["reviews"]]

themes, low = Counter(), Counter()
for r in reviews:
    text = f"{r['title']} {r['review']}".lower()
    r["themes"] = [t for t, rx in THEMES.items() if re.search(rx, text)]
    themes.update(r["themes"])
    if r["rating"] <= 2:
        low.update(r["themes"])

print(len(reviews), "reviews,", sum(r["rating"] <= 2 for r in reviews), "rated 1 or 2 stars")
for theme, n in themes.most_common():
    print(f"{theme:<9} {n:>3} reviews, {low[theme]:>3} of them 1-2 stars")

# One review per line, ID kept, ready for your model and the prompt above
with open("reviews.jsonl", "w", encoding="utf-8") as f:
    for r in reviews:
        f.write(json.dumps({k: r[k] for k in ("id", "country", "date", "rating", "title", "review", "themes")}, ensure_ascii=False) + "\n")

Our run (12 November 2026, Notion, US and UK) fetched 200 reviews in 10 requests, about $0.02:

200 reviews, 102 rated 1 or 2 stars
AI         49 reviews,  24 of them 1-2 stars
speed      31 reviews,  22 of them 1-2 stars
crashes    17 reviews,  12 of them 1-2 stars
login       7 reviews,   6 of them 1-2 stars
sync        6 reviews,   4 of them 1-2 stars
pricing     6 reviews,   4 of them 1-2 stars

Even before a model reads anything, that says where to look: speed complaints are mostly negative (22 of 31), while AI is the most discussed theme but split between praise and complaints. Then pass reviews.jsonl to your model with the prompt above. The keyword tags are a starting point the model should correct, not the answer.

For ongoing product intelligence, run it on a schedule and classify only reviews you haven’t seen; the review-monitoring job shows how to keep that state.

Scheduled retrieval → Deduplicate by review ID → Classify new reviews → Aggregate themes → Alert the right owner

Use MCP when an AI coding agent should retrieve reviews as part of a larger workflow, such as comparing customer complaints across App Store, Reddit, X/Twitter, and YouTube. The agent can fetch the source records, produce a brief, and leave the evidence in a structured artifact.

Detect release regressions

Reviews don’t carry the app version, so line them up with your own release dates instead. Track negative-review rate and theme count in the same window before and after each release:

14 days before the 4 Nov release → 8 reliability complaints
14 days after the 4 Nov release  → 63 reliability complaints, mostly crashes and failed sign-in

Reviewers often name the version in the text (“since 4.2 it crashes”), so ask your classifier to extract any version a review mentions.

This is not proof that a release caused every complaint. It is a strong signal to investigate, especially when the same wording starts appearing immediately after a release.

Set an alert when either of these changes occurs:

  • A high-severity theme appears for the first time.
  • A theme exceeds a review-count threshold in a set period.
  • Negative feedback after a release rises materially above the period before it.
  • Multiple reviews describe the same blocker with different wording.

For the collection and deduplication side, see how to build a review-monitoring job.

Common mistakes

Treating star rating as the complete sentiment label

A five-star review can contain a serious feature request. A one-star review can be caused by a temporary account issue. Read the text and retain the original evidence.

Summarizing before preserving the rows

Once you only have a prose summary, you cannot audit the conclusion or create a new breakdown. Keep the review-level CSV or JSON as the source of truth.

Ignoring country, language, and timing

Those fields often explain why feedback looks inconsistent. A regional payment issue and a new-version crash should not be blended into one generic negative-sentiment number.

Asking an AI model for unsupported certainty

Use language such as “likely theme” or add a confidence score for ambiguous reviews. The goal is better prioritization, not pretend-perfect labels.

Next steps