App Ratings Dataset

Name: FinBrain
Brand: FinBrain Technologies

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:

iOS Ratings: App Store rating (1-5 stars) and ratings count
Android Ratings: Play Store rating (1-5 stars), ratings count, and install count
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 android.installCount field may be null for some symbols.

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

df = fb.app_ratings.ticker("UBER", as_dataframe=True)
print(df)

import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.finbrain.tech"

headers = {"Authorization": f"Bearer {API_KEY}"}

response = requests.get(f"{BASE_URL}/v2/app-ratings/UBER", headers=headers)
result = response.json()

# Access app ratings from the response envelope
for entry in result["data"][:5]:
    ios = entry["ios"]
    android = entry["android"]
    print(f"{entry['date']}: iOS {ios['score']} | Android {android['score']}")

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

Visualization

Plot app ratings with the built-in SDK chart:

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

# Interactive chart: ratings count (bars) + score (line)
fb.plot.app_ratings("UBER", store="app")   # iOS App Store
fb.plot.app_ratings("UBER", store="play")  # Google Play Store

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(symbol):
    """Monitor app quality and detect rating changes"""
    df = fb.app_ratings.ticker(symbol, as_dataframe=True)

    if df.empty or len(df) < 7:
        return None

    ios_change = df["ios_score"].iloc[0] - df["ios_score"].iloc[6]
    android_change = df["android_score"].iloc[0] - df["android_score"].iloc[6]

    alerts = []

    if ios_change < -0.1:
        alerts.append(f"App Store rating dropped {abs(ios_change):.2f}")
    if android_change < -0.1:
        alerts.append(f"Play Store rating dropped {abs(android_change):.2f}")
    if df["ios_score"].iloc[0] < 4.0:
        alerts.append(f"App Store rating below 4.0 ({df['ios_score'].iloc[0]:.1f})")
    if df["android_score"].iloc[0] < 4.0:
        alerts.append(f"Play Store rating below 4.0 ({df['android_score'].iloc[0]:.1f})")

    return {
        "symbol": symbol,
        "current_ios": df["ios_score"].iloc[0],
        "current_android": df["android_score"].iloc[0],
        "ios_change_7d": ios_change,
        "android_change_7d": android_change,
        "alerts": alerts,
        "status": "warning" if alerts else "healthy"
    }

result = monitor_app_quality("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(tickers):
    """Compare app ratings across competitors"""
    results = []

    for symbol in tickers:
        try:
            df = fb.app_ratings.ticker(symbol, as_dataframe=True)

            if df.empty:
                continue

            ios = df["ios_score"].iloc[0]
            android = df["android_score"].iloc[0]
            combined = (ios + android) / 2
            total_ratings = df["ios_ratingsCount"].iloc[0] + df["android_ratingsCount"].iloc[0]

            results.append({
                "symbol": symbol,
                "ios": ios,
                "android": android,
                "combined": combined,
                "total_ratings": total_ratings
            })
        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(delivery_apps)

print("Food Delivery App Comparison:")
print("-" * 50)
for app in comparison:
    print(f"{app['symbol']}: Combined {app['combined']:.2f} | iOS {app['ios']:.1f} | Android {app['android']:.1f}")

Rating Trend Analysis

Analyze rating trends over time:

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

def analyze_rating_trend(symbol, days=30):
    """Analyze rating trend over time"""
    df = fb.app_ratings.ticker(symbol, as_dataframe=True)

    if df.empty or len(df) < days:
        return None

    # Calculate combined rating for each row
    df["combined"] = (df["ios_score"] + df["android_score"]) / 2

    recent = df["combined"].head(days)

    # Calculate trend: compare recent half vs older half
    second_half_avg = recent.head(days // 2).mean()
    first_half_avg = recent.tail(days // 2).mean()

    change = second_half_avg - first_half_avg

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

    return {
        "symbol": symbol,
        "current_rating": df["combined"].iloc[0],
        "30d_change": change,
        "trend": trend
    }

result = analyze_rating_trend("NFLX", 30)
print(f"{result['symbol']}: {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(symbol, threshold=0.3):
    """Detect significant App Store vs Play Store rating divergence"""
    df = fb.app_ratings.ticker(symbol, as_dataframe=True)

    if df.empty:
        return None

    ios_score = df["ios_score"].iloc[0]
    android_score = df["android_score"].iloc[0]
    divergence = abs(ios_score - android_score)

    alert = None
    if divergence > threshold:
        better_platform = "App Store" if ios_score > android_score 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 {
        "symbol": symbol,
        "ios_rating": ios_score,
        "android_rating": android_score,
        "divergence": divergence,
        "alert": alert
    }

result = detect_platform_divergence("META")
if result["alert"]:
    print(f"Alert: {result['alert']}")
    print(f"  App Store: {result['ios_rating']:.1f} | Play Store: {result['android_rating']:.1f}")

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