# How to Fix "Google Play Protect Blocked This App" When Installing an APK

> AI Release · @ai_release1 · https://ai-release.org/guides/kak-ispravit-google-play-protect-zablokiroval-prilozhen_en.html

## TL;DR

- **Time to complete:** 15 minutes
- **Difficulty:** Intermediate
- **You'll need:** an Android device (record its version in Step 1), a data-capable USB cable, Android SDK Platform Tools (`adb`), Android SDK Build Tools (`apksigner`), the `.apk` or `.apks` you are installing.

"Play Protect blocked the app" is three different screens, and only two of them let you through. Most guides collapse them into one and tell you to tap **Install anyway** — which is exactly the button that is missing on the screen where Google's server already classified the build as harmful. Identify the screen before touching any setting.

| What you see | What triggered it | Can you continue? |
|---|---|---|
| `Blocked by Play Protect` with a single **OK** button | Server-side verdict: the build is classified as harmful or PUA (potentially unwanted app) | No — this dialog has no bypass |
| `Unsafe app blocked` / "This app may be harmful", with **Install anyway** (sometimes hidden behind **More details**) | Play Protect has no reputation data for this signing certificate | Yes |
| `Failure [INSTALL_FAILED_VERIFICATION_FAILURE]` in the terminal | The package verifier rejected the streamed ADB install | Yes, after switching the verifier off for ADB |

Checklist before you start:

- [ ] Photograph or copy the exact on-screen text
- [ ] Confirm the APK is signed at all (`apksigner verify`)
- [ ] Back up app data if an older copy must be uninstalled
- [ ] Re-enable every security toggle you turn off

## Requirements and setup
![Illustration: Requirements and setup](https://ai-release.org/guides/img/kak-ispravit-google-play-protect-zablokiroval-prilozhen-en-1.jpg?v=1794926470)


- Windows, macOS or Linux with the vendor USB driver installed.
- Android SDK Platform Tools on `PATH` — verify with `adb version`.
- Android SDK Build Tools — `apksigner` lives at `<SDK>/build-tools/<version>/apksigner`. The version number depends on what you installed; check the documentation for the build-tools release you have.
- USB debugging enabled: Settings → About phone → tap **Build number** seven times, then Settings → System → Developer options → **USB debugging**.
- The APK on your computer, not on the phone. Note the full path.
- For split packages you need `bundletool` to produce or extract a `.apks` set — check the documentation for current syntax.

**Example:** on macOS with a default Android Studio install, the binary is at `~/Library/Android/sdk/build-tools/<version>/apksigner`; the same `<SDK>/build-tools/<version>/` layout applies on Linux and Windows.

Menu names for Play Protect differ between Android versions and vendor skins (Pixel, Samsung One UI, Xiaomi HyperOS) — check the documentation for your build; the toggle itself is named **Scan apps with Play Protect** everywhere.

## Step 1. Identify the block and record the device baseline

**What to do:** capture the on-screen wording, then read the device state over ADB.

```bash
adb devices
adb shell getprop ro.build.version.release
adb shell getprop ro.build.version.sdk
adb shell dumpsys package com.google.android.gms | grep -m1 versionName
adb shell settings get global package_verifier_enable
adb shell settings get global verifier_verify_adb_installs
```

**Example output:**

```
List of devices attached
R58M12ABCDE     device
14
34
    versionName=24.xx.xx
1
1
```

`1` means the toggle is on, `0` means off, `null` means the key does not exist on this build.

**Why:** Play Protect ships inside Google Play Services (`com.google.android.gms`), while the package verifier is a separate layer that also inspects ADB installs. Knowing which layer stopped you decides whether you fix this in Settings or in the shell — and the captured string tells you whether the verdict came from Google's servers or from the local verifier.

**How to check:** the device must appear as `device`, not `unauthorized`, and five values must print. If you see `unauthorized`, run `adb kill-server && adb start-server` and accept the RSA prompt on the phone.

## Step 2. Clear the block on the correct layer
![Illustration: Step 2. Clear the block on the correct layer](https://ai-release.org/guides/img/kak-ispravit-google-play-protect-zablokiroval-prilozhen-en-2.jpg?v=1794926479)


**What to do:** match the route to the screen from the TL;DR table.

**Route A — dialog with an "Install anyway" button.** Open Settings → Security (or Security & privacy) → More security settings → Google Play Protect → gear icon → turn off **Scan apps with Play Protect**, retry the install, then turn it back on immediately.

**Route B — ADB verification failure.** Check the signature first, then disable the verifier for ADB only:

```bash
apksigner verify --verbose --print-certs app-release.apk
adb shell settings put global verifier_verify_adb_installs 0
adb install -r -d app-release.apk
adb shell settings put global verifier_verify_adb_installs 1
```

For split packages, install all parts in one transaction instead of one by one:

```bash
adb install-multiple base.apk split_config.arm64_v8a.apk
```

**Example:** `adb install -r -d app-release.apk` prints `Performing Streamed Install` followed by `Success`. The `-r` flag reinstalls over an existing copy, `-d` allows a version downgrade.

**Why:** `verifier_verify_adb_installs` controls only the ADB path — it does not disable Play Protect's on-device scanning, so it is the least invasive switch available. Leaving it at `0` silently weakens every future sideload, which is why the restore command is part of the same block.

If the APK comes from a third-party repository or you are replacing Google apps on the device entirely, see [How to Replace Google Apps with Fossify: Install, Configure and What Works Without Google Play](https://ai-release.org/guides/kak-zamenit-prilozheniya-google-na-fossify-ustanovka-na.html?utm_source=tg&utm_medium=channel&utm_campaign=guide_inline&utm_content=guide_to_guide) — the same install principles apply to any F-Droid-style build.

**How to check:** `apksigner` prints `Verifies` plus a `Signer #1 certificate DN:` line. `adb install` prints `Success`. After the restore command, `adb shell settings get global verifier_verify_adb_installs` returns `1`.

## Step 3. Confirm the install and re-arm protection
![Illustration: Step 3. Confirm the install and re-arm protection](https://ai-release.org/guides/img/kak-ispravit-google-play-protect-zablokiroval-prilozhen-en-3.jpg?v=1794926484)


**What to do:** verify the package is present, launched, and not silently quarantined.

```bash
adb shell pm list packages | grep com.example.app
adb shell dumpsys package com.example.app | grep -E "versionName|firstInstallTime|installerPackageName"
adb shell monkey -p com.example.app -c android.intent.category.LAUNCHER 1
```

**Example output:**

```
package:com.example.app
    versionName=1.0.0
    firstInstallTime=2025-01-01 12:00:00
    installerPackageName=null
```

`installerPackageName=null` is normal for ADB and sideload installs; `com.android.vending` means the copy came from Google Play.

**Why:** a blocked install can leave a stale or partially installed package that `pm list packages` still reports. Reading `versionName` and `firstInstallTime` proves you are running the build you just pushed, and `monkey` proves the app actually starts instead of crashing at launch.

**How to check:** `monkey` prints `Events injected: 1` and the app opens on screen. Then open Play Store → profile icon → Play Protect → **Scan** and confirm the app still launches afterwards and is not listed as harmful.

If this build is meant for a team rather than for yourself, stop distributing raw APKs — [How to Publish a Private App on Google Play and Install It on Android](https://ai-release.org/guides/poshagovoe-rukovodstvo-kak-opublikovat-chastnoe-prilozh.html?utm_source=tg&utm_medium=channel&utm_campaign=guide_inline&utm_content=guide_to_guide) describes the private-track route, which removes the warning entirely because the app is distributed by Play itself.

## Troubleshooting

**Problem. ADB install is rejected even though the APK is valid.**
- Error: `Failure [INSTALL_FAILED_VERIFICATION_FAILURE]`
- Cause: the package verifier is intercepting the streamed ADB install; `verifier_verify_adb_installs` is still `1`.
- Solution: run `adb shell settings put global verifier_verify_adb_installs 0`, repeat `adb install -r -d app-release.apk`, then `adb shell settings put global verifier_verify_adb_installs 1`.

**Problem. The dialog has only an OK button; "Install anyway" never appears.**
- Error: `Blocked by Play Protect`
- Cause: Google's server-side verdict flagged the build, so the local UI deliberately offers no bypass. Toggling **Scan apps with Play Protect** does not remove this screen.
- Solution: do not fight it. Verify what you are installing first — `sha256sum app-release.apk` on Linux/macOS or `certutil -hashfile app-release.apk SHA256` on Windows — and compare the hash with the one published by the developer. If it matches and you still need the app, rebuild and sign it with a release keystore and distribute it through a Play private track instead of sideloading.

**Problem. Installation stops with "App not installed" right after the warning is dismissed.**
- Error: `Failure [INSTALL_FAILED_UPDATE_INCOMPATIBLE: Package com.example.app signatures do not match previously installed version; ignoring!]`
- Cause: the installed copy was signed with a different key — typically a debug build sitting next to a release build.
- Solution: `adb uninstall com.example.app` (this deletes app data), then `adb install app-release.apk`. Keep one keystore per package and reuse it for every build.

## Summary and next steps

Identify which of the three block screens you are looking at before changing any setting, because only two of them are overridable. After installing, always restore `verifier_verify_adb_installs` to `1` and re-run a Play Protect scan to confirm the app still launches.

## FAQ

**Does turning off "Scan apps with Play Protect" remove the block permanently?**
No. The toggle affects local scanning, while server-side verdicts persist and Play Services may re-enable the option after an update.

**Is it safe to disable Play Protect just to install one APK?**
It is acceptable for a short, verifiable window if you trust the APK's source and hash. Re-enable it immediately after the install; the device is unprotected while it is off.

**Why does Play Protect warn about an app I compiled myself?**
A debug or freshly generated certificate has no install history, so it looks identical to a brand-new unknown publisher. Signing with a stable release keystore does not remove the warning either — reputation accumulates over installs.

**Does installing over ADB bypass Play Protect completely?**
Only the ADB verification path. Play Protect still scans installed apps on the device afterwards and can flag or remove the package later.
