How to Update Your App to Target Android 15 (API Level 35) or Higher

If you’re an Android developer, you’ve likely received a warning from Google Play Console: “App must target Android 15 (API level 35) or higher.” This requirement, effective August 31, 2025, ensures apps stay secure, performant, and compatible with the latest Android devices. But what does it mean to target API level 35, and how can you update your app to comply? Don’t worry—this beginner-friendly guide will walk you through every step, address common issues (like those faced by Kivy developers), and help you get your app ready for Google Play.

In this article, we’ll cover why Google enforces this requirement, how to update your app, and how to troubleshoot persistent warnings. Whether you’re using Kivy, Flutter, React Native, or native Android development, you’ll find clear, actionable steps to meet the Android 15 target. Let’s get started!

Why Does Google Require Apps to Target Android 15 (API Level 35)?

Google updates its target API level requirement annually to ensure apps leverage the latest security, privacy, and performance improvements in Android. By targeting Android 15 (API level 35), your app aligns with the latest Android OS features, providing a better user experience.

Key Reasons for the Requirement

• Security: Android 15 introduces stricter permissions and non-SDK interface restrictions to protect user data.
• Performance: Features like edge-to-edge display and optimized rendering (e.g., Vulkan API) improve app smoothness.
• Compatibility: Ensures apps work seamlessly on devices running Android 15 and future versions.
• User Trust: Apps targeting older APIs may lack modern safety standards, reducing discoverability on Google Play.

Question for Reflection: Why do you think Google sets a deadline of August 31, 2025, for this requirement? What might happen to apps targeting older APIs, like Android 13 (API level 33)?

Starting August 31, 2025, new apps and updates must target API level 35, except for Wear OS, Android Auto, and Android TV apps, which require API level 34. Existing apps must target at least API level 34 to remain visible to new users on devices running Android 15 or higher. Non-compliant apps risk being hidden from newer devices, impacting downloads and revenue.

Understanding Target API vs. Minimum API

Before diving into the steps, let’s clarify two key terms:

• Target API Level: The Android version your app is designed to fully support, defined by targetSdkVersion in your build configuration. Targeting API 35 means your app is optimized for Android 15’s features and behavior changes.
• Minimum API Level: The oldest Android version your app supports, defined by minSdkVersion. This ensures compatibility with older devices.

Question for Reflection: How might setting a higher target API level affect your app’s features or user base? Why might you choose a lower minSdkVersion?

Step 1: Check Your Current Target API Level

First, confirm your app’s current target API level. This helps you understand if you need to update.

How to Check

• Google Play Console: Go to your app’s dashboard, navigate to “App Integrity” or “Advanced Settings,” and check the listed target API level.
• Code Inspection:
  • Open your AndroidManifest.xml file and look for the targetSdkVersion attribute.
  • In Gradle-based projects, check build.gradle (app-level) for targetSdkVersion.

Example (build.gradle):

android {
    compileSdkVersion 34
    defaultConfig {
        targetSdkVersion 34
        minSdkVersion 21
    }
}

Question for Reflection: If your app targets API 34, why might Google Play still show a warning about needing API 35?

Step 2: Update Your Build Configuration

To target Android 15, update your app’s targetSdkVersion to 35. The steps depend on your development framework.

For Native Android (Gradle)

1. Open build.gradle (app-level):
   • Find the android section.
   • Update compileSdkVersion and targetSdkVersion to 35.
2. Example:android { compileSdkVersion 35 defaultConfig { targetSdkVersion 35 minSdkVersion 21 } }
3. Sync Gradle: In Android Studio, click “Sync Project with Gradle Files.”
4. Update Dependencies: Ensure libraries (e.g., AndroidX, Google Play services) are compatible with API 35. Check for updates in build.gradle.

For Kivy (Buildozer)

If you’re using Kivy with Buildozer (as in the Stack Overflow post), modify the buildozer.spec file:

1. Open buildozer.spec.
2. Update the following lines:android.api = 35 android.minapi = 21 # Adjust based on your needs android.sdk = 35
3. Rebuild your app:buildozer android clean buildozer android debug
4. Upload the new APK/AAB to Google Play.

Common Issue: Some Kivy developers report persistent warnings even after updating to API 35. This often happens due to old app bundles in testing tracks (e.g., internal or closed testing).

Question for Reflection: Why might updating only the android.api in Buildozer not resolve the warning immediately?

For Flutter

1. Open android/app/build.gradle.
2. Update:android { compileSdkVersion 35 defaultConfig { targetSdkVersion 35 minSdkVersion 21 } }
3. Run flutter clean and rebuild:flutter build appbundle

For React Native (Expo)

1. Open app.json.
2. Update the expo-build-properties plugin:"plugins": [ [ "expo-build-properties", { "android": { "compileSdkVersion": 35, "targetSdkVersion": 35, "buildToolsVersion": "35.0.0" } } ] ]
3. Rebuild:expo prebuild expo run:android

Pro Tip: Use Android Studio’s SDK Manager to download Android 15 (API level 35) SDK tools and test your app in an emulator.

Step 3: Address Android 15 Behavior Changes

Targeting API 35 introduces behavior changes that may affect your app. Let’s explore some key changes:

• Edge-to-Edge Display: Apps targeting API 35 are edge-to-edge by default, using the full screen (including status and navigation bars). Test your UI to ensure content isn’t obscured.
• PendingIntent Mutability: You must specify whether PendingIntent objects are mutable or immutable. Update your code to comply.
• Custom Notifications: Notifications with custom layouts use a standard template to ensure consistency. Use Notification.DecoratedCustomViewStyle if needed.
• Foreground Service Restrictions: Apps can’t start foreground services from the background, except in specific cases. Review your service logic.
• Non-SDK Restrictions: Android 15 further limits non-SDK interfaces. Use official SDK alternatives to avoid crashes.

Question for Reflection: Which of these changes might affect your app’s functionality? How can you test for compatibility?

Testing Tips

• Use an Android 15 emulator or device to test your app.
• Check for deprecated APIs using Android Studio’s lint tool.
• Review the Android 15 Behavior Changes guide.

Step 4: Update Testing Tracks

A common issue (as seen in the Stack Overflow post) is persistent warnings due to old app bundles in testing tracks (e.g., internal, open, or closed testing). Even if your production bundle targets API 35, older bundles in other tracks can trigger warnings.

How to Fix

1. Go to Google Play Console:
   • Navigate to “Release” > “Testing” (Internal, Open, or Closed tracks).
   • Check for active bundles with targetSdkVersion < 35.
2. Update or Pause Tracks:
   • Upload a new bundle targeting API 35 to each active track.
   • Alternatively, pause tracks with non-compliant bundles.
3. Check App Bundle Explorer:
   • Go to “Release” > “App Bundle Explorer.”
   • Ensure all active bundles target API 35.
4. Wait for Processing: Warnings may take 24-48 hours to clear after updates.

Question for Reflection: Why might Google Play flag testing tracks for API compliance, even if they’re paused?

Step 5: Submit Your Updated App

Once your app targets API 35 and passes testing:

1. Build a new APK or AAB.
2. Upload it to Google Play Console (Production or Testing track).
3. Submit for review.
4. Monitor the “Policy Status” page for warning updates.

If warnings persist, double-check all tracks and contact Google Play support.

Step 6: Request an Extension (If Needed)

If you can’t update by August 31, 2025, Google allows an extension until November 1, 2025:

• Access the extension form in Google Play Console (available later in 2025).
• Submit the form via the “Policy Status” page.

Question for Reflection: Under what circumstances might you need an extension? How could planning ahead prevent this?

Troubleshooting Common Issues

Here are solutions to issues reported by developers (e.g., Kivy users on Stack Overflow):

• Warning Persists After Update:
  • Check all testing tracks for old bundles.
  • Ensure the uploaded AAB/APK’s AndroidManifest.xml shows targetSdkVersion="35".
  • Wait 24-48 hours for Google Play to process.
• Build Errors:
  • Update Gradle (e.g., to 8.8.2) and plugins.
  • Ensure dependencies are compatible with API 35.
• Kivy-Specific Issues:
  • Update buildozer.spec to android.api = 35 and android.sdk = 35.
  • Clean and rebuild: buildozer android clean.
• Expo/React Native:
  • Use Expo SDK 52 or higher, which supports API 35.
  • Update app.json as shown above.

Question for Reflection: Have you encountered any of these issues in your app? How might you diagnose the root cause?

Troubleshooting Table

Tools to Simplify the Process

• Android Studio: Use the SDK Manager to download API 35 and the SDK Upgrade Assistant for guidance.
• Google Play Console: Check policy status and app bundle details.
• Lint Tool: Identify deprecated APIs or compatibility issues.
• Canva/Photopea: Create visuals for your app’s updated UI (e.g., edge-to-edge design).

FAQs About Targeting Android 15 (API Level 35)

Why does Google Play enforce this requirement?

Google ensures apps use the latest security and performance features, protecting users and maintaining platform quality.

Can I keep a lower minSdkVersion?

Yes, a lower minSdkVersion (e.g., 21) ensures compatibility with older devices, but targetSdkVersion must be 35.

What happens if I miss the deadline?

Your app won’t be visible to new users on devices running Android 15 or higher, but existing users can still access it.

How do I test for Android 15 compatibility?

Use an Android 15 emulator or device, and run lint checks in Android Studio.

Conclusion: Get Your App Ready for Android 15

Updating your app to target Android 15 (API level 35) is essential to stay compliant with Google Play’s 2025 requirements. By updating your build configuration, addressing behavior changes, and checking testing tracks, you can resolve warnings and keep your app visible. Start early to avoid last-minute stress, and test thoroughly to ensure a smooth user experience.

Call to Action: Check your app’s target API level today! Have you faced issues like persistent warnings or build errors? Share your experience in the comments, or ask for help.

Resource: For detailed guidance, visit Android Developers: Meet Google Play’s Target API Level Requirement.