App Ratings Dataset

Access mobile app store ratings and review data from Apple App Store and Google Play Store. Track app performance metrics as alternative data signals for consumer-facing companies.

What’s Included

The App Ratings dataset provides:

• App Store Ratings: iOS app rating (1-5 stars)
• Play Store Ratings: Android app rating (1-5 stars)
• Rating Counts: Number of ratings per platform
• Rating Changes: Track rating movements over time
• Historical Data: Long-term app performance trends
• Weekly Updates: Fresh data every week

Coverage

Coverage	Details
Platforms	Apple App Store, Google Play Store
Companies	Consumer-facing companies with mobile apps
Update Frequency	Weekly
Historical Data	2+ years

Note: The playStoreInstallCount field may be null for some tickers.

Quick Start

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

# Get app ratings as DataFrame
df = fb.app_ratings.ticker("S&P 500", "UBER", as_dataframe=True)
print(df.head())

For complete code examples in Python, JavaScript, C++, Rust, and cURL, see the API Reference.

Interpreting App Ratings

Rating Levels

Rating	Interpretation	Signal
4.5 - 5.0	Excellent	Strong user satisfaction
4.0 - 4.5	Good	Healthy app performance
3.5 - 4.0	Average	Room for improvement
3.0 - 3.5	Below average	User concerns
< 3.0	Poor	Significant issues

Rating Trends

Trend	Interpretation
Rising rating	Improving product/service
Stable rating	Consistent experience
Falling rating	Potential issues emerging
Rating divergence (iOS vs Android)	Platform-specific problems

Use Cases

App Quality Monitor

Monitor app ratings for quality signals:

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

def monitor_app_quality(market, ticker):
    """Monitor app quality and detect rating changes"""
    data = fb.app_ratings.ticker(market, ticker)

    if not data.get("appRatings") or len(data["appRatings"]) < 7:
        return None

    latest = data["appRatings"][0]
    week_ago = data["appRatings"][6]

    app_store_change = latest["appStoreScore"] - week_ago["appStoreScore"]
    play_store_change = latest["playStoreScore"] - week_ago["playStoreScore"]

    alerts = []

    if app_store_change < -0.1:
        alerts.append(f"App Store rating dropped {abs(app_store_change):.2f}")
    if play_store_change < -0.1:
        alerts.append(f"Play Store rating dropped {abs(play_store_change):.2f}")
    if latest["appStoreScore"] < 4.0:
        alerts.append(f"App Store rating below 4.0 ({latest['appStoreScore']:.1f})")
    if latest["playStoreScore"] < 4.0:
        alerts.append(f"Play Store rating below 4.0 ({latest['playStoreScore']:.1f})")

    return {
        "ticker": ticker,
        "current_app_store": latest["appStoreScore"],
        "current_play_store": latest["playStoreScore"],
        "app_store_change_7d": app_store_change,
        "play_store_change_7d": play_store_change,
        "alerts": alerts,
        "status": "warning" if alerts else "healthy"
    }

result = monitor_app_quality("S&P 500", "UBER")
print(f"Status: {result['status']}")
if result["alerts"]:
    print("Alerts:")
    for alert in result["alerts"]:
        print(f"  - {alert}")

Consumer App Comparison

Compare app performance across competitors:

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

def compare_app_ratings(market, tickers):
    """Compare app ratings across competitors"""
    results = []

    for ticker in tickers:
        try:
            data = fb.app_ratings.ticker(market, ticker)

            if not data.get("appRatings"):
                continue

            latest = data["appRatings"][0]
            # Calculate combined rating
            combined = (latest["appStoreScore"] + latest["playStoreScore"]) / 2
            results.append({
                "ticker": ticker,
                "app_store": latest["appStoreScore"],
                "play_store": latest["playStoreScore"],
                "combined": combined,
                "total_ratings": latest["appStoreRatingsCount"] + latest["playStoreRatingsCount"]
            })
        except Exception:
            continue

    return sorted(results, key=lambda x: x["combined"], reverse=True)

# Compare food delivery apps
delivery_apps = ["UBER", "DASH", "GRUB"]
comparison = compare_app_ratings("S&P 500", delivery_apps)

print("Food Delivery App Comparison:")
print("-" * 50)
for app in comparison:
    print(f"{app['ticker']}: Combined {app['combined']:.2f} | App Store {app['app_store']:.1f} | Play Store {app['play_store']:.1f}")

Rating Trend Analysis

Analyze rating trends over time:

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

def analyze_rating_trend(market, ticker, days=30):
    """Analyze rating trend over time"""
    data = fb.app_ratings.ticker(market, ticker)

    if not data.get("appRatings") or len(data["appRatings"]) < days:
        return None

    ratings = data["appRatings"][:days]

    # Calculate combined rating for each day
    def combined(r):
        return (r["appStoreScore"] + r["playStoreScore"]) / 2

    # Calculate trend
    first_half = ratings[days//2:]
    second_half = ratings[:days//2]

    first_avg = sum(combined(r) for r in first_half) / len(first_half)
    second_avg = sum(combined(r) for r in second_half) / len(second_half)

    change = second_avg - first_avg

    if change > 0.05:
        trend = "improving"
    elif change < -0.05:
        trend = "declining"
    else:
        trend = "stable"

    return {
        "ticker": ticker,
        "current_rating": combined(ratings[0]),
        "30d_change": change,
        "trend": trend
    }

result = analyze_rating_trend("S&P 500", "NFLX", 30)
print(f"{result['ticker']}: {result['trend']} (30d change: {result['30d_change']:+.2f})")

Platform Divergence Detection

Detect when iOS and Android ratings diverge:

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

def detect_platform_divergence(market, ticker, threshold=0.3):
    """Detect significant App Store vs Play Store rating divergence"""
    data = fb.app_ratings.ticker(market, ticker)

    if not data.get("appRatings"):
        return None

    latest = data["appRatings"][0]
    divergence = abs(latest["appStoreScore"] - latest["playStoreScore"])

    alert = None
    if divergence > threshold:
        better_platform = "App Store" if latest["appStoreScore"] > latest["playStoreScore"] else "Play Store"
        worse_platform = "Play Store" if better_platform == "App Store" else "App Store"
        alert = f"{worse_platform} rating significantly lower than {better_platform}"

    return {
        "ticker": ticker,
        "app_store_rating": latest["appStoreScore"],
        "play_store_rating": latest["playStoreScore"],
        "divergence": divergence,
        "alert": alert
    }

result = detect_platform_divergence("S&P 500", "META")
if result["alert"]:
    print(f"Alert: {result['alert']}")
    print(f"  App Store: {result['app_store_rating']:.1f} | Play Store: {result['play_store_rating']:.1f}")

Related Resources

• App Ratings API Reference - Endpoint details, parameters, and response schema
• LinkedIn Metrics - Workforce and follower data
• News Sentiment - Market sentiment scores
• Python SDK Documentation