Guide App maintenance
How to update a Flutter app for Google Play’s target API requirement
What the 2026 rule says, what happens if you miss it, and the steps to update a Flutter app, including the errors you’ll likely hit.
Short answer
Since 31 August 2026 (1 November for apps that got an extension), Google Play only accepts new apps and updates that target Android 16 (API level 36). Apps already on the store must target at least Android 15 (API 35), or new users on newer Android versions can’t install them. For a Flutter app, the fix is to upgrade Flutter, the Android Gradle Plugin and Gradle, update or replace old plugins, handle the Android 15 and 16 behaviour changes (edge-to-edge, predictive back, large screens), check 16 KB memory page support, then test and release.
Every year Google Play raises the Android version that apps must target. Miss it and you can’t publish updates, and older apps quietly disappear for new users on newer phones. People who already have the app keep it, so the problem is easy to miss until an urgent fix gets rejected.
Here is what the 2026 rule says, how to check your app, and the steps to update a Flutter app, including the build errors you’ll most likely hit.
What Google Play requires
The deadline moves up one Android version every August.
| Deadline | New apps and updates must target | Existing apps need, to stay visible to new users |
|---|---|---|
| 31 Aug 2024 | Android 14 (API 34) | Android 13 (API 33) |
| 31 Aug 2025 | Android 15 (API 35) | Android 14 (API 34) |
| 31 Aug 2026 | Android 16 (API 36) | Android 15 (API 35) |
Wear OS and Android Automotive apps must target API 35, and Android TV and Android XR apps API 34. Permanently private apps, restricted to your own organisation for internal use, are exempt.
If the yearly pattern holds, expect Android 17 (API 37) to be required for updates from August 2027.
What happens if you miss it
- No more updates. Play Console rejects new releases that target an older API level, including urgent bug fixes.
- Hidden from new users. If your app targets API 34 or lower, new users can only install it on devices running that Android version or older, which rules out most new phones.
- Existing users keep it. People who installed it before can still find, reinstall and use it, which is why the problem is easy to miss.
- Extensions have ended. Google allowed extensions to 1 November 2026 on request. That date has passed, so an app that still targets API 35 or lower can’t ship updates until it is upgraded.
How to check your app
- Play Console. Check your Inbox, where Google sends target API warnings and deadlines. Play Console also shows an error if you upload a release that targets too low an API level.
- Your Flutter project. Look for targetSdk in android/app/build.gradle or build.gradle.kts. If it says flutter.targetSdkVersion, the value comes from your Flutter version.
- Your Flutter version. Run flutter --version. Recent stable releases default to API 36; older ones need upgrading or an explicit targetSdk.
How to update a Flutter app, step by step
- Upgrade Flutter. Move to the current stable release with flutter upgrade, then run flutter doctor. This updates the engine, the default target SDK and Flutter’s Gradle plugin.
- Upgrade the Android build tools. API 36 needs Android Gradle Plugin 8.9.1 or newer, which needs Gradle 8.11.1 or newer and JDK 17. The safest versions are the ones a new project created with your Flutter version uses. Flutter prints a warning when your Gradle, Android Gradle Plugin or Kotlin versions are too old.
- Migrate old Gradle files. Projects created with older Flutter versions often still apply Flutter’s Gradle plugin the old way. Flutter’s migration guide moves them to the plugins block.
- Set the SDK levels. Set compileSdk and targetSdk to 36. Keep minSdk as low as your plugins allow.
- Update packages. Run flutter pub outdated, then upgrade major versions one plugin at a time. Replace discontinued plugins: abandoned ones are the usual cause of failed builds.
- Fix permissions. Android 13 needs a runtime prompt for notifications, Android 14 needs a declared type for every foreground service, and Google Play only allows broad photo and video access when it is core to the app, so most apps should use the system photo picker.
- Handle the behaviour changes. Edge-to-edge, predictive back and large screens, covered in the next section.
- Check 16 KB page size support. Every Flutter app ships native libraries, and apps targeting Android 15 or newer must support 16 KB memory pages on 64-bit devices. From 1 February 2027, Google Play blocks updates that don’t. Recent Flutter versions handle the engine; plugins with their own native libraries may need updating. Android Studio’s APK Analyzer flags any library that isn’t aligned.
- Test and release. Run the app on Android 15 and 16 emulators and a real device, read the pre-launch report, then release through internal testing and a staged rollout.
Android 15 and 16 changes that break layouts
- Edge-to-edge. Apps targeting API 35 draw behind the status and navigation bars by default, and apps targeting API 36 can’t opt out on Android 16. Use SafeArea or MediaQuery padding so buttons don’t end up under the system bars.
- Predictive back. On Android 16, apps targeting API 36 get the system back animations by default, and Android stops calling the old onBackPressed method. Replace WillPopScope with PopScope and test every screen that intercepts back.
- Large screens. On tablets and foldables (smallest width 600dp or more), Android 16 ignores orientation locks, resizability and aspect-ratio limits for apps targeting API 36, including Flutter’s SystemChrome.setPreferredOrientations. A portrait-only app will rotate there. Games are exempt, and a temporary opt-out exists, but it stops working when you target API 37, so make your layouts work in landscape.
Errors you’ll likely hit
- Namespace not specified. An old plugin predates Android Gradle Plugin 8. Update the plugin, or replace it if it is abandoned.
- Java or Gradle version mismatch. Errors such as “Unsupported class file major version” mean Gradle, the Android Gradle Plugin and the JDK don’t match. Align them using the compatibility table in the Android docs.
- Kotlin version errors. Raise the Kotlin Gradle plugin version in your Gradle settings.
- Manifest merger failed. Often a missing android:exported attribute. Since Android 12, every activity, service or receiver with an intent filter must declare it.
- minSdk conflicts. A newer plugin needs a higher minSdk. Check how many of your users are on older Android versions, then raise it.
Make next year’s upgrade easier
- Upgrade a little every quarter. Small Flutter and plugin bumps cost far less than a two-year jump under deadline pressure.
- Keep plugins few and well maintained. Every plugin is something that can block an upgrade.
- Use Clean Architecture. With plugins behind data-layer interfaces, replacing a discontinued plugin touches one data source, not your screens, and your BLoCs never notice.
- Build releases automatically. A CI build on every change catches toolchain breakage months before the deadline.
FAQ
What target API level does Google Play require in 2026?
Since 31 August 2026, new apps and app updates must target Android 16 (API level 36); apps that got an extension had until 1 November 2026. Existing apps must target at least Android 15 (API level 35) to stay available to new users on newer Android versions. Wear OS and Automotive apps need API 35, and Android TV and XR apps API 34.
What happens if my app doesn’t meet the target API level?
You can’t publish updates until it does. If it targets API 34 or lower, new users can only install it on devices running that Android version or older. People who installed it before can still find, reinstall and use it.
How do I change the target SDK in a Flutter app?
Set targetSdk and compileSdk to 36 in android/app/build.gradle or build.gradle.kts, or upgrade to a recent Flutter version, whose flutter.targetSdkVersion default is 36. You will usually also need Android Gradle Plugin 8.9.1 or newer, a matching Gradle version and JDK 17; the versions a new Flutter project uses are a safe reference.
Why does my Flutter app fail to build after raising the target SDK?
Usually an outdated plugin (“Namespace not specified”), mismatched Gradle, Android Gradle Plugin and JDK versions, or an old Kotlin version. Update Flutter and the build tools first, then the plugins one by one.
Does my Flutter app need 16 KB page size support?
Yes. Flutter apps include native libraries, and Google Play requires apps targeting Android 15 or newer to support 16 KB memory pages on 64-bit devices. From 1 February 2027, updates without it can’t be released. Recent Flutter versions cover the engine; check plugins with native code using Android Studio’s APK Analyzer.
Does Apple have a similar rule?
Yes. Since 28 April 2026, apps uploaded to App Store Connect must be built with Xcode 26 or later using the iOS 26 SDK, and since 9 September 2026 iOS apps must target iOS 13 or later. Plan both upgrades together.
How long does it take to update an old Flutter app?
It depends on how far behind the app is. An app upgraded last year usually needs version bumps and a test pass. An app several years behind often needs new Gradle files and replacement plugins, so start well before the deadline.