Google Play Target API 35 Warning Blocks Release Track Promotion - Manifest and SDK Alignment Fix - How to Fix

Problem: Your Android App Bundle uploads successfully, but Google Play blocks rollout or promotion with a target API 35 warning or policy alert. Internal testing might pass while production promotion is blocked at the final step.

Common symptoms:

Play Console policy panel flags target API compliance during promotion
release notes are ready, but the release stays in warning or blocked state
local project settings show API 35, yet Play still detects an older target level
only one flavor or one build lane fails while others pass

This usually happens when the effective merged manifest or build output does not match what your team expects from editor settings.

Why this spikes now (2026 Android release cycles)

In 2026, teams are shipping more frequent hotfixes while mixing Unity upgrades, AGP updates, and ad or analytics SDK refreshes in the same sprint. That combination creates drift between:

editor-level target API settings
Gradle templates and plugin constraints
generated merged manifests used for final packaging

The result is a late-stage compliance surprise: everything looks configured for API 35 in project UI, but the published bundle still resolves differently in Play policy checks.

Root cause

Google Play API 35 warnings usually come from one or more of these:

Manifest merge override
A library manifest or legacy template overrides targetSdkVersion during merge.
Compile and target SDK mismatch in build templates
Project settings and Gradle template values drift after upgrades.
Outdated plugin dependencies
Older ad, mediation, billing, or analytics plugins pin older Android settings.
Wrong build lane promoted
CI uploads an artifact from a stale branch, flavor, or cached job.
Assumption without artifact inspection
Team validates settings in editor, but not the generated .aab metadata path used by Play checks.

Quick fix checklist

Pin one release tuple: branch, flavor, version code, expected target API.
Confirm project, Gradle, and merged-manifest values all resolve to API 35.
Update or remove plugins that inject older target values.
Rebuild a clean AAB in CI and inspect final manifest output.
Upload the verified artifact and confirm policy status before promotion.

Step 1 - Lock one Android release tuple

Before changing anything, define one source of truth for this promotion:

release_branch
build_flavor (or Unity build profile)
version_code
expected_target_api = 35
expected_compile_sdk >= 35

This prevents mixed validation where one teammate tests local debug output while CI promotes a different artifact.

Step 2 - Align Unity or Gradle Android settings

In your project configuration:

Set target API to Android 35 in project settings.
Ensure compile SDK is compatible with your target API.
Regenerate or review Gradle templates if your project uses custom templates.
Confirm no hardcoded lower target value remains in templates or build scripts.

If you recently upgraded Unity, also verify your Android build tools and SDK manager installation include the platform and build-tools expected by that Unity version.

Step 3 - Validate merged manifest output (not just source manifest)

The policy check evaluates effective output, so inspect merged results:

build the release AAB from the exact lane you will upload
inspect merged manifest entries for the release variant
confirm target SDK resolves to 35 in final output
check for library manifests that override or conflict with main values

If your manifest source says 35 but merged output differs, treat that as the real blocker.

Step 4 - Triage plugin and dependency drift

Focus on SDKs that commonly drag older Android requirements:

ad and mediation adapters
billing and monetization packages
legacy analytics or push libraries
old Android support dependencies still present through transitive references

Update incompatible packages to current supported versions and remove stale duplicates from your project plugin paths.

Step 5 - Rebuild clean, inspect artifact, then upload

Run a clean release build and verify the exact file being uploaded:

clear build cache for the lane (local or CI workspace)
generate fresh AAB from the validated branch and config
inspect manifest output and keep a screenshot or text capture
upload the new AAB
re-open Play policy panel and confirm warning is cleared before promotion

This avoids reusing stale artifacts that still carry outdated target values.

Verification checklist

After applying the fix, confirm:

Play Console no longer shows target API 35 warning for the new artifact
merged manifest in the uploaded build resolves target API to 35
compile SDK and target SDK values are consistent across lane configs
version code in Play matches your validated artifact
release track promotion completes without policy block

Alternative fixes for stubborn edge cases

If warnings persist:

create a temporary minimal lane excluding optional plugins to isolate manifest overrides
compare two successive AAB uploads with different version codes to detect stale caching
run dependency tree inspection to identify transitive Android libraries pinning older settings
move promotion to a clean CI runner image where SDK and Gradle caches are fully rebuilt

Prevention for future Android release windows

Add an API-compliance gate to your release checklist:

verify merged manifest target API from release output
verify compile SDK and target SDK tuple in build logs
lock supported plugin versions before content freeze
require artifact fingerprint plus version code in approval notes

That gate catches policy drift before Play upload and prevents last-hour promotion failures.