Android targetSdkVersion Explained: Why It Decides If an App Installs, Updates, and Behaves (2026)
App worked fine on your old phone but crashes or won't install on Android 15? The answer is often targetSdkVersion. Learn what it means, how it differs from min/compile SDK, why a low target causes install failures, and how to check any APK.
Ever had an app work perfectly on an older phone, then crash, drop notifications, get denied permissions, or show “this app isn’t supported on this device” after moving to a newer one or updating to Android 15? Nine times out of ten, the culprit is targetSdkVersion— a single number buried in AndroidManifest.xml that decides which Android version’s rules the app runs under.
Bottom line: targetSdkVersion tells the system “which version’s contract this app was written against.” Higher means access to newer behaviors — but when it falls below what Google Play or the OS requires, you hit install, listing, and behavior limits.
Core idea: min decides “can it install,” target decides “how it runs,” compile decides “which APIs you can write with.”
Three SDK versions — don’t mix them up
| Name | Meaning | Who cares |
|---|---|---|
| minSdkVersion | Lowest Android version the app supports | Whether a user’s device is new enough |
| targetSdkVersion | The version the app is written for (runtime uses that version’s behavior) | The system, the store, behavior consistency |
| compileSdkVersion | Which Android SDK you compile against | Developers, access to new APIs |
What targetSdkVersion actually changes
It’s the most overlooked yet most impactful, because it triggers system behavior changes:
- Android 6.0 (target 23)— runtime permissions begin. target ≥ 23 shows permission prompts; target < 23 gets auto-granted.
- Android 10 (target 29) — background location restricted, Scoped Storage enforced.
- Android 13 (target 33)— the POST_NOTIFICATIONS permission becomes a runtime permission. Apps with target ≥ 33 that don’t request it won’t show notifications at all.
- Android 14 (target 34) — foreground service types must be declared, or the app crashes outright.
The same code, with target 33 vs target 31, can behave completely differently on Android 14.
Why a low target causes install / update failures
- Google Play listing rules— new apps and updates must meet a higher targetSdkVersion or they’re rejected.
- Sideloading limits— since Android 14, installing an app with targetSdkVersion below 23 is blocked by the system (“This app was built for an older version of Android”).
- Downgrade installs — going from a high-target build to a low-target one can trigger signature or version conflicts.
So “it won’t install” isn’t always a signature problem — sometimes the APK’s targetSdkVersion is simply too low for the new OS.
How to check an APK’s targetSdkVersion
# Option 1: aapt (Android SDK Build-Tools)
aapt dump badging app.apk | grep sdkVersion
# Output looks like:
# sdkVersion:'24'
# targetSdkVersion:'33'
# Option 2: apkanalyzer
apkanalyzer manifest target-sdk app.apkNo computer? Use APK Info or SAI on your phone — select the APK and it shows min/target/compile SDK at a glance.
Quick FAQ
Higher target is always better, right?Not necessarily. A higher target means more new rules to follow; if the app hasn’t adapted, you may get missing notifications or a killed background process. The ideal is “target tracks the mainstream version andthe app has adapted.”
Why does an app work on an old phone but act up on a new one? Likely a low target: newer systems apply stronger compatibility restrictions to low-target apps.
My downloaded APK has a target so low the system blocks it. Now what?There’s no clean fix. Find a newer build of that app, or resort to custom ROMs/tools that lift the restriction (not recommended). The safe path is waiting for the developer to update.
Advice by role
- Regular users:before installing, check targetSdkVersion with APK Info; builds too low (especially < 23) likely won’t install on new phones; if notifications stop appearing, suspect a low target and the resulting permission behavior difference.
- Developers:after every major OS release, bump target and complete the adaptation; track Google Play’s yearly target threshold increases; manage min / target / compile separately.
Action checklist
- Look up the target APK’s targetSdkVersion via aapt dump badging or APK Info.
- Compare against the device’s Android version to judge behavior/install risk.
- When install fails, distinguish signature issues from target too low.
- Developers: make target upgrades a routine task with every OS update.
Understand targetSdkVersion and you hold a key to Android compatibility problems. Many “mystery crashes” and install failures are solved the moment you look at this one number.
Need to extract APKs from Google Play with full version metadata for analysis? Try gptoapk.com — extracted packages come with SDK-related metadata attached.