App Review Triage Monitor — App Store & Google Play Review Alerts

Watch your apps' reviews on the App Store and Google Play in one place. Every new review gets sorted into a bucket (bug, billing, feature request, praise), flagged for severity, tagged with the version it's about, and grouped into recurring themes. When a release introduces a crash or a wave of refund complaints, you get a short summary in Slack or a webhook instead of finding out days later.

It's built to run on a schedule and remember what it already saw, so it tells you what changed, not the same 500 reviews every time.

Use it if you ship one or more mobile apps and you'd rather get the reviews that need action pushed to you, already sorted, than log into two separate consoles and read them yourself.

What you can count on

• The reviews are real. Every review is pulled straight from Apple's public App Store review feed and Google Play. Nothing is summarized away or invented. You get the original text, rating, author, date, and version.
• It's exact. Reviews are deduplicated by their real review ID, so you never see the same one twice and never get a phantom one.
• The triage is deterministic and transparent. The same review always lands in the same bucket. There's no black box and no AI making things up. You can read the rule that fired and the keywords behind every classification, and the full original text ships with each result so you can check it yourself.

Optional: bring your own AI key for sharper triage

You don't need this. Read it only if you want the last bit of accuracy.

The Actor works great out of the box with no key and no setup. Its built-in classifier handles the clear-cut reviews (real crashes, refund complaints, genuine praise) and that's most of what you act on. It costs nothing extra and runs the same every time.

If you want, you can drop your own Anthropic API key into the anthropicApiKey field. When you do, only the roughly 1-in-4 reviews that are genuinely ambiguous (sarcasm, mixed feedback, no obvious keyword) get a second look for a more accurate call. The other three-quarters are untouched. It's your key, billed to your own Anthropic account, used only on your runs, and it costs a tiny fraction of a cent per review. Leave the field blank and nothing changes.

Short version: free and solid by default, a little sharper on the tricky reviews if you bring a key.

Why not just use App Store Connect or Google Play Console?

Those are fine for reading reviews one at a time. This exists for three things they don't do:

1. One feed across both stores. Apple and Google are separate consoles with no shared view. This merges them so you stop checking two places.
2. Alerts into your pipeline, not another dashboard. The consoles give you email and an in-app list. This posts a compact, sorted summary to Slack or a webhook the moment a run finishes.
3. Sorting and theme grouping done for you. Instead of skimming 40 reviews to notice they're all about the same crash, you get one line: "5 new reviews mention black screen on v9.1.5."

What it does

• Pulls recent reviews from the App Store and Google Play and normalizes them into one format.
• Sorts every new review into bug_or_crash, billing_complaint, feature_request, praise, or other, with a severity flag and the app version it's about.
• Groups similar new reviews into themes, with the version they cluster around.
• Flags rating drops against the previous run.
• Only reports what's new or changed since the last run, so you're not re-reading old reviews.
• Writes the results to a dataset, a forwardable HTML and Markdown report, and an optional Slack/webhook alert.
• Can track competitor apps too, so you can compare what their users are complaining about.

Input

{
  "apps": [
    {
      "label": "My App",
      "appStoreUrl": "https://apps.apple.com/us/app/my-app/id1234567890",
      "playStoreUrl": "https://play.google.com/store/apps/details?id=com.myapp"
    }
  ],
  "competitorApps": [],
  "maxReviewsPerRun": 100,
  "onlyNewSinceLastRun": true,
  "country": "us",
  "detectBugsCrashes": true,
  "detectBillingComplaints": true,
  "detectFeatureRequests": true,
  "detectRatingDrops": true,
  "clusterThemes": true,
  "weeklyReport": true,
  "webhookUrl": "https://hooks.slack.com/services/XXX/YYY/ZZZ"
}

Give each app an App Store URL, a Google Play URL, or both. One store is fine; two get unified. A Slack incoming-webhook URL works directly in webhookUrl.

Output

You get one digest record per app plus one record per new review. Here's a trimmed digest:

{
  "type": "app_digest",
  "label": "My App",
  "sync_status": "ok",
  "stores": ["app_store", "google_play"],
  "new_count": 23,
  "bucket_counts": {
    "bug_or_crash": 4, "billing_complaint": 2, "feature_request": 5,
    "praise": 9, "other": 3
  },
  "urgent_count": 3,
  "urgent_items": [
    {
      "store": "google_play", "rating": 1, "version": "9.1.5",
      "bucket": "bug_or_crash", "severity": "high",
      "text": "App opens to a black screen and repeats since the update."
    }
  ],
  "clusters": [
    { "theme": "black screen", "mentions": 4, "dominant_version": "9.1.5",
      "summary": "4 new reviews mention 'black screen' (re: v9.1.5)" }
  ],
  "rating_before": 4.61, "rating_after": 4.49, "rating_change": -0.12,
  "rating_drop_alert": true
}

Each new review is stored with its full text and its triage attached, and an HTML/Markdown report lands in the run's key-value store as REPORT.html and REPORT.md. The webhook payload is

{ "text": "<Slack-ready summary>", "summary": { ...full run... } }

Run it on a schedule

This is meant to run on a schedule. That's what turns it into a monitor.

• Daily coverage: a schedule with cron 0 9 * * * (9am every day).
• Right after a release: run every few hours for the first couple of days (0 */4 * * *).

Each run only looks at reviews that showed up since the last one, so running it often stays cheap.

Who it's for

• Indie developers who want a Slack ping when a release breaks something, without babysitting two consoles.
• Small studios running a handful of apps that want one sorted feed and a report to forward after each release.
• Agencies watching client apps who need per-app digests and rating-drop alerts they can route into client channels.

Pricing

You pay per event, only for what a run actually does:

Because only new reviews are processed, a daily run on a small app costs cents.

FAQ

Does it handle both stores? Yes. Give an app an App Store URL, a Google Play URL, or both. Two stores get merged into one feed.

Will it alert me about the same review twice? No. With onlyNewSinceLastRun on (the default), each run reports only reviews that are new or changed since the last run.

Does it need a browser? No. Apple's review feed is plain JSON over HTTP, and Google Play is read with a maintained scraper. No headless browser.

How are rating drops measured? Against a combined, volume-weighted rating across both stores, saved from the previous run.

What happens if one store fails? Each app is handled on its own. A failure is reported for that app and the run keeps going.

Does it fetch developer replies? Google Play replies are included. Apple's public review feed doesn't expose them.

Keywords

App review monitoring, App Store review tracker, Google Play review tracker, app review alerts, Slack review alerts, review webhook, app review classification, bug detection from reviews, app rating monitor, app crash reports from reviews, mobile app feedback monitoring, App Store Connect alternative, Google Play Console alternative, cross-store review aggregator, post-release review monitoring, competitor review tracking, indie app developer tools, app review API.

If you're looking for a way to monitor App Store and Google Play reviews and get them automatically sorted into bugs, billing complaints, and feature requests with alerts to Slack, this Actor does exactly that. Point it at your app's store URLs, set it on a daily schedule, and connect a webhook.