• Mobile apps
  • App Store
  • Ratings
  • Store Data

App Store rating history: track any app's rating over time

App Store rating history is not public. Rebuild any app's rating history from daily snapshots, the average of new ratings and reviews by version.

Author
Extenify Team
Published
Reading time
13 min read
Two smartphones stacked on a beige outdoor chair cushion next to a grey stone-tiled floor

App Store rating history is something Apple does not give you. A product page shows the rating and the number of ratings as they are today, and App Store Connect lists reviews you can filter, but neither shows how the rating moved last month, or whether the version you shipped two weeks ago made it better or worse. People search for "App Store ratings over time" because the answer is not in either place.

You can rebuild it, though, for your own app and for any competitor, from public data. This guide shows three methods we tested on November 3, 2026: daily snapshots of the rating and count per storefront, a simple formula that recovers the average of only the new ratings between two snapshots, and the average star rating of written reviews per app version and per week. Each comes with a short Node.js script and real output.

Key takeaways

  • The App Store keeps no public rating history, and App Store Connect has no ratings-over-time chart. Google Play Console does; Apple does not.
  • Record averageUserRating and userRatingCount from the iTunes lookup endpoint every day, per storefront, at full precision.
  • From two snapshots you can recover the average of only the ratings added in between: (a2 × n2 - a1 × n1) / (n2 - n1). That number moves long before the overall rating does.
  • The public reviews feed returns up to 500 recent reviews per country with the app version on each, enough to compare versions and weeks.
  • Written reviews skew lower than star-only ratings. For Slack in the US, recent written reviews averaged 3.1 to 3.8 stars per version while the overall rating was 4.14.

Does the App Store keep a rating history?

No. Apple's ratings and reviews overview describes "a single overview rating for your app for each country or region of the App Store", and the country of a rating "reflects the location where the customer initially purchased the app." The help page on how to view ratings and reviews lets you filter reviews by country or region, by version and by star rating, and adds that iOS 11 and later show "an overview rating based on all ratings after Sept 19, 2017." There is no chart, no daily series and no export of the rating itself.

Three more rules from the same pages shape any history you build:

  • Edits replace. When a customer edits a rating or review, or submits a new one, it replaces the previous one. A rating can go down without a single new rating.
  • Resets wipe the slate. You can reset the rating when you release a new version. The product page then shows a notice until "sufficient users have rated the new version." Our guide to App Store version history explains how to spot which version a reset came with.
  • Ratings and reviews are different things. Every review has a rating, but most ratings come without a review. Apple's API and feeds give you the written reviews; star-only ratings exist only in the summary numbers.

Third-party trackers fill the gap the same way you can: they take a snapshot every day from the day they start tracking an app. Nobody can recover days that nobody recorded, so the best time to start is before you need the history.

Method 1: record a daily rating snapshot per storefront

The iTunes lookup endpoint returns an app's current rating and rating count for one storefront at a time, with no API key. Our guide to the iTunes Search API covers its fields and limits. Here is what it returned for Slack (app ID 618783545) on November 3, 2026:

Field Value (US storefront)
averageUserRating 4.14315
userRatingCount 54,921
averageUserRatingForCurrentVersion 4.14315
userRatingCountForCurrentVersion 54,921
version 26.10.40, released October 28, 2026

The "current version" fields matched the overall ones exactly, which is what you would expect now that ratings carry over between versions unless the developer resets them. Do not use them as a per-version rating; Method 3 does that job.

The script below appends one row per storefront per run to a JSON Lines file and compares each row with the previous one for the same app and storefront. It needs Node.js 18 or newer and no packages.

// rating-snapshot.mjs: record an App Store rating snapshot per storefront and compare it with the last one.
// Usage: node rating-snapshot.mjs 618783545 us gb de
import { appendFile, readFile } from 'node:fs/promises';

const FILE = 'rating-history.jsonl';
const [id, ...countries] = process.argv.slice(2);
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function lookup(appId, country) {
  const res = await fetch(`https://itunes.apple.com/lookup?id=${appId}&country=${country}`);
  if (!res.ok) throw new Error(`HTTP ${res.status} for ${country}`);
  const data = await res.json();
  return data.resultCount > 0 ? data.results[0] : null;
}

async function lastSnapshots() {
  const last = new Map();
  try {
    for (const line of (await readFile(FILE, 'utf8')).split('\n')) {
      if (!line.trim()) continue;
      const row = JSON.parse(line);
      last.set(`${row.id}:${row.country}`, row);
    }
  } catch {
    // first run: no history yet
  }
  return last;
}

// What the ratings added between two snapshots averaged, recovered from the two running averages.
export function compare(before, after) {
  const added = after.count - before.count;
  if (after.count < before.count * 0.5) return { event: 'reset', added };
  if (added <= 0) return { event: 'no new ratings', added };
  const stars = after.average * after.count - before.average * before.count;
  return { event: 'new ratings', added, newRatingsAverage: Number((stars / added).toFixed(2)) };
}

const previous = await lastSnapshots();
for (const country of countries.length ? countries : ['us']) {
  const app = await lookup(id, country);
  await sleep(500);
  if (!app) continue;
  const row = {
    date: new Date().toISOString().slice(0, 10),
    id,
    country,
    version: app.version,
    average: app.averageUserRating, // keep full precision, never the rounded display value
    count: app.userRatingCount,
  };
  await appendFile(FILE, `${JSON.stringify(row)}\n`);
  const before = previous.get(`${id}:${country}`);
  console.log(country, row.version, row.average, row.count, before ? compare(before, row) : 'first snapshot');
}

The first run printed:

us 26.10.40 4.14316 54891 first snapshot
gb 26.10.40 4.03005 4858 first snapshot
de 26.10.40 4.17017 3849 first snapshot

Look at the US row: 54,891 ratings, 30 fewer than the 54,921 the same endpoint returned a few minutes earlier. The lookup is served from caches that do not refresh at the same moment, so two reads close together can disagree. Treat a single day's change of a few dozen ratings as noise, and if a reading ever goes backwards by a small amount, keep the higher one or wait for the next day. Schedule the script once a day; our guide to a Node.js cron job shows how to run it on time and catch up after downtime.

Method 2: recover the average of new ratings

The overall rating of an app with tens of thousands of ratings barely moves, even when a bad release is making people angry. What you want to know is how the ratings that came in this week compare with the rest. Two snapshots give you that, because a running average times its count is the total number of stars:

new ratings average = (a2 × n2 - a1 × n1) / (n2 - n1)

An illustration with made-up numbers: an app at 4.20000 from 10,000 ratings last Monday and 4.18700 from 10,200 ratings this Monday holds 42,707 stars now against 42,000 then. The 200 new ratings brought 707 stars, an average of 3.54. The overall rating fell by only 0.013, while the week's new ratings averaged two thirds of a star below everything before them. The compare function in the script returns exactly this as newRatingsAverage.

Two conditions make the number trustworthy:

  • Full precision. The lookup returns averages to five decimal places. If you store the rounded value shown on the product page, the rounding error swamps the signal: for Slack's 54,921 US ratings, a rounding error of 0.005 is worth about 275 stars, and spread over 180 new ratings that is an error of about 1.5 stars in the result.
  • Enough new ratings. Use weekly differences, not daily ones, and skip any period with fewer than about 50 new ratings in a storefront. Cache noise of a few dozen ratings is otherwise large compared with the change.

Edits and resets break the formula. If someone changes a five-star rating to a one-star rating, the count stays the same and the average drops, so a period with no new ratings but a lower average is a sign of edits. A count that falls by half or more is almost always a reset, and the script reports it as one. Start a new baseline from that day.

Method 3: written reviews by version and by week

Snapshots tell you that something changed. Reviews tell you which version changed it. The App Store's public customer reviews feed returns the most recent reviews for one storefront, 50 per page for up to 10 pages, and every entry includes the star rating and the app version. Our guide to App Store review alerts covers the feed and the App Store Connect API in detail.

This script reads all 10 pages and prints the average rating and the share of one- and two-star reviews per version (versions with at least 10 reviews) and per week:

// reviews-by-version.mjs: average star rating of recent written reviews, per app version and per week.
// Usage: node reviews-by-version.mjs 618783545 us
const [id, country = 'us'] = process.argv.slice(2);
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function fetchReviews(appId, cc) {
  const reviews = [];
  for (let page = 1; page <= 10; page++) {
    const url = `https://itunes.apple.com/${cc}/rss/customerreviews/page=${page}/id=${appId}/sortby=mostrecent/json`;
    const res = await fetch(url);
    if (!res.ok) break;
    const text = await res.text();
    if (!text.trim()) break; // past the last page the feed returns an empty body
    const entries = JSON.parse(text).feed?.entry ?? [];
    const list = Array.isArray(entries) ? entries : [entries];
    if (list.length === 0) break;
    for (const e of list) {
      reviews.push({
        rating: Number(e['im:rating'].label),
        version: e['im:version'].label,
        date: e.updated.label.slice(0, 10),
      });
    }
    await sleep(500);
  }
  return reviews;
}

function summarize(reviews, keyOf) {
  const groups = new Map();
  for (const r of reviews) {
    const key = keyOf(r);
    const g = groups.get(key) ?? { n: 0, sum: 0, low: 0 };
    g.n += 1;
    g.sum += r.rating;
    if (r.rating <= 2) g.low += 1;
    groups.set(key, g);
  }
  return [...groups].map(([key, g]) => ({
    key,
    reviews: g.n,
    average: Number((g.sum / g.n).toFixed(2)),
    lowStarShare: `${Math.round((g.low / g.n) * 100)}%`,
  }));
}

// Monday of the review's week, so weeks sort and compare cleanly.
function weekOf(date) {
  const d = new Date(`${date}T00:00:00Z`);
  d.setUTCDate(d.getUTCDate() - ((d.getUTCDay() + 6) % 7));
  return d.toISOString().slice(0, 10);
}

const reviews = await fetchReviews(id, country);
console.log(`${reviews.length} reviews, ${reviews.at(-1)?.date} to ${reviews[0]?.date}`);
console.table(summarize(reviews, (r) => r.version).filter((row) => row.reviews >= 10));
console.table(summarize(reviews, (r) => weekOf(r.date)).sort((a, b) => (a.key < b.key ? -1 : 1)));

For Slack in the US storefront it returned 500 reviews written between August 28 and November 2, 2026. Per version:

Version Reviews Average 1 to 2 stars
26.10.40 14 3.64 36%
26.10.30 38 3.76 29%
26.10.20 60 3.47 30%
26.10.11 43 3.07 44%
26.09.50 73 3.36 38%
26.09.40 77 3.42 30%
26.09.30 40 3.52 33%
26.09.20 40 3.45 38%
26.09.10 48 3.83 23%
26.08.40 53 3.60 34%

And per week, which tells the same story in time: the weeks of October 5 and October 12 averaged 3.13 and 3.12 with 44% and 40% low-star reviews, against 3.51 to 3.97 in the weeks around them.

What this shows:

  • One version stood out. 26.10.11 had the lowest average and the highest low-star share of any version in the window. A release that drew 44% one- and two-star reviews deserves a look at what those reviews say, even though the overall rating did not visibly move.
  • Written reviews are harsher than ratings. Every version averaged between 3.07 and 3.83 while the overall US rating stayed at 4.14. People who take the time to write are more often unhappy. Compare reviews with reviews and ratings with ratings; never judge a release by setting its review average against the overall rating.
  • Small groups swing. The newest version had only 14 reviews when we ran this. Wait for 30 or more before drawing conclusions.

The feed is capped at 500 reviews per storefront. For a very popular app that is a couple of months; for a small app it can be years. Run the script weekly and keep the output, and the cap stops mattering.

For your own app: the App Store Connect API

If it is your app, the App Store Connect API gives you the complete record of written reviews, not just the latest 500. The customer reviews endpoint returns each review's rating, created date and territory, and a separate endpoint lists the reviews of one App Store version. Page through them once, store them, and you have a review-based rating history back to the app's first review. Star-only ratings are still only available as the summary numbers, so keep Method 1 running alongside.

How to read an App Store rating history

A chart of the rating over time is easy to misread. Before you act on a change, check these:

  1. Which storefront? Ratings are per country or region. A drop in Germany is invisible in a US-only chart. Our guide to the App Store download count shows how spread out ratings are across storefronts for a large app.
  2. Did the count jump too? A new rating prompt can multiply the number of ratings overnight and change who leaves them, so a moving average right after a new prompt says more about the prompt than about the app.
  3. Was there a reset? A count that collapses means a new baseline. Compare only from the reset onward.
  4. Is it the new ratings or edits? A lower average with no new ratings means people edited their ratings, often after an update removed something they liked.
  5. Which version? Line the change up with the version history, then read the reviews for that version. Our guide to reading review and rating trends covers how to group complaints by theme.

Google Play is the opposite case: Play Console has ratings charts over time and monthly CSV files with daily and total averages, which our guide to the Google Play rating calculation walks through. On the App Store you have to keep the history yourself.

Get an App Store rating history without running scripts

If you would rather not maintain a collector, Extenify records the rating, rating count, reviews and version of App Store and Google Play apps every day, yours or a competitor's, and plots rating and rank trends with version markers on the same timeline, next to your Chrome, Edge and Firefox extensions. It sends app store rating alerts for rating drops and fresh one-star reviews to email, Slack, Discord, Telegram or Microsoft Teams, so a bad week reaches you while it is still a week. If you are about to ship, our guide to App Store phased release shows how to use the seven-day rollout to catch a bad version early, and z-score anomaly detection explains how to decide which changes in a daily series are worth an alert. Every plan starts with a free trial; see Extenify pricing.

Frequently asked questions

Can I see an app's rating history on the App Store?

No. The App Store shows only the current rating and rating count for each country or region. To see how a rating changed over time, record it yourself every day, or use a tracker that has been recording it.

Does App Store Connect show ratings over time?

No. App Store Connect shows the current overview rating and lets you filter reviews by country or region, version and star rating. It has no chart or export of the rating over time. Google Play Console does offer one for Android apps.

Why did my App Store rating count go down?

Small drops between two reads are usually caching: two requests minutes apart can return different counts. A large drop usually means the rating was reset with a new version. Ratings can also disappear when users edit or replace them.

Do App Store ratings reset with every new version?

No. Since iOS 11, the overview rating includes all ratings after September 19, 2017, across versions. It only resets when the developer chooses to reset it when releasing a new version.

How do I see App Store ratings by country?

Call the iTunes lookup endpoint with a country parameter, for example country=gb, and read averageUserRating and userRatingCount. In App Store Connect, choose the country or region from the menu on the ratings and reviews page.

How can I see the rating of a specific app version?

The public summary does not split by version. Group written reviews by their version, from the reviews feed or the App Store Connect API, or recover the average of new ratings between two snapshots taken while that version was live.

Summary

App Store rating history does not exist until you record it. Take a daily snapshot of the rating and count in each storefront at full precision, recover the average of new ratings from weekly differences, and group written reviews by version and week to see which release moved the stars. Watch for cache noise, resets and edits, compare reviews with reviews, and start recording before the week you need the answer.

Image credits

Put every store in one dashboard tonight.

Sign in with Google, paste one store link, and your unified view is live in under a minute. Then 7 days of Pro free, no credit card required, and you never touch your app's code.

Start free trial