DEV Community: JackFruit296

How to find what users hate in competitor apps (App Store reviews + AI, with Python)

JackFruit296 — Tue, 27 Oct 2026 08:00:02 +0000

Before you build a feature, your users have usually already told you what they want. They just told your competitors, in 1-star reviews.

I wanted a fast way to read those reviews for any app category and get a ranked list of pain points, questions and objections, each linked back to the original review. This post shows the free DIY way in Python, then the shortcut I ended up building.

Step 1: Find the top apps for a topic (free, no API key)

Apple's iTunes Search API is public. One request gives you the top apps for a keyword:

import requests

def search_apps(term, country="us", limit=5):
    r = requests.get("https://itunes.apple.com/search", params={
        "term": term, "country": country, "entity": "software", "limit": limit,
    }, timeout=20)
    r.raise_for_status()
    return [
        {"id": a["trackId"], "name": a["trackName"], "ratings": a.get("userRatingCount", 0)}
        for a in r.json()["results"]
    ]

apps = search_apps("habit tracker")
for a in apps:
    print(a["name"], a["ratings"])

Step 2: Pull recent reviews from the RSS feed

Each app has a public customer-reviews feed in JSON, about 50 reviews per page and up to 10 pages:

def get_reviews(app_id, country="us", pages=2):
    out = []
    for page in range(1, pages + 1):
        url = (f"https://itunes.apple.com/{country}/rss/customerreviews/"
               f"page={page}/id={app_id}/sortby=mostrecent/json")
        entries = requests.get(url, timeout=20).json().get("feed", {}).get("entry", [])
        if isinstance(entries, dict):
            entries = [entries]
        for e in entries:
            if "im:rating" not in e:
                continue  # the first entry can be app metadata
            out.append({
                "rating": int(e["im:rating"]["label"]),
                "text": e["content"]["label"],
                "version": e.get("im:version", {}).get("label"),
            })
    return out

reviews = [r for a in apps for r in get_reviews(a["id"])]
critical = sorted([r for r in reviews if r["rating"] <= 3], key=lambda r: r["rating"])
print(len(reviews), "reviews,", len(critical), "critical")

Tip: sort critical reviews first. The 1–3 star reviews are where the product gaps are. 5-star reviews mostly say "love it".

Step 3: Turn reviews into insights with an LLM

Send the critical reviews to a model with a strict JSON format, and give every review an id so each insight can point back to its evidence:

corpus = "\n".join(f"r{i} [{r['rating']}★] {r['text'][:400]}" for i, r in enumerate(critical[:120]))

prompt = f"""From these app reviews, list the top pain points, questions,
objections and exact phrases users use. Return JSON only:
{{"pain_points": [{{"title": "...", "severity": 0-100, "evidence": "r12"}}], ...}}

Reviews:
{corpus}"""

Two things I learned the hard way:

Make the model cite review ids, then drop any insight whose id doesn't exist. That kills most hallucinated "insights".
Batch it. Around 60 reviews per call keeps answers sharp and cheap.

What it found for "habit tracker"

I ran this on the top habit tracker apps on the US App Store: 39 reviews from 4 apps, 30 insights, 47 seconds. A few of the real 1-star reviews behind the top pain points:

"The app updated and I no longer have lifetime access"

"I am subscribed to Pro and the widgets still say 'subscribe to pro'"

"Trying to profit off those who want to improve their lives is horrible"

"I created a few habits but they are not triggering at right time"

The pattern is clear without reading 39 reviews yourself: pricing changes and paywall bugs hurt trust more than missing features. If you're building in this category, "honest one-time price, no surprise paywall" is a positioning, not just a pricing choice.

The shortcut: run it as an Apify Actor

Maintaining scrapers, batching and JSON repair got old, so I packaged the whole pipeline as an Apify Actor: App Review Analyzer. It reads App Store reviews, Google Play reviews and (optionally) YouTube comments, and returns:

pain points, questions, objections and exact user wording
a severity score and frequency for each
an evidence quote and a link to the original review
an optional strategy report in HTML

Calling it from Python:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("jaclfruit_296/audience-radar-actor").call(run_input={
    "topic": "habit tracker",
    "sources": ["app_store", "google_play"],
    "country": "us",
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["type"], item["score"], item["insight"], "|", item["evidenceQuote"])

It's pay per result (about $0.003 per review analyzed), so a run like the one above costs roughly $0.20. You can also point it at a dataset from any other scraper and it will analyze that text instead.

Wrap-up

Competitor 1-star reviews are the cheapest user research you'll ever do.
Always keep the link from insight to evidence, or you can't trust the output.
Read the top 10 quotes yourself before you decide anything.

If you're validating a whole new app idea rather than a feature, I wrote a follow-up: How to check an app idea against real App Store data before you build it (link it here once it's live).

What do you use to research competitors before building? I'd love to hear other approaches in the comments.

How to check an app idea against real App Store data before you build it

JackFruit296 — Tue, 27 Oct 2026 07:59:47 +0000

AI made building an app cheap. It didn't make picking the right app cheap. A week spent on an idea the market already owns is still a week gone.

So before building, I now run every idea through real store data. This post walks through the method with Python, a real result, and the tool I built to do it in one step.

The idea I tested

A habit tracker for people with ADHD that uses tiny 2-minute habits and a pet that grows when you keep a streak. Free with a $4.99/month premium plan.

It sounds like a solid indie project. Let's see what the stores say.

Step 1: List the competitors and their numbers

Apple's iTunes Search API is free and needs no key. It returns ratings count, average rating, price and the last update date for each app:

import requests
from datetime import datetime, timezone

def competitors(term, country="us", limit=25):
    r = requests.get("https://itunes.apple.com/search", params={
        "term": term, "country": country, "entity": "software", "limit": limit,
    }, timeout=20)
    rows = []
    for a in r.json()["results"]:
        updated = datetime.fromisoformat(a["currentVersionReleaseDate"].replace("Z", "+00:00"))
        rows.append({
            "name": a["trackName"],
            "rating": round(a.get("averageUserRating", 0), 2),
            "ratings": a.get("userRatingCount", 0),
            "price": a.get("price", 0),
            "days_since_update": (datetime.now(timezone.utc) - updated).days,
        })
    return sorted(rows, key=lambda x: x["ratings"], reverse=True)

for row in competitors("adhd habit tracker")[:10]:
    print(row)

Apple doesn't publish installs, so ratings count is the best public demand signal on iOS.

Step 2: Turn the numbers into three questions

I score every idea 0–10 on three things:

Score	Question	Signals from the data
Demand	Do people want this?	Ratings on the top apps, number of apps
Competition	Is there room to enter? (high = easy)	Strong apps, stale leaders, unhappy users, a free option
Revenue	Will people pay?	Share of paid apps or in-app purchases, price level

My rule of thumb: an average of 7.5 or more means build. Below 6 means skip or change the idea. Competition usually decides it: consumer apps rarely score above 5 there.

Two quick checks catch most bad ideas:

Is there a giant? One app with hundreds of thousands of ratings and a 4.9 rating owns the category.
Is the giant free? Then your $4.99/month plan competes with $0.

Step 3: Read the critical reviews

The numbers say whether to enter. The 1–3 star reviews of the top apps say how. Pull them from the public review feed (I covered the code in my previous post on finding what users hate in competitor apps) and look for complaints that repeat across apps.

The result: 5.0 / 10, Skip

Here's what the data said for the ADHD habit tracker idea (US App Store):

15 competitors for the main keywords.
The top direct competitor, Finch: Self-Care Pet, has 768k ratings at 4.95★, and it's free. It's essentially the same idea.
Other big apps in the space: Me+ Lifestyle Routine (249k ratings), Structured (168k), Habit Tracker (148k).
All the top direct competitors are free.
Critical reviews keep coming back to the same complaint: pay-forever subscriptions feel extractive.

Scores: Demand 7, Competition 3, Revenue 5 → 5.0 / 10. Verdict: Skip, unless it's repositioned.

The useful part wasn't the "no". It was the angle the data pointed to:

Drop the pet (Finch owns it). Focus on time-blindness and decision fatigue.
Sell a one-time $9.99 unlock instead of a subscription, because that's exactly what reviewers ask for.
Watch the legal side: App Store guideline 2.3 (no "treats ADHD" claims in your metadata) and GDPR for habit data.

Doing it in one step

Doing this by hand for every idea took me an evening each time, so I built it as an Apify Actor: App Idea Validator.

You describe the idea in a sentence. It:

picks search keywords and searches the App Store and Google Play
lets AI mark the direct competitors (not just keyword matches)
computes the market numbers with fixed rules (not by the AI)
reads the critical reviews of the biggest competitors
scores Demand / Competition / Revenue and gives a Build / Reposition / Skip verdict
writes a one-page Lean Canvas and a legal & store-policy check

To keep the AI honest, the Competition score can't move more than 2 points away from a hint computed from the raw numbers. A category with a 768k-rating leader can't be called "easy".

From Python:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("jaclfruit_296/app-idea-validator-actor").call(run_input={
    "idea": "A habit tracker for people with ADHD that uses tiny 2-minute habits "
            "and a pet that grows when you keep a streak.",
    "stores": ["app_store", "google_play"],
    "country": "us",
})

summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("OUTPUT")["value"]
v = summary["verdict"]
print(v["verdict"], v["average"], {k: s["score"] for k, s in v["scores"].items()})

The full report is saved as REPORT.html, and the competitor table can be exported as CSV or Excel. It costs under $0.50 per idea.

Takeaways

Check the stores before you write code. It takes minutes.
One free giant with a 4.9 rating is usually a "no", whatever your feature list says.
Read the 1-star reviews of the leader. Your positioning is hiding in there.
A "Skip" verdict is a good result. It just saved you a week.

What's an idea you'd like to see scored? Drop it in the comments and I'll run it and post the verdict.