# Target API level 36 on Google Play: the November 1, 2026 extension and the Expo, Flutter and React Native fix

> Since Aug 31, 2026, Google Play requires target API level 36. How the Nov 1 extension works and how to move Expo, Flutter and React Native apps to API 36.

Canonical: https://makeyourapp.live/blog/target-api-level-36-google-play-extension-fix
Last updated: 2026-10-30

By [Yagyesh Bobde](https://www.bobdeyagyesh.in) · App updates · Published Oct 30, 2026 · 7 min read

Missed the August 31 cutoff? Find out what the November 1, 2026 extension still gets you, then move Expo, Flutter or React Native to API 36 without breaking back navigation or layouts.

## Short answer

The target API level 36 rule says that since August 31, 2026, every new app and app update sent to Google Play must target Android 16 (API 36). Developers whose apps got a policy warning could request an extension to November 1, 2026 from the Policy status page. Once that extension ends, Play blocks updates until you upload a build with targetSdk 36. Expo SDK 54+, Flutter 3.38+ and React Native 0.81+ target API 36 by default.

## Key takeaways

- Since August 31, 2026, new apps and app updates on Google Play must target Android 16 (API level 36). Wear OS and Automotive need API 35, and Android TV and XR need API 34.
- The extension only runs to November 1, 2026. Its form link reaches non-compliant apps through Play Console Notifications and the warning's page on Policy status.
- If an existing phone app targets API 35 or higher, it stays available to new users. Missing the deadline stops your updates, not your current listing.
- Expo SDK 54 (React Native 0.81) and Flutter 3.38 target API 36 by default. Upgrading usually works better than hand-editing the number.
- When an app targets API 36, Android no longer calls onBackPressed and ignores orientation locks on screens 600dp wide or wider. Test back navigation and tablet layouts before you upload.

The **target API level 36** requirement on Google Play means a release built for anything below Android 16 can't ship. As of October 2026, Play rejects every new app and every update that targets a lower level, often with the message `Target SDK of artifact is too low`. Apps that got a policy warning could ask for more time, but the extension stops on November 1, 2026. This guide covers what the extension still gets you, how to move Expo, Flutter and React Native to API 36, and what tends to break once you do.

## What does the target API level 36 requirement actually block?

It blocks submissions. Since August 31, 2026, you can't upload a new phone app or an update unless it targets API 36. Apps already live that target API 35 or higher remain fully available, including to new users.

According to Google's [target API level requirements](https://support.google.com/googleplay/android-developer/answer/11926878), "New apps and app updates must target Android 16 (API level 36) or higher to be submitted to Google Play." Requirements differ by form factor, and the only full exception is for permanently private apps meant for internal distribution in one organization.

| Form factor | New apps and updates (from Aug 31, 2026) | Existing apps stay fully available if they target |
| --- | --- | --- |
| Phone, tablet, Android Auto | API 36 | API 35 or higher |
| Wear OS | API 35 | API 34 or higher |
| Android Automotive OS | API 35 | API 32 or higher |
| Android TV | API 34 | API 33 or higher |
| Android XR | API 34 | API 34 or higher |

An existing app below those levels "will only be available on devices running Android OS that are the same or lower than your apps' target API level." People who already installed it keep using it as before. Someone on a newer phone, though, is told the app "was made for an older version of Android."

## Can you still get the extension before November 1, 2026?

Only if Play sent your app a policy warning and the request form still shows on it. Even then, the extension lasts until November 1, 2026 at the latest, so it's a few extra days for a fix that's almost done, not a new plan.

Google says it sends "an extension request form link via their Notifications" to affected apps, and that the form is "available through the details page of the warning or issue on the Policy status page." Google shows no form to apps that already comply.

1. Open Play Console and select the app.
2. Look in the Inbox or Notifications for the target API level message. If it's there, follow its link.
3. If not, go to Policy status, open the target API level warning or issue, and look for the extension request form on its details page.
4. Fill in the form for every affected app. Each app has its own warning.
5. Whether the extension is granted or not, plan to upload an API 36 build before November 1, 2026. After that date, updates need API 36.

> **Missed both dates?:** An existing phone app that targets API 35 doesn't disappear. Your listing and current users are safe, but you can't ship any update, including a crash fix, until the build targets API 36. Get the bump done now, while nothing urgent is waiting on it.

## How do you bump Expo, Flutter and React Native to API 36?

The cleanest route is upgrading to a framework version that already targets API 36: Expo SDK 54, React Native 0.81 or Flutter 3.38. If you can't upgrade yet, you can raise the number by hand, but then you also have to deal with the Android 16 behavior changes yourself.

| Stack | Targets API 36 by default from | Where the number lives | Manual route if you can't upgrade |
| --- | --- | --- | --- |
| Expo (managed / CNG) | SDK 54 (React Native 0.81) | Generated by prebuild; override with expo-build-properties | `targetSdkVersion: 36` and `compileSdkVersion: 36` in the expo-build-properties plugin |
| React Native (bare) | 0.81 | `android/build.gradle` | Set compileSdk and targetSdk to 36, then opt out of predictive back in the manifest |
| Flutter | 3.38 (`flutter.targetSdkVersion` = 36) | `android/app/build.gradle(.kts)` | Replace a hardcoded 35 with 36 or with `flutter.targetSdkVersion` |

**Expo.** The [SDK 54 changelog](https://expo.dev/changelog/sdk-54) says SDK 54 and React Native 0.81 are "now targeting Android 16." Upgrade with `npx expo install expo@^54.0.0 --fix`, run `npx expo-doctor@latest`, and if you use Continuous Native Generation, "Delete the android and ios directories if you generated them for a previous SDK version." On SDK 53 you can try setting `targetSdkVersion: 36` through the `expo-build-properties` plugin, but React Native 0.79 still handles back through `onBackPressed`, so read the next section before shipping it.

**Flutter.** The [Flutter 3.38 release notes](https://flutter.dev/blog/whats-new-in-flutter-3-38) list the defaults as `flutter.compileSdkVersion` (API 36) and `flutter.targetSdkVersion` (API 36), and "strongly encourage you to use the API level variables vended by the Flutter SDK in your build files." Version 3.38 also needs Java 17 at minimum. If `targetSdk = 35` is hardcoded in your app module, the Flutter upgrade won't change it, so check the file.

**Bare React Native.** Set `compileSdkVersion` and `targetSdkVersion` to 36 in `android/build.gradle`. On 0.81 and later you're mostly done. On older versions, also add `android:enableOnBackInvokedCallback="false"` to `<application>` in `AndroidManifest.xml`. Without it, the hardware back button and back gesture skip your JavaScript navigation.

## What breaks when an app starts targeting Android 16?

Back navigation and large-screen layouts break most often. With API 36 as the target, Android stops calling `onBackPressed`, won't let you opt out of edge-to-edge, and ignores orientation and resizability locks on displays at least 600dp wide.

The changes that matter most to cross-platform apps, from Google's [Android 16 behavior changes](https://developer.android.com/about/versions/16/behavior-changes-16):

- **Predictive back:** "`onBackPressed` is not called and `KeyEvent.KEYCODE_BACK` is not dispatched anymore." Setting `android:enableOnBackInvokedCallback="false"` is a temporary opt-out.
- **Edge-to-edge:** `windowOptOutEdgeToEdgeEnforcement` is "deprecated and disabled", so a header or bottom button can end up under the status bar or gesture bar.
- **Large screens:** on displays 600dp and wider, `screenOrientation`, `resizableActivity` and aspect-ratio limits are ignored, which can stretch portrait-only layouts. Games are exempt. `PROPERTY_COMPAT_ALLOW_RESTRICTED_RESIZABILITY` is a temporary opt-out that "won't apply when targeting API level 37."
- **Text:** `elegantTextHeight` is ignored, which can change line height for Arabic, Thai, Tamil and several other scripts.
- **Health sensors:** `BODY_SENSORS` is replaced by granular health permissions such as `READ_HEART_RATE`.

## What did other developers hit when they moved to API 36?

The public reports so far show two kinds of trouble: back-button behavior that changes without any error, and libraries that make the target level of the bundle Play receives differ from what the project files say.

**Audius (React Native 0.79).** In [pull request #14635](https://github.com/AudiusProject/apps/pull/14635), the Audius team says Google Play rejected both uploads of Android version 1.5.186 with `Target SDK of artifact is too low`. They moved compileSdk and targetSdk from 35 to 36, set build tools to 36.0.0, and added `android.suppressUnsupportedCompileSdk=36`, because "RN 0.79 pins AGP 8.8". They also set `enableOnBackInvokedCallback="false"`, since without it back "would bypass React Navigation." A later PR dropped the opt-out after they moved to React Native 0.81, which registers an `OnBackPressedCallback` on its own.

**A Flutter 3.35.2 app.** In [Flutter issue #174516](https://github.com/flutter/flutter/issues/174516), a developer set targetSdk 36 in Gradle and the manifest, but Play Console still reported "Your bundle targets SDK 34, but uses a Play Core library that cannot be used with that version." Removing the old `com.google.android.play:core:1.10.3` library led to R8 "Missing classes" errors. Fixing those led to "You can't rollout this release because it doesn't allow any existing users to upgrade to the newly added app bundles." The bundle was finally accepted after they added ProGuard keep rules, set minSdk explicitly, and turned off language, density and ABI splits, at the cost of a larger download.

The common lesson: changing the number in Gradle doesn't finish the job. Audius had to fix runtime behavior, and the Flutter developer had to fix a dependency that changed what Play read from the bundle. Check the built artifact and test on an Android 16 device, not only the config file.

## How do you check an API 36 build before uploading it?

Read the target level from the release bundle itself, then put the bundle on an internal or closed testing track and try back navigation, insets and a tablet layout on Android 16. A rejection or a production bug costs much more time than these checks.

Worked example: an Expo SDK 53 app that targets API 35 and needs one more update.

1. Run `npx expo install expo@^54.0.0 --fix`, then `npx expo-doctor@latest`, and fix whatever it reports.
2. If the project uses Continuous Native Generation, delete the old `android` and `ios` folders and build again. Otherwise, apply the native upgrade changes by hand.
3. Build the release AAB, for example with `eas build -p android --profile production`.
4. Confirm the target with `bundletool dump manifest --bundle app.aab --xpath /manifest/uses-sdk/@android:targetSdkVersion`. It should print `36`.
5. Upload to internal testing. On an Android 16 phone, press back on every nested screen, check that headers and bottom buttons aren't hidden under the system bars, and rotate a tablet or a resizable emulator.
6. Promote to production with release notes that mention the Android 16 fixes.

To make testing go faster, use the tester setup in our [Google Play closed testing guide](https://makeyourapp.live/blog/google-play-closed-testing-12-testers-test-plan), and borrow wording for the update text from our [release notes examples](https://makeyourapp.live/blog/app-store-release-notes-examples). If you'd rather hand the release off, our [App Store submission service](https://makeyourapp.live/services/app-store-submission) covers Play Console and App Store Connect for $599 for both stores. Developer account fees are separate.

## Frequently asked questions

### What happens if I miss the November 1, 2026 target API extension?

Your current listing stays up. A phone app that targets API 35 or higher is still available to existing and new users. Play Console will reject any new release, including urgent bug fixes, until the bundle targets Android 16 (API 36). Apps below API 35 can only be installed on devices running that Android version or older.

### Do Wear OS and Android TV apps need to target API 36?

No. As of October 2026, new Wear OS and Android Automotive OS apps and updates must target API 35, and Android TV and Android XR apps must target API 34. Only phone, tablet and Android Auto apps need API 36. The single full exception is a permanently private app distributed inside one organization.

### Can I target API 36 without upgrading my Expo SDK?

On SDK 53 you can set targetSdkVersion and compileSdkVersion to 36 in the expo-build-properties plugin, and some developers have. React Native 0.79, which SDK 53 uses, still sends back presses through onBackPressed, and Android 16 no longer calls it at API 36. You would need to opt out with enableOnBackInvokedCallback set to false. Upgrading to SDK 54 is the supported route.

### What is the difference between compileSdkVersion and targetSdkVersion?

compileSdkVersion is the Android API version your code compiles against. targetSdkVersion tells Android which version's behavior your app has adopted, and Google Play enforces it. compileSdk must be the same as targetSdk or higher, so moving to target 36 means compiling against API 36 or later. Expo SDK 58, for example, compiles against 37 and targets 36.

### Why does Play Console still say my app targets an older API level after I changed build.gradle?

Play reads the target level from the bundle you upload, not from your source files. A hardcoded value in another module, an outdated plugin, or a library like the old Play Core can change the merged manifest. Run bundletool dump manifest on the release AAB to see the real targetSdkVersion, and make sure you uploaded the new build rather than an old artifact.

## Sources & further reading

- [Target API level requirements for Google Play apps (Play Console Help)](https://support.google.com/googleplay/android-developer/answer/11926878) (checked Oct 30, 2026)
- [Behavior changes: Apps targeting Android 16 or higher (Android Developers)](https://developer.android.com/about/versions/16/behavior-changes-16) (checked Oct 30, 2026)
- [Expo SDK 54 changelog](https://expo.dev/changelog/sdk-54) (checked Oct 30, 2026)
- [What's new in Flutter 3.38](https://flutter.dev/blog/whats-new-in-flutter-3-38) (checked Oct 30, 2026)
- [fix(mobile): target Android SDK 36, AudiusProject/apps PR #14635](https://github.com/AudiusProject/apps/pull/14635) (checked Oct 30, 2026)
- [Flutter 3.35.2 forces SDK 34 despite explicit overrides, flutter/flutter issue #174516](https://github.com/flutter/flutter/issues/174516) (checked Oct 30, 2026)

## Related

- [App Store phased release: how the 7-day rollout works, when to pause and how to ship a fix (2026)](https://makeyourapp.live/blog/app-store-phased-release-update-rollout-plan)
- [App Store release notes examples: write What's New text that tells users what changed (2026)](https://makeyourapp.live/blog/app-store-release-notes-examples)
- [All posts](https://makeyourapp.live/blog)