App Ratings API

Retrieve mobile app ratings from Apple App Store and Google Play Store. Track app performance as alternative data for consumer-facing companies.

Endpoint

GET /v2/app-ratings/{symbol}

Authentication

Authenticate using one of the following methods (in order of recommendation):

Method	Example
Bearer token (recommended)	`Authorization: Bearer YOUR_API_KEY`
X-API-Key header	`X-API-Key: YOUR_API_KEY`
Query parameter	`?apiKey=YOUR_API_KEY`
Legacy query parameter	`?token=YOUR_API_KEY`

Parameters

Path Parameters

Parameter	Type	Required	Description
`symbol`	string	Yes	Stock ticker symbol (e.g., `UBER`, `DASH`)

Query Parameters

Parameter	Type	Required	Description
`startDate`	string	No	Start date (YYYY-MM-DD)
`endDate`	string	No	End date (YYYY-MM-DD)
`limit`	integer	No	Maximum number of data points to return

Request

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

df = fb.app_ratings.ticker("UBER",
                           date_from="2025-01-01",
                           date_to="2025-06-30",
                           as_dataframe=True)
print(df)

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.finbrain.tech/v2/app-ratings/UBER"

import requests

url = "https://api.finbrain.tech/v2/app-ratings/UBER"
headers = {"Authorization": "Bearer YOUR_API_KEY"}
params = {"startDate": "2025-01-01", "endDate": "2026-01-31", "limit": 10}

response = requests.get(url, headers=headers, params=params)
data = response.json()

for entry in data["data"]["data"]:
    ios = entry["ios"]
    android = entry["android"]
    print(f"{entry['date']}: iOS {ios['score']}, Android {android['score']}")

#include <iostream>
#include <string>
#include <curl/curl.h>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* userp) {
    userp->append((char*)contents, size * nmemb);
    return size * nmemb;
}

json get_app_ratings(const std::string& symbol, const std::string& api_key) {
    CURL* curl = curl_easy_init();
    std::string response;

    if (curl) {
        std::string url = "https://api.finbrain.tech/v2/app-ratings/" + symbol;

        struct curl_slist* headers = nullptr;
        std::string auth_header = "Authorization: Bearer " + api_key;
        headers = curl_slist_append(headers, auth_header.c_str());

        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
        curl_easy_perform(curl);
        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }

    return json::parse(response);
}

int main() {
    auto result = get_app_ratings("UBER", "YOUR_API_KEY");

    for (auto& entry : result["data"]["data"]) {
        std::cout << entry["date"].get<std::string>() << ": "
                  << "iOS " << entry["ios"]["score"].get<double>()
                  << ", Android " << entry["android"]["score"].get<double>()
                  << std::endl;
    }

    return 0;
}

use reqwest::blocking::Client;
use serde::Deserialize;
use std::error::Error;

#[derive(Debug, Deserialize)]
struct IosRating {
    score: f64,
    #[serde(rename = "ratingsCount")]
    ratings_count: i64,
}

#[derive(Debug, Deserialize)]
struct AndroidRating {
    score: f64,
    #[serde(rename = "ratingsCount")]
    ratings_count: i64,
    #[serde(rename = "installCount")]
    install_count: i64,
}

#[derive(Debug, Deserialize)]
struct AppRatingEntry {
    date: String,
    ios: IosRating,
    android: AndroidRating,
}

#[derive(Debug, Deserialize)]
struct AppRatingsInner {
    symbol: String,
    name: String,
    data: Vec<AppRatingEntry>,
}

#[derive(Debug, Deserialize)]
struct AppRatingsResponse {
    success: bool,
    data: AppRatingsInner,
}

fn get_app_ratings(symbol: &str, api_key: &str)
    -> Result<AppRatingsResponse, Box<dyn Error>> {
    let url = format!(
        "https://api.finbrain.tech/v2/app-ratings/{}",
        symbol
    );

    let client = Client::new();
    let response: AppRatingsResponse = client
        .get(&url)
        .header("Authorization", format!("Bearer {}", api_key))
        .send()?
        .json()?;

    Ok(response)
}

fn main() -> Result<(), Box<dyn Error>> {
    let result = get_app_ratings("UBER", "YOUR_API_KEY")?;

    for entry in &result.data.data {
        println!("{}: iOS {:.2}, Android {:.2}",
            entry.date, entry.ios.score, entry.android.score);
    }

    Ok(())
}

const response = await fetch(
  "https://api.finbrain.tech/v2/app-ratings/UBER",
  { headers: { "Authorization": "Bearer YOUR_API_KEY" } }
);
const result = await response.json();

for (const entry of result.data.data) {
  console.log(`${entry.date}: iOS ${entry.ios.score}, Android ${entry.android.score}`);
}

Response

Success Response (200 OK)

{
  "success": true,
  "data": {
    "symbol": "AAPL",
    "name": "Apple Inc.",
    "data": [
      {
        "date": "2026-01-16",
        "ios": {
          "score": 4.07,
          "ratingsCount": 111561
        },
        "android": {
          "score": 4.61,
          "ratingsCount": 696519,
          "installCount": 168682133
        }
      },
      {
        "date": "2026-01-09",
        "ios": {
          "score": 4.07,
          "ratingsCount": 111409
        },
        "android": {
          "score": 4.61,
          "ratingsCount": 694535,
          "installCount": 168160710
        }
      }
    ]
  },
  "meta": {
    "timestamp": "2026-01-19T15:06:32.888Z"
  }
}

Response Fields

Field	Type	Description
`success`	boolean	Whether the request was successful
`data`	object	Response data wrapper
`data.symbol`	string	Stock ticker symbol
`data.name`	string	Company name
`data.data`	array	Array of rating data points (weekly snapshots)
`meta.timestamp`	string	Response timestamp (ISO 8601)

App Rating Object Fields

Field	Type	Description
`date`	string	Date of the snapshot (YYYY-MM-DD)
`ios`	object	iOS App Store metrics
`ios.score`	number	iOS App Store rating (1-5)
`ios.ratingsCount`	integer	Number of App Store ratings
`android`	object	Google Play Store metrics
`android.score`	number	Google Play Store rating (1-5)
`android.ratingsCount`	integer	Number of Play Store ratings
`android.installCount`	integer	Play Store install count

Interpretation

Rating	Quality
4.5 - 5.0	Excellent
4.0 - 4.5	Good
3.5 - 4.0	Average
3.0 - 3.5	Below average
Below 3.0	Poor

Errors

Code	Error	Description
400	Bad Request	Invalid symbol
401	Unauthorized	Invalid or missing API key
403	Forbidden	Authenticated, but not authorized to access this resource
404	Not Found	Symbol not found
429	Too Many Requests	Rate limit exceeded — wait and retry
500	Internal Server Error	Server-side error

App Ratings Dataset - Use cases and analysis examples
LinkedIn Data - Employee metrics
News Sentiment - News sentiment