Google Play Sentiment Tracking via Search API
Track app review sentiment, monitor competitor ratings, extract feature requests via search API without building a Google Play scraper.
You can track Google Play app review sentiment without building a scraper. A search API that covers Google returns review snippets, ratings context, and user complaints surfaced in search results -- enough to monitor competitor apps, catch feature requests, and detect rating trends without managing browser automation or dealing with Google Play's anti-scraping measures.
Why scraping Google Play is painful
The direct approach -- scraping the Google Play Store page -- has well-known problems in 2026:
- Google Play renders reviews with JavaScript. You need a headless browser (Puppeteer, Playwright) or a rendering service.
- Reviews are paginated with infinite scroll. Getting more than the first 40 reviews requires scroll simulation and wait logic.
- Google actively blocks automated access. IP rotation, CAPTCHA solving, and user-agent spoofing add operational complexity.
- The page structure changes without notice. A layout update can break your selectors overnight.
Libraries like google-play-scraper abstract some of this, but they break periodically and have open issues about rate limits and missing reviews.
The search API approach
Instead of scraping the Play Store directly, search for app reviews through Google. Queries like "[app name] google play reviews 2026" or "[app name] app review complaints" return results that include review aggregation sites, forum discussions, and Google Play listings with review snippets.
import requests, os
API_KEY = os.environ["SCAVIO_API_KEY"]
def get_app_review_signals(app_name: str) -> dict:
"""Pull review signals for an app from search results."""
queries = [
f"{app_name} google play reviews 2026",
f"{app_name} app complaints bugs",
f"{app_name} app feature requests users",
]
all_results = []
for q in queries:
resp = requests.post(
"https://api.scavio.dev/api/v1/search",
headers={"x-api-key": API_KEY},
json={"query": q, "num_results": 10},
)
if resp.status_code == 200:
all_results.extend(resp.json().get("results", []))
return {
"app": app_name,
"total_signals": len(all_results),
"results": all_results,
}
# 3 queries x $0.005 = $0.015 per app
signals = get_app_review_signals("Notion")
print(f"Found {signals['total_signals']} review signals for {signals['app']}")Extracting sentiment from search snippets
Search result snippets contain condensed review sentiment. Google surfaces the most relevant text fragments, which tend to include strong opinions -- both positive and negative. You can classify these without a dedicated NLP pipeline:
NEGATIVE_SIGNALS = [
"crash", "bug", "slow", "broken", "worst", "terrible",
"uninstall", "waste", "scam", "ads", "battery drain",
"not working", "freezes", "lost data", "subscription",
]
POSITIVE_SIGNALS = [
"love", "best", "amazing", "fast", "smooth", "recommend",
"intuitive", "great app", "must have", "perfect",
]
def classify_snippet(snippet: str) -> str:
text = snippet.lower()
neg = sum(1 for w in NEGATIVE_SIGNALS if w in text)
pos = sum(1 for w in POSITIVE_SIGNALS if w in text)
if neg > pos:
return "negative"
if pos > neg:
return "positive"
return "neutral"
def analyze_sentiment(app_name: str) -> dict:
data = get_app_review_signals(app_name)
breakdown = {"positive": 0, "negative": 0, "neutral": 0}
complaints = []
for r in data["results"]:
snippet = r.get("snippet", "")
sentiment = classify_snippet(snippet)
breakdown[sentiment] += 1
if sentiment == "negative":
complaints.append(snippet[:120])
return {
"app": app_name,
"sentiment": breakdown,
"top_complaints": complaints[:5],
}
result = analyze_sentiment("Notion")
print(f"Sentiment: {result['sentiment']}")
for c in result["top_complaints"]:
print(f" Complaint: {c}")Competitive monitoring
The real value is tracking multiple apps over time. If you run a mobile app, monitoring competitor review sentiment weekly reveals feature gaps, quality issues, and user migration triggers.
import json, datetime
COMPETITORS = ["Notion", "Obsidian", "Craft", "Logseq"]
HISTORY_FILE = "app_sentiment_history.json"
def weekly_competitor_scan():
"""Weekly scan: 4 apps x 3 queries x $0.005 = $0.06/week."""
try:
with open(HISTORY_FILE) as f:
history = json.load(f)
except FileNotFoundError:
history = {}
today = datetime.date.today().isoformat()
for app in COMPETITORS:
result = analyze_sentiment(app)
history.setdefault(app, []).append({
"date": today,
"sentiment": result["sentiment"],
"top_complaints": result["top_complaints"],
})
with open(HISTORY_FILE, "w") as f:
json.dump(history, f, indent=2)
# Detect shifts
for app, entries in history.items():
if len(entries) >= 2:
prev_neg = entries[-2]["sentiment"]["negative"]
curr_neg = entries[-1]["sentiment"]["negative"]
if curr_neg > prev_neg + 3:
print(f"ALERT: {app} negative sentiment spiked")
weekly_competitor_scan()Tracking feature requests
User reviews are a source of unfiltered feature requests. Search for "[app name] wish it had" or "[app name] missing feature" to surface what users want but the app does not offer. This is competitive intelligence you can act on.
def find_feature_requests(app_name: str) -> list[str]:
queries = [
f"{app_name} wish it had feature",
f"{app_name} missing feature reddit",
f"{app_name} please add feature request",
]
requests_found = []
for q in queries:
resp = requests.post(
"https://api.scavio.dev/api/v1/search",
headers={"x-api-key": API_KEY},
json={"query": q, "num_results": 5},
)
if resp.status_code == 200:
for r in resp.json().get("results", []):
snippet = r.get("snippet", "")
if snippet:
requests_found.append(snippet[:150])
return requests_found
features = find_feature_requests("Notion")
for f in features[:5]:
print(f"Feature request: {f}")Limitations
- Search-based sentiment tracking is directional, not precise. You get trends and signals, not statistically rigorous scores. For precise analysis, you need direct access to the review corpus.
- Review recency depends on what Google indexes. Very recent reviews (last 24-48 hours) may not appear in search results yet.
- This approach works best for popular apps with hundreds of reviews that generate search-indexable content. Niche apps with few reviews produce sparse signals.
When this approach makes sense
Use search-based sentiment tracking when you need weekly or monthly competitive intelligence without building and maintaining a scraper. At $0.06/week for four competitors, the cost is negligible. For real-time review monitoring or academic-grade sentiment analysis, invest in a direct Play Store API integration or a dedicated service. For most product teams, the search approach gives 80% of the insight at 5% of the engineering effort.