# Pain Point Finder — App Store Review Spike Detector (`0xgollum/pain-point-finder`) Actor

Scans an app's public App Store customer reviews and finds which specific complaints just started spiking in a recent window versus your own reviews' baseline - a fresh pain-point signal, no LLM or API key required.

- **URL**: https://apify.com/0xgollum/pain-point-finder.md
- **Developed by:** [0xGollum](https://apify.com/0xgollum) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$20.00 / 1,000 pain points

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Pain Point Finder — App Store Review Spike Detector 📉

**Find out which specific complaint just started spiking in your app's recent reviews — no LLM, no API key, just your own reviews compared against their own baseline.**

Searches this actor ranks for: App Store review analyzer, app review sentiment tracker, product feedback signal, customer complaint spike detector, no-LLM review analysis, App Store RSS feed API.

### Why a spiking complaint is a signal, not just data

Every review-analysis tool on the market does the same thing: scrape reviews, run them through an LLM you bring your own API key for, get a summary. That's a data dump with an extra step. The signal that actually matters for a product team is narrower: **which complaint just got worse recently, compared to how things normally are for this app** — a genuinely new problem, not the usual background noise every app gets.

This actor pulls from Apple's own public, unauthenticated customer-review feed (no scraping, no login — Trustpilot, by contrast, sits behind an AWS WAF bot-check that blocks plain HTTP clients outright, confirmed live 2026-08-03), splits negative reviews into a recent window vs. everything older, and surfaces keywords whose mention rate just spiked — the same spike-vs-trailing-baseline shape used across the rest of this actor portfolio, applied to review text instead of trade volume or job postings.

### Who uses this and for what

| Persona | Use it to... |
|---|---|
| **Product managers** | Catch a regression's real-world impact within days of a release, not weeks |
| **App developers (indie or team)** | Get an early warning before a 1-star pile-up tanks your rating |
| **Support teams** | Know what's about to flood the inbox before it does |
| **Competitive research** | Track a competitor's app for what's currently breaking for their users |

### vs. the alternatives

| | Pain Point Finder | LLM-based review analyzers | Manually reading reviews |
|---|---|---|---|
| **Cost** | Pay-per-result, no extra setup | + your own OpenAI/Claude API bill | Free, but doesn't scale |
| **Data source** | Apple's public review feed | Usually the same feed, then an LLM call | Whatever you can read |
| **What you get** | A ranked list of *newly spiking* complaints | A general sentiment summary | Nothing structured |
| **Setup** | Run it | Bring your own LLM key, prompt-tune it | Bookmark the App Store page |

### The honest tradeoffs

- **No stemming.** "crashes" and "crashing" are tracked as separate keywords — a real complaint can get undercounted if reviewers split their wording. A deliberate simplicity tradeoff, not an oversight (adding real NLP would mean an extra dependency for a marginal gain).
- **Needs enough history on both sides.** Tested live against real apps (2026-08-03): a very high-traffic app can have its *entire* visible review window (Apple caps the feed at ~500 reviews) fall inside the recent window, leaving nothing to compare against — the actor correctly returns nothing rather than a meaningless "everything is new" result. A very fast-shipping app can have too few recent reviews to trust a rate off of. Both cases are silently skipped rather than faked.
- **App Store only, for now** — not Google Play or Trustpilot (the latter is actively hostile to plain scraping, see above).

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| **app\_ids** | array | *(required)* | Numeric Apple App Store IDs |
| **country** | string | "us" | App Store storefront country code |
| **max\_pages** | integer | 10 | Review feed pages to fetch (Apple caps at 10, ~500 reviews) |
| **max\_rating** | integer | 2 | Star rating at/below which a review counts as negative |
| **min\_mentions\_current** | integer | 3 | Min distinct recent negative reviews a keyword must appear in |
| **recent\_window\_days** | integer | 7 | Size of the "recent" window, anchored on the app's own latest review |
| **min\_spike\_ratio** | number | 2.0 | Min multiple of the baseline rate to flag a keyword |
| **max\_results** | integer | 100 | Cap on rows returned, highest spike first |
| **request\_timeout\_secs** | integer | 30 | HTTP request timeout |

### Output example

```json
{
  "app_id": "1232780281",
  "keyword": "broken",
  "recent_version": "1.7.325",
  "mentions_recent": 4,
  "negative_reviews_recent": 22,
  "mentions_prior": 4,
  "negative_reviews_prior": 177,
  "spike_ratio": 8.05,
  "example_review": "Change the recents section back on Mobile!! What an overstimulating nightmare!"
}
```

### FAQ

**Do I need an OpenAI/Claude API key?** No — this actor uses plain keyword frequency, not an LLM. That's a real cost and setup advantage over every competitor found in a pre-build market scan of this niche.

**Why don't I see any results for a very popular app?** If the app's most recent ~500 reviews are all inside your `recent_window_days`, there's no baseline to compare against and the actor correctly reports nothing rather than a meaningless spike.

**What's `recent_version`?** The most common app version among the recent-window reviews — informational only, the actual recent/baseline split is by review date, not version string (a fast-shipping app's version number changes too often to use as a reliable bucket).

### Part of the 0xGollum signal suite

Stacks with [Funding Intent](https://apify.com/0xgollum/funding-intent) and [Hiring Intent](https://apify.com/0xgollum/hiring-intent) — each actor turns one public, noisy, or hard-to-monitor data source into a single actionable signal instead of a data dump.

# Actor input Schema

## `app_ids` (type: `array`):

Numeric Apple App Store IDs to scan (found in the app's App Store URL, e.g. apps.apple.com/us/app/x/id284882215 -> 284882215).

## `country` (type: `string`):

Two-letter App Store storefront country code (e.g. 'us', 'gb', 'fr').

## `max_pages` (type: `integer`):

Apple's public feed exposes at most 10 pages (~500 most recent reviews) per app/country.

## `max_rating` (type: `integer`):

Reviews at or below this star rating are treated as negative/complaint reviews.

## `min_mentions_current` (type: `integer`):

A keyword must appear in at least this many distinct negative reviews within the recent window to be considered (filters one-off noise).

## `recent_window_days` (type: `integer`):

Negative reviews within this many days of the most recent one form the 'recent' bucket; everything older is the baseline. Anchored on the app's own most recent review, not today's date.

## `min_spike_ratio` (type: `number`):

Flag a keyword when its mention rate in the recent window's negative reviews is at least this multiple of its rate in the baseline (older) negative reviews.

## `max_results` (type: `integer`):

Cap on the number of pain-point rows returned per run, highest spike ratio first.

## `request_timeout_secs` (type: `integer`):

HTTP request timeout.

## Actor input object example

```json
{
  "app_ids": [
    "284882215"
  ],
  "country": "us",
  "max_pages": 10,
  "max_rating": 2,
  "min_mentions_current": 3,
  "recent_window_days": 7,
  "min_spike_ratio": 2,
  "max_results": 100,
  "request_timeout_secs": 30
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "app_ids": [
        "284882215"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("0xgollum/pain-point-finder").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "app_ids": ["284882215"] }

# Run the Actor and wait for it to finish
run = client.actor("0xgollum/pain-point-finder").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "app_ids": [
    "284882215"
  ]
}' |
apify call 0xgollum/pain-point-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,0xgollum/pain-point-finder"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/CBIPNln48czk8ChC4/builds/tKGDBHcOfKePOqOey/openapi.json