DEV Community: Tiandu Tech

Monitor your competitors' Chrome extension reviews with a scheduled scraper

Tiandu Tech — Sun, 18 Oct 2026 21:08:15 +0000

If you build a Chrome extension, your competitors' 1-star reviews tell you what their users want and aren't getting. The Chrome Web Store has no export or alerts for other people's extensions, so the usual option is checking by hand.

Here's a small setup: a scheduled scraper collects the latest reviews of a handful of competing extensions every day, and a short Python script flags the new low-rated ones.

We'll use the App Store, Google Play & Chrome Web Store Reviews Scraper on Apify for collection and Apify's built-in Schedules for timing.

The idea

Pick 3–10 competing extensions.
Run the scraper on a schedule (say, daily) with a modest maxReviewsPerApp. Chrome reviews are fetched newest first, so a small cap still catches everything posted since the last run, as long as fewer reviews than the cap arrive in a day.
After each run, compare reviewIds with the ones you've already seen, and report new reviews with rating <= 2.

The scraper itself doesn't track what you've seen before. Each run simply returns up to your limit. The "only new" part is a few lines of your own code, shown below.

Step 1: Collect the extension IDs

The ID is the 32-character string at the end of an extension's Web Store URL, e.g. https://chromewebstore.google.com/detail/<name>/ddkjiahejlhfcafbddmgiahcphecmpfh. You can paste either the full URL or just the ID.

Step 2: The input

{
  "apps": [
    "ddkjiahejlhfcafbddmgiahcphecmpfh",
    "<competitor-extension-id-2>",
    "<competitor-extension-id-3>"
  ],
  "language": "en",
  "maxReviewsPerApp": 50
}

countries isn't needed: Chrome Web Store reviews aren't split by country, and country comes back as null.
language filters to reviews in that language. Change it (for example to de) if your market isn't English-speaking. Leaving it out doesn't give you all languages: the default is en. One run covers one language.
maxReviewsPerApp: 50 is one store request per extension (the scraper fetches 50 per request, at most one request per second), which keeps each run small. This still holds with language set, because the store applies the language filter in that same request: you get up to 50 reviews in that language (fewer if the extension doesn't have that many).

Each review comes back with rating, text, appVersion (the extension version the reviewer used), thumbsUp (the store's "helpful" count), reviewedAt and developerReply. title is always null for Chrome because the store has no review titles.

Step 3: Schedule it

Two ways, both standard Apify features:

Saved task + Schedule: in Apify Console, save the input above as a task for the Actor, then create a Schedule (Console → Schedules) with a cron expression such as 0 7 * * * (every day at 07:00 in the schedule's time zone) and add the task to it.
From your own cron: call the Actor from your own scheduler with the API client, as in the script below.

Step 4: Flag new low-rated reviews

This script reads the dataset of the latest successful run of the task, keeps a local file of seen review IDs, and prints new 1–2 star reviews:

import json, os, pathlib
from apify_client import ApifyClient

TASK_ID = os.environ["APIFY_TASK_ID"]        # the saved task from Step 3
SEEN = pathlib.Path("seen_review_ids.json")

client = ApifyClient(os.environ["APIFY_TOKEN"])
items = list(client.task(TASK_ID).last_run(status="SUCCEEDED").dataset().iterate_items())

seen = set(json.loads(SEEN.read_text())) if SEEN.exists() else set()
new = [r for r in items if r["reviewId"] not in seen]
alerts = [r for r in new if (r.get("rating") or 5) <= 2]

for r in sorted(alerts, key=lambda r: r.get("reviewedAt") or ""):
    print(f'[{r["appId"]}] {r["rating"]}★  v{r.get("appVersion") or "?"}  '
          f'{(r.get("reviewedAt") or "")[:10]}\n  {r.get("text") or ""}\n')

SEEN.write_text(json.dumps(sorted(seen | {r["reviewId"] for r in items})))
print(f"{len(new)} new reviews, {len(alerts)} low-rated")

Pipe the output into Slack, email or an issue tracker however you like. On the first run every review is "new"; after that you only see the delta.

What to look for

Repeated complaints after a competitor's update. Group alerts by appVersion; a cluster of 1-star reviews on one version usually means a regression.
Unanswered complaints. developerReply is null on reviews the competitor hasn't answered. Those show what they aren't handling.
Most-agreed-with reviews. Sort by thumbsUp to see which complaints other users marked as helpful.

Limits to keep in mind

The scraper uses the same anonymous data request that the Web Store's public reviews page makes. It isn't a documented API, so a site change can break parsing. If two extensions in a row can't be parsed, the remaining Chrome tasks are skipped and the run summary says so, rather than writing wrong data.
An unknown or removed extension ID returns no rows, and the summary notes it.
Emails and phone numbers in review text and replies are redacted, but reviewers can still type other personal details. Keep the data internal.

The same setup works for Google Play and App Store apps too: add their IDs to apps and set countries.

Set up your own monitor: https://apify.com/tiandu-tech/apify-002-app-reviews

Find user pain points in app and extension reviews with Python

Tiandu Tech — Sun, 18 Oct 2026 21:02:33 +0000

Star ratings tell you that users are unhappy. The review text tells you why. This post shows a short Python workflow (pandas plus the standard library) that turns a dataset of App Store, Google Play and Chrome Web Store reviews into a ranked list of complaints, broken down by store and app version.

We'll start from a dataset exported by the App Store, Google Play & Chrome Web Store Reviews Scraper on Apify, which gives every review the same fields no matter which store it came from. Any review export with similar columns will work.

1. Get the data

Run the Actor with your apps and extensions (see the companion tutorial for input details), and turn on the optional sentiment switch if you want a quick baseline label:

{
  "apps": ["com.whatsapp", "ddkjiahejlhfcafbddmgiahcphecmpfh"],
  "countries": ["us"],
  "language": "en",
  "maxReviewsPerApp": 500,
  "sentiment": true
}

Then either export the dataset as JSON from the run's Output tab, or fetch it with the API (this uses apify-client 3.x, where call() returns an object, so it's run.default_dataset_id; on the old 2.x client it's run["defaultDatasetId"]):

import os, json
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("tiandu-tech/apify-002-app-reviews").call(run_input={
    "apps": ["com.whatsapp", "ddkjiahejlhfcafbddmgiahcphecmpfh"],
    "countries": ["us"], "language": "en",
    "maxReviewsPerApp": 500, "sentiment": True,
})
items = list(client.dataset(run.default_dataset_id).iterate_items())
with open("reviews.json", "w", encoding="utf-8") as f:
    json.dump(items, f, ensure_ascii=False)

2. Load and clean

import pandas as pd

df = pd.read_json("reviews.json")
df["reviewedAt"] = pd.to_datetime(df["reviewedAt"], errors="coerce", utc=True)
df["text"] = df["text"].fillna("")
df = df[df["text"].str.len() > 0]

print(df.groupby(["store", "appId"]).size())

Useful columns: store, appId, rating, text, appVersion, thumbsUp, reviewedAt, developerReply, and sentiment if you turned it on.

Note: the Actor's sentiment label is a simple rule (English keywords plus star rating), and for non-English reviews it mostly follows the rating. Treat it as a baseline, not ground truth.

3. Ratings at a glance

summary = (df.groupby(["store", "appId"])
             .agg(reviews=("reviewId", "count"),
                  avg_rating=("rating", "mean"),
                  share_1_2_star=("rating", lambda s: (s <= 2).mean()),
                  replied=("developerReply", lambda s: s.notna().mean()))
             .round(2))
print(summary)

replied is the share of reviews with a developer reply, a quick proxy for how actively a team handles feedback.

4. Rating by app version

Releases often explain rating drops. appVersion is the version the reviewer was using:

by_version = (df.dropna(subset=["appVersion"])
                .groupby(["appId", "appVersion"])
                .agg(n=("reviewId", "count"), avg=("rating", "mean"))
                .query("n >= 10")
                .sort_values(["appId", "avg"]))
print(by_version.head(20))

5. Pull out complaint phrases

Take the negative reviews and count the most common two- and three-word phrases. No ML needed:

import re
from collections import Counter

STOP = set("""a an the and or but if to of in on for with is it this that was are be
i me my we you your they them have has had not no just so very app extension
""".split())

def phrases(text, n):
    words = [w for w in re.findall(r"[a-z']+", text.lower()) if w not in STOP]
    return [" ".join(words[i:i+n]) for i in range(len(words) - n + 1)]

neg = df[df["rating"] <= 2]
counts = Counter()
for t in neg["text"]:
    counts.update(phrases(t, 2))
    counts.update(phrases(t, 3))

for phrase, c in counts.most_common(30):
    print(f"{c:4d}  {phrase}")

Read the top phrases and group them into themes by hand. On a few hundred reviews this takes minutes, and you see exactly why each phrase landed in a theme.

6. Tag themes and rank them

Turn your themes into keyword rules and score them by frequency and by how many users agreed (thumbsUp):

THEMES = {
    "crash / freeze": ["crash", "freez", "stuck", "not responding"],
    "login / account": ["login", "log in", "sign in", "account", "password"],
    "performance": ["slow", "lag", "battery", "memory"],
    "ads / paywall": ["ads", "subscription", "paywall", "premium"],
    "update broke it": ["update", "latest version", "new version"],
}

def tag(text):
    t = text.lower()
    return [name for name, kws in THEMES.items() if any(k in t for k in kws)] or ["other"]

neg = neg.assign(theme=neg["text"].map(tag)).explode("theme")
ranking = (neg.groupby(["store", "theme"])
              .agg(reviews=("reviewId", "count"),
                   agreed=("thumbsUp", lambda s: s.fillna(0).sum()))
              .sort_values(["store", "reviews"], ascending=[True, False]))
print(ranking)

The agreed column weights each complaint by how many other users marked the review as helpful, a rough signal of how many users share the problem.

7. Export for the team

ranking.to_csv("pain_points_by_store.csv")
neg.sort_values("thumbsUp", ascending=False)[
    ["store", "appId", "appVersion", "rating", "thumbsUp", "theme", "text"]
].head(50).to_csv("top_negative_reviews.csv", index=False)

Two CSVs: one ranked list of themes per store, and the 50 most-agreed-with negative reviews as evidence.

Where to go next

Swap the keyword rules for an embedding model or an LLM once you have more data.
Compare your app against a competitor by adding their IDs to the same run.
Run it on a schedule and track theme counts week over week (see the monitoring post).

A reminder on data: review text can contain names or details that reviewers typed themselves. The Actor redacts emails and phone numbers, but keep the data internal and follow the privacy rules that apply to you.

Get the scraper here: https://apify.com/tiandu-tech/apify-002-app-reviews

A runnable example project (collect + analyze) is on GitHub: https://github.com/DongmeiHerman/app-reviews-pain-points

How to scrape App Store, Google Play and Chrome Web Store reviews in one run

Tiandu Tech — Sun, 18 Oct 2026 21:02:26 +0000

If your product ships as an iOS app, an Android app and a Chrome extension, its reviews sit in three stores with three page layouts. Copying them by hand is slow. Running three separate scrapers leaves you with three exports and three sets of field names to merge.

This guide pulls reviews from all three stores with one input list and one run, and gets back one dataset with the same fields for every store. We'll use the App Store, Google Play & Chrome Web Store Reviews Scraper on Apify. It has no Actor fee; you only pay for Apify platform usage.

Heads-up about Apple (October 2026): Apple's public review feed currently returns empty pages at times. When that happens the run says so in its summary and log instead of silently returning nothing. Google Play and the Chrome Web Store are not affected.

What you need

A free Apify account (needed to run anything on Apify).
The IDs or URLs of the apps and extensions you care about.

Step 1: Find your IDs

You can paste either the store URL or the bare ID. The store is detected automatically.

Store	What to paste	Example
Apple App Store	numeric app ID or `apps.apple.com` URL	`310633997` (WhatsApp)
Google Play	package name or `play.google.com` URL	`com.whatsapp`
Chrome Web Store	32-letter extension ID or `chromewebstore.google.com` URL	`ddkjiahejlhfcafbddmgiahcphecmpfh` (uBlock Origin Lite)

The Apple ID is the number after id in the App Store URL. The Google Play package name is the id= value in the Play URL. The Chrome extension ID is the 32-character string at the end of the Web Store URL.

Step 2: Build the input

Here is an input that mixes all three stores:

{
  "apps": [
    "310633997",
    "com.whatsapp",
    "ddkjiahejlhfcafbddmgiahcphecmpfh"
  ],
  "countries": ["us", "gb"],
  "language": "en",
  "maxReviewsPerApp": 100
}

What each field does:

apps (required): your mixed list of IDs or URLs.
countries: two-letter codes. Apple and Google Play reviews are fetched per country. Chrome Web Store reviews aren't split by country, so this is ignored for extensions.
language: used by Google Play and the Chrome Web Store. For Chrome, only reviews in this language are returned. Apple's language follows the country.
maxReviewsPerApp: cap per app per country (per extension for Chrome). Apple never returns more than 500 per app per country.

Two optional switches, both off by default:

sentiment: true adds a simple positive / neutral / negative label. It's a rule (English keywords plus star rating), not an ML model.
includeReviewerName: true adds a masked nickname, first character plus ***.

Step 3: Run it

Option A: in the browser

Open the Actor page (https://apify.com/tiandu-tech/apify-002-app-reviews), paste the JSON into the input's JSON view (or fill in the form), and click Start. When the run finishes, the reviews appear as a table in the run's Output tab (the table view is named Reviews). Use Export there to download them as JSON, CSV or Excel.

Option B: from Python

Install the official client:

pip install "apify-client>=3.3,<4"
export APIFY_TOKEN=...   # from Apify Console → Settings → API & Integrations

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run_input = {
    "apps": ["310633997", "com.whatsapp", "ddkjiahejlhfcafbddmgiahcphecmpfh"],
    "countries": ["us", "gb"],
    "language": "en",
    "maxReviewsPerApp": 100,
}

run = client.actor("tiandu-tech/apify-002-app-reviews").call(run_input=run_input)
print("Run status:", run.status)

reviews = list(client.dataset(run.default_dataset_id).iterate_items())
print(f"Got {len(reviews)} reviews")

by_store = {}
for r in reviews:
    by_store[r["store"]] = by_store.get(r["store"], 0) + 1
print(by_store)   # e.g. {'google': ..., 'chrome': ..., 'apple': ...}

call() waits for the run to finish. In apify-client 3.x it returns a typed Run object, so you read run.status and run.default_dataset_id. The older 2.x client returned a plain dict; with 2.x use run["status"] and run["defaultDatasetId"] instead.

Never hard-code the token in your script; read it from an environment variable as above.

Option C: plain HTTP

Apify's run-sync-get-dataset-items endpoint runs the Actor and returns the items in one call (good for small runs):

curl -X POST \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"apps":["com.whatsapp","ddkjiahejlhfcafbddmgiahcphecmpfh"],"maxReviewsPerApp":20}' \
  "https://api.apify.com/v2/acts/tiandu-tech~apify-002-app-reviews/run-sync-get-dataset-items?format=json"

Step 4: Read the output

Every review has the same fields regardless of store:

Field	Notes
`store`	`apple`, `google` or `chrome`
`appId`	app ID, package name or 32-letter extension ID
`country`	`null` for Chrome
`language`	review language
`reviewId`	unique within a store
`rating`	1–5
`title`	`null` for Chrome; Google Play reviews have no title either
`text`	review body; emails and phone numbers are redacted
`appVersion`	version the reviewer was using
`thumbsUp`	helpful count
`reviewedAt`	ISO 8601 timestamp
`developerReply`	reply text, if any

Because the schema is shared, you can drop the whole dataset into one spreadsheet or DataFrame and group by store, appId or appVersion straight away.

Things to know

Duplicates across countries are removed. The same reviewId is kept once, and country is the first country it was seen in. The run summary reports how many were removed.
Empty results are explained. A wrong ID or an app without reviews shows up in the summary rather than failing silently.
Resilience: network errors, HTTP 429 and 5xx are retried up to 3 times with back-off. If a store's page format changes and two tasks in a row fail to parse, the rest of that store's tasks are skipped so no wrong data is written.
Privacy: reviewer names are off by default, and the Actor never outputs avatars, profile links or user IDs. You're still responsible for following the data-protection rules that apply to you.

Wrap-up

That's it: one input list, one run, one schema. Export to CSV for a quick read, or load the dataset into Python (the companion post shows how to find pain points in it).

Try it here: https://apify.com/tiandu-tech/apify-002-app-reviews

A runnable example project (collect + analyze) is on GitHub: https://github.com/DongmeiHerman/app-reviews-pain-points