• Google Play
  • Releases
  • Store Data
  • Competitors
  • Mobile apps

Google Play version history: where to find it and track it

Google Play version history is not public. Find your own app's release history in Play Console, check any app's current version, and record updates daily.

Author
Extenify Team
Published
Reading time
12 min read
A tall red sandstone cliff with many horizontal rock layers rising against a blue sky, with a single pine tree at its base

Google Play version history is one of the most searched and least satisfying things about the Play Store. Users want to know what changed in the update that broke their favorite app, developers want to see how often a competitor ships, and both discover the same thing: a Google Play listing shows the latest update and nothing before it. A Samsung Community member put it plainly when asking for the feature: the store shows "only the previous update details, but I want to see the full history as a list".

This guide shows what Google Play does show, where the complete history of your own app lives in Play Console and its reports, and how to build a version history for any app, including competitors, with a short Node.js script that records the listing every day.

Key takeaways

  • Google Play has no public version history. A listing shows the "Updated on" date, the current "What's new" text and, for some apps, a single version number.
  • Many large apps show "Varies with device" instead of a version. Of four popular apps we checked in late October 2026, Slack and Firefox showed a version; Spotify and Duolingo did not.
  • For your own app, Play Console keeps the full record: release notes history and rollout history on each release's details page, plus monthly CSV reports broken down by app version.
  • The Play Developer API is not a history API: its tracks endpoint returns only "active releases", and its reviews endpoint covers only the last week.
  • For any other app, the only complete Google Play version history is one you record yourself, once a day, starting now.

Does Google Play have a version history?

No. The App Store has a Version History section that lists recent releases with their notes (only the last 25, as our App Store version history guide explains). Google Play has no equivalent. What a listing shows:

  • "Updated on": the date of the most recent update, under "About this app".
  • "What's new": the release notes of the current version only. Each update replaces the previous text.
  • Version: in the "About this app" details, either a single version name or "Varies with device".
  • Released on: the date the app was first published, also in the details.

We read four popular listings in late October 2026 to see what each one exposed:

App Updated on Version shown Requires Android
Slack Oct 26, 2026 26.10.30.0 10
Firefox Oct 22, 2026 159.0 8.0
Spotify Oct 23, 2026 Varies with device Not shown
Duolingo Oct 26, 2026 Varies with device Not shown

Two things stand out. Half of these apps publish no single version number at all. And the version name does not have to look like a date or match the update date: Slack's version 26.10.30.0 was live on a listing updated on October 26. Treat the version as an opaque label and the "Updated on" date as the release signal.

Why some apps say "Varies with device"

"Varies with device" means the listing has no single version to show for every user. Google does not document the exact rule, but in practice it appears on large apps that serve more than one build at a time, for example different builds for phones, tablets, watches or TVs, or a new version still in a staged rollout next to the old one. For those apps, the "Updated on" date and the "What's new" text are the only public release signals.

How to see which version is on your phone

If you are a user trying to find out what changed, start with the version you have:

  1. Open the app's listing in the Play Store app and tap About this app. The version (or "Varies with device"), the update date and the "What's new" text are listed there.
  2. On the phone itself, open Settings > Apps, choose the app and look for the version near the bottom of the app info screen. The exact menu names differ by phone maker.
  3. For the full history of a specific app, check the developer's website, blog or changelog. Many open source apps also publish release notes on GitHub.

Google Play only offers the current release for your device. Sites that offer older APKs are not affiliated with Google, and installing apps from them carries real security risk.

Version history for your own app in Play Console

For apps you publish, Play Console keeps everything. There are four places to look.

Release details. In Play Console, go to Test and release > Releases overview and open a release. According to Google's release help page, the release details page lists "Release notes: A list of previous release notes" and a "Rollout history: Timeline displaying timestamps when releases were halted, resumed, or served to new user percentages". It also compares installs, updates, performance issues and ratings with previous releases.

Latest releases and bundles. The Latest releases and bundles page (previously App bundle explorer) has a version filter that lets you pick any version you uploaded and inspect the devices it supports, its downloadable APKs and its delivery modules.

Monthly reports. Play Console's downloadable reports live in a private Cloud Storage bucket whose name starts with pubsite_prod_rev. Two are useful for version history:

  • stats/installs/installs_[package]_YYYYMM_app_version.csv breaks installs down by version code day by day, so you can see when each version started reaching users and how fast it replaced the previous one.
  • reviews/reviews_[package]_YYYYMM.csv includes "App Version Code" and "App Version Name" columns, so you can read reviews per version.

Google notes that data is posted within 3 to 7 days, so these files are for analysis, not alerts. You can copy them with gsutil cp -r or a service account with read-only storage access.

What the Play Developer API does not give you. The tracks resource of the Google Play Developer API "represents all active releases in the track", with their version codes, release notes, status and rollout fraction, but not the releases that came before. The bundles list returns your uploaded app bundles without release dates. And the reviews endpoint, which does include appVersionName, returns "only the reviews that users have created or modified within the last week". If you want a release log you can query, snapshot the tracks endpoint after every release and keep the rows yourself. For crash and ANR rates per release, see our guide to the Google Play Developer Reporting API, and for installs and users, our explainer on Google Play Console statistics.

Build a Google Play version history for any app

For competitors and any app you do not own, there is no backfill button. The workable approach is the same one that works for Chrome extension version history: read the listing once a day and store a new row whenever the version, the update date or the release notes change.

This script reads those fields from a public listing:

// play-version.mjs: read the current version, update date and "What's new" text from a Google Play listing.
// Node.js 18+ (global fetch). Not an official API: keep volume low and cache results.
const UPDATED = /Updated on<\/div><div[^>]*>([^<]+)</;
// Either [[["1.2.3"]],[[[sdk]],[[[minSdk,"8.0"]]]]]] or, for "Varies with device", [[null,[]],[[[sdk]],[null,[]]]],
// followed by the "What's new" text.
const RELEASE =
  /(?:\[\[\["([^"]+)"\]\],\[\[\[\d+\]\],\[\[\[\d+,"([^"]+)"\]\]\]\]\]|\[\[null,\[\]\],\[\[\[\d+\]\],\[null,\[\]\]\]\]),null,null,null,\[null,\[null,"((?:[^"\\]|\\.)*)"/;

export async function getPlayVersion(packageName) {
  const url = `https://play.google.com/store/apps/details?id=${encodeURIComponent(packageName)}&hl=en_US&gl=US`;
  const res = await fetch(url, { headers: { 'user-agent': 'Mozilla/5.0 (compatible; store-stats-check)' } });
  if (res.status === 404) return null; // not on Google Play, or not in this country
  if (!res.ok) throw new Error(`Google Play returned ${res.status} for ${packageName}`);
  const html = await res.text();
  const updated = html.match(UPDATED)?.[1];
  const release = html.match(RELEASE);
  return {
    packageName,
    updatedOn: updated ? new Date(`${updated} UTC`).toISOString().slice(0, 10) : null,
    version: release ? (release[1] ?? 'Varies with device') : null,
    requiresAndroid: release?.[2] ?? null,
    whatsNew: release ? JSON.parse(`"${release[3]}"`).replaceAll('<br>', '\n').trim() : null,
    checkedAt: new Date().toISOString(),
  };
}

if (import.meta.url === `file://${process.argv[1]}`) {
  for (const id of process.argv.slice(2)) console.log(await getPlayVersion(id));
}

Run it with package names, the id= part of a listing URL:

node play-version.mjs com.Slack org.mozilla.firefox com.spotify.music

For Firefox it returned version: '159.0', requiresAndroid: '8.0', updatedOn: '2026-10-22' and the release notes, which began "Significantly reduced how often tabs unexpectedly reload on Xiaomi and Redmi devices." For Spotify it returned version: 'Varies with device' and its generic release notes. For a package that does not exist it returned null. The patterns match undocumented page data, so when a listing does not match, the function returns null fields instead of guessing; check that case in your monitoring, because it is also how you will notice that Google changed the page.

Record a row only when something changes

Call the reader once a day and append a row when anything differs from the last one you stored:

// record-play-versions.mjs: run once a day; appends a row to history.json whenever a listing changes.
import { readFile, writeFile } from 'node:fs/promises';
import { getPlayVersion } from './play-version.mjs';

const FILE = 'history.json';
const APPS = process.argv.slice(2);
const history = JSON.parse(await readFile(FILE, 'utf8').catch(() => '[]'));

for (const id of APPS) {
  const now = await getPlayVersion(id);
  if (!now) continue;
  const last = history.findLast((row) => row.packageName === id);
  const changed =
    !last || last.version !== now.version || last.updatedOn !== now.updatedOn || last.whatsNew !== now.whatsNew;
  if (changed) {
    history.push(now);
    console.log(`${id}: ${last ? `${last.version} (${last.updatedOn})` : 'first record'} -> ${now.version} (${now.updatedOn})`);
  }
  await new Promise((r) => setTimeout(r, 2000)); // one listing every 2 seconds
}
await writeFile(FILE, JSON.stringify(history, null, 2));

The first run prints com.Slack: first record -> 26.10.30.0 (2026-10-26); a second run the same day prints nothing, because nothing changed. Comparing the update date and the notes as well as the version is what makes this work for "Varies with device" apps, where the version field never changes.

Make it production ready

  • Use a database, not a JSON file, once you track more than a few apps. One row per app per change, keyed on package name and check time, is enough. Our PostgreSQL time series guide covers this table shape.
  • Schedule it exactly once a day and catch up after downtime, as described in our Node.js cron job guide.
  • Diff the notes, not only the version. Our JSON diff in Node.js guide shows how to turn two snapshots into a readable change list for an alert.
  • Read each listing in the countries you care about. Releases can be limited by country, so the gl parameter can change what you see.
  • Be a polite client. One request per app per day, a clear user agent, caching, and backing off on HTTP 429 keep the job small and respectful.

Fill in some of the past from reviews

You cannot download a competitor's past releases, but you can recover some of them. Each Google Play review records the app version the reviewer had installed. On Slack's listing, the reviews embedded in the page alone carried versions from 20.07.20.0 to 26.x. Open source tools such as google-play-scraper page through recent reviews and return a version field with each one, though not every review has it. The earliest review that mentions a version gives you a "first seen" date for that version, which is an upper bound on its release date. It will have gaps for versions few people reviewed, so label it as an estimate.

What to do with a Google Play version history

A version history is only useful when you read it next to other numbers:

  • Explain rating changes. When your rating or a competitor's drops, the first question is "what shipped?". Line versions up with ratings and reviews, as in our checklist for the week after an extension release, which applies just as well to Android apps.
  • Measure competitor cadence. How often a rival ships is one of the strongest public signals of momentum. Our app competitor analysis guide compares release cadence across seven apps and shows how to put it in a weekly scorecard.
  • Spot quiet changes. An "Updated on" date that changes while the version stays "Varies with device" still tells you a new build went out. Watch the reviews over the following days.
  • Catch your own rollouts. For your app, compare what you released in Play Console with what the public listing shows, so you know when an update actually reached the store page.

Track Google Play versions without maintaining scripts

If you would rather not run and fix a scraper, Extenify does this for you. It is an app version tracker that records public store listing data for Google Play and App Store apps, plus Chrome, Edge and Firefox extensions, every day. It keeps every version change with its date, puts version markers on the installs and rating charts, and sends alerts to email, Slack, Telegram, Discord or Teams when an app you follow ships an update. It works the same for competitors as for your own apps. Every plan starts with a 7-day free trial with no credit card required, and the pricing page shows how much history each plan keeps. The same daily record also powers the Google Play download count trends for each app.

Frequently asked questions

Does Google Play show an app's version history?

No. A Google Play listing shows the date of the last update, the current "What's new" text and, for some apps, the current version. Earlier releases are not listed. Developers can see their own release history in Play Console.

How can I see what changed in the latest update of an app?

Open the listing and read the "What's new" section, which holds the notes for the current release only. For older changes, check the developer's website or changelog, because Google Play replaces the text with every update.

Why does Google Play say "Varies with device" for the version?

It means the app does not have one version for every user, which is common for large apps that serve different builds to different devices or roll a new version out gradually. The "Updated on" date still tells you when the latest update went live.

How do I find which version of an app I have installed?

Open the app's listing in the Play Store and tap "About this app", or go to Settings, then Apps, choose the app and look for the version on its app info screen. Menu names vary by phone maker.

Can I download an older version of an app from Google Play?

No. Google Play only serves the current release for your device. Older APKs on third-party sites are not from Google and can be modified, so avoid installing them unless the developer publishes them directly.

How do I see my own app's release history in Play Console?

Go to Test and release, then Releases overview, and open a release to see its release notes history and rollout history. The Latest releases and bundles page lets you inspect every version you uploaded, and the monthly installs report broken down by app version shows when each version reached users.

Summary

Google Play version history does not exist as a public page. A listing shows the latest update date, the current "What's new" text and sometimes a single version; large apps often show "Varies with device" instead. For your own app, Play Console has the full record in each release's details, the Latest releases and bundles page and the monthly reports by app version, while the Developer API only covers active releases and last week's reviews. For every other app, record the listing once a day, store a row whenever the version, date or notes change, fill gaps from review versions where you can, and read the result next to ratings and reviews.

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