Versions and compatibility

When you install an Android app outside the Play Store, three technical details decide whether the install succeeds and whether the file is what its creator actually shipped: the version code, the Android release requirement, and the app’s CPU architecture. Understanding these three values lets you read an APK’s metadata the way an engineer does, and it gives you a decision rule for every install prompt you will ever see.

the material below gives you that method. It is a practical guide to reading the version and compatibility details of an APK or app bundle, checking them against your device, and deciding whether to proceed.

APK

An APK (Android Package Kit) is the compiled package of an app. It contains the code, resources, and the manifest that declares permissions and components. The file is a ZIP archive, but you should never treat it as a ZIP file for casual inspection; its internal structure is defined by the Android platform and the signing scheme.

For installation, what matters is not the file extension but the signature and the target SDK level. The Android system checks the APK’s signature during install. If the signature does not match the existing app’s signature, the install fails with “App not installed” (Android Developers, “Sign your app”, 2023). If the APK targets an API level newer than the device’s OS, the system will refuse to install it; if it targets an API level older than the minimum supported by the OS, installation may also fail or the app may behave incorrectly (Android Developers, “Version your app”, 2023).

Version codes are integers that increase with each release. The versionCode must be higher than the currently installed variant for an update to be accepted. The versionName is what users see. A team that releases a new build without incrementing the version code will cause “App not installed” errors on devices that already have the previous build, because the system sees the same or lower version code.

Android releases and API levels

Android releases are tied to API levels. Android 13 is API 33, Android 14 is API 34, and Android 15 is API 35, per Android Developers documentation. When you read “targetSdkVersion” in an app’s metadata, it tells you which API level the app was built against. An app that targets an older API level may still install on a newer OS, but it may miss behavior changes and security patches. Google Play requires new apps and updates to target a recent API level; as of 2024, the requirement was API 34 for new apps and updates (Android Developers, 2024).

To check the target SDK of an already-installed app, you cannot see it in the normal app info screen. You can inspect the APK with aapt dump badging from Android SDK Build Tools or use a tool like AppBrain. On a device, Settings > Apps > App info shows the release number, not the target SDK.

How Android release numbers control compatibility

Android releases are identified by API level, not marketing names. An app that says “Android 8.0+” means the app’s minSdkVersion is 26. The system refuses to install an APK whose minSdkVersion is higher than the device’s API level. The Play Store hides incompatible apps; a sideloaded APK will fail with “There was a problem parsing the package” or “App not installed”.

To find your Android release: open Settings > About phone and look for “Android version” or “Build number” (exact path varies by device maker). Google’s Android Developers documentation lists the API level for each Android release, and the Android Studio IDE shows the target and minimum SDK of an APK when you open it with the APK Analyzer (Android Developers, 2024).

The two SDK numbers that matter

Two numbers matter in practice: the minimum SDK (the oldest Android release the app supports) and the target SDK (the API level the app was built against). Newer Android releases restrict certain permissions and background behavior, so an app that targets an old API level may behave differently or fail on a current device. If an app refuses to install on your phone, check whether the target SDK is too new for your OS release, or too old for the current Android security policy.

Android

Android is the operating system. The release on your device determines which app formats install, which APIs are available, and how strict the OS is about permissions and background activity. Google publishes the current distribution and API levels on the Android Developers dashboard; the exact numbers change quarterly, so check the current dashboard rather than relying on a screenshot from an article. As of the 2024 platform releases, Android 14 (API level 34) is the stable baseline for new devices, and Android 15 (API level 35) is the next release under development, per Android Developers (2024).

The number that matters for compatibility is not the marketing name (“Android 14”) but the API level. An app declares minSdkVersion (the lowest API it supports), targetSdkVersion (the API it was tested against), and compileSdkVersion (the API used to build it). When you install an APK, Android checks whether your device’s API level is at or above the app’s minimum. If the device is too old, the system refuses to install it.

A decision checklist before you install

1. Check the Android release on your device before installing an app that is not from your default store. Go to Settings → About phone → Android version. Note the API level that corresponds to it (Android 8.0 = 26, 9 = 28, 10 = 29, 11 = 30, 12 = 31, 13 = 33, 14 = 34).
2. Read the app’s listed “Requires Android” field on the store page or the publisher’s site. If the app requires a newer Android release than your device, the install will fail or the app may not function.
3. If you are installing an APK manually, check the target SDK level in the app’s manifest before installing. The Android Developers documentation states that apps targeting an older API level may lack security fixes and may not run on newer Android releases (Android Developers, “Target and runtime requirements”, 2024).

The one fact a competing guide won’t give you

An APK’s versionCode is the single integer that decides whether Android accepts the file as an update. If it is not strictly higher than the code of the build already on the device, the system rejects the install silently or with a generic error, regardless of what the versionName string says.