# Android App Links verification failed: read the state, then fix the cause

> When Android App Links verification fails, links open the browser and nothing tells you why. How to read the verification state with adb, what none, legacy_failure and 1024 mean, the eight causes behind them, and the cases where a verified domain still opens the browser.

Source: https://straitlink.in/blog/android-app-links-verification-failed/

**The short answer:** run `adb shell pm get-app-links <your.package>` on an Android 12 or later phone. Every domain that isn't `verified` failed. Then reset the state, run `pm verify-app-links --re-verify`, wait a few minutes and read it again. If it still fails, the cause is almost always how `assetlinks.json` is served, a fingerprint that doesn't match the installed build, or the intent filter. All three are covered below.

This guide starts from the failure and works back to the cause. If you already suspect the fingerprints, our post on [the SHA-256 mistakes that break verification](https://straitlink.in/blog/android-app-links-verification-sha-256-mistakes/) goes deeper on debug, upload and Play signing keys. For the wider adb toolkit (firing links, logcat, browser hand-offs), see [test deep links with adb](https://straitlink.in/blog/test-deep-links-android-adb-commands/). The commands and rules here come from Android's [Verify App Links](https://developer.android.com/training/app-links/verify-applinks) and [Troubleshoot App Links](https://developer.android.com/training/app-links/troubleshoot) guides.

## Why a failed verification looks like nothing

From Android 12, a failed verification sends the tap to the browser. Android's [behaviour changes for Android 12](https://developer.android.com/about/versions/12/behavior-changes-all) say a web link opens your app "only if your app is approved for the specific domain." Otherwise it "resolves to the user's default browser app instead." No error shows, no dialog appears, and your app never hears about the tap. The phone holds a per-domain verification state that tells you what went wrong, and adb can read it.

## Step 1: read the verification state

With the app installed on an Android 12 or later phone:

```bash
adb shell pm get-app-links com.yourco.app
```

The output lists each host from your intent filters:

```text
com.yourco.app:
    ID: 01234567-89ab-cdef-0123-456789abcdef
    Signatures: [***]
    Domain verification state:
      links.yourco.com: verified
      www.yourco.com: 1024
```

Android's guide lists every state it can print:

| State | What Android says it means | What to do |
|---|---|---|
| `verified` | Successfully verified for this app | Nothing on the server side. If links still open the browser, see the last section |
| `none` | Nothing recorded yet | Wait a few minutes, then re-verify (step 2) |
| `approved` | Force-approved, usually by a shell command | Not a real pass. Reset and re-verify |
| `denied` | Force-denied, usually by a shell command | Reset and re-verify |
| `migrated` | Kept from the older verification process | Re-verify to get a current result |
| `restored` | Approved after a data restore | Re-verify to get a current result |
| `legacy_failure` | Rejected by a legacy verifier, reason unknown | Work through the causes below |
| `system_configured` | Approved by the device configuration | Nothing to fix on your side |
| `1024` or higher | An error code specific to the device's verifier | Check the network, then the causes below |

Android's guide says only `verified` means the domain passed. Any other state means verification couldn't be done.

## Step 2: reset and verify again

The phone checks when the app is installed, so an old failure sticks around after you fix the server. On Android 12 and later you can run the check by hand. These are the commands from Android's guide, in order:

```bash
# 1. Forget the old result
adb shell pm set-app-links --package com.yourco.app 0 all
# 2. Run verification again (the phone needs internet)
adb shell pm verify-app-links --re-verify com.yourco.app
# 3. Wait a few minutes, then read the result
adb shell pm get-app-links com.yourco.app
```

The guide asks you to wait "a few minutes for the verification agent to finish". If the app targets Android 11 or lower, first turn on the newer verification process with `adb shell am compat enable 175408749 com.yourco.app`.

## The eight causes behind a failed state

### 1. The file isn't served the way Android needs

Android fetches `https://<host>/.well-known/assetlinks.json` for each host. Android's [assetlinks guide](https://developer.android.com/training/app-links/configure-assetlinks) asks for:

- HTTPS, even if your intent filter uses `http`
- no redirects ("no 301 or 302 redirects")
- `Content-Type: application/json`
- a file on every host the app declares

```bash
curl -sI https://links.yourco.com/.well-known/assetlinks.json
# HTTP/2 200
# content-type: application/json
```

Redirects are the classic trap. The troubleshooting guide says the system won't verify your App Links if `http://example.com` redirects to `https://example.com`, or `example.com` to `www.example.com`. The free [assetlinks.json checker](https://straitlink.in/tools/assetlinks-checker/) fetches the file the same way and names the problem.

### 2. The fingerprint doesn't match the installed build

The file lists SHA-256 fingerprints of signing certificates. The troubleshooting guide's common mistakes: a debug-signed app with only the release fingerprint in the file, lowercase fingerprints ("The signature should be in upper case"), and, with Play App Signing, missing the key Google uses to sign each release. Play Console shows that key, and a ready-made JSON snippet, under **Release → Setup → App signing**. The [SHA-256 post](https://straitlink.in/blog/android-app-links-verification-sha-256-mistakes/) covers this cause in full.

### 3. The intent filter isn't one Android verifies

Verification only looks at intent filters with `android:autoVerify="true"`, the `VIEW` action, the `BROWSABLE` and `DEFAULT` categories, and an `http` or `https` scheme. Android's Android 12 notes add that for apps targeting Android 12 or higher, the filters must "include the BROWSABLE category and support the https scheme." Also check that every host is one you control. The troubleshooting guide lists "a URL that your app doesn't own" in an intent filter as a common error.

### 4. A wildcard host with the file in the wrong place

If your filter says `android:host="*.yourco.com"`, Android's guide says the file must be published at the root host, `https://yourco.com/.well-known/assetlinks.json`. A file only on `links.yourco.com` won't verify the wildcard.

### 5. The trailing-dot host serves something else

This one is easy to miss. The troubleshooting guide says to "check that example.com. (with the trailing period) serves the same content as example.com." Some CDNs and firewall rules treat the dotted name as a different host:

```bash
curl -sI https://links.yourco.com./.well-known/assetlinks.json
```

### 6. One bad host fails them all on older Android

On Android 11 and lower, Android's guide says the app becomes the default handler "only if it finds a matching Digital Asset Links file for all hosts in the manifest." One test host behind a VPN, or a staging domain with no file, makes every domain fail on those phones. Android 12 and later verify each host on its own. Keep test hosts in a debug build variant, as the guide suggests.

### 7. Something blocks the fetch

Bot protection, a country block or a login wall in front of `/.well-known/` stops verification even when the file is right. The troubleshooting guide's "server robustness" check asks whether clients can connect to your server at all. Google's public [Digital Asset Links API](https://developers.google.com/digital-asset-links/reference/rest/v1/statements/list) shows what Google's own service reads from your domain:

```bash
curl -s "https://digitalassetlinks.googleapis.com/v1/statements:list?source.web.site=https://links.yourco.com&relation=delegate_permission/common.handle_all_urls"
```

If it lists your package and fingerprints, Google can read the file. That's good evidence but not proof that every phone can, so still re-verify on a device.

### 8. The phone hasn't picked up your fix yet

Android's guide is specific about update delays. On Android 14 and lower, the phone doesn't re-check in the background, so changes "are typically only picked up when the app is installed or updated". On Android 15 and later it re-verifies periodically, and changes "can take up to seven days to propagate". Even after a reinstall, the guide warns that "server-side caches might still delay" the new file for a few hours. On a test phone, use step 2 instead of waiting.

## Verified, but the link still opens the browser

When `get-app-links` says `verified` and taps still land in the browser, the cause is on the phone or in how the link was tapped:

- **The user turned link handling off.** Run `adb shell pm get-app-links --user cur com.yourco.app`. The `User 0` block shows `Verification link handling allowed` and which domains are enabled or disabled. In the app you can send people to the **Open by default** screen with the `ACTION_APP_OPEN_BY_DEFAULT_SETTINGS` intent, as Android's guide shows.
- **Another app owns the domain.** Android says "only one app at a time can be associated with a particular domain." Debug and release builds installed side by side are the usual culprit.
- **The link was typed into Chrome's address bar,** or opened inside an in-app browser. Tap it from a chat or email app instead. [Instagram and WhatsApp links opening the browser](https://straitlink.in/blog/instagram-whatsapp-links-open-browser-not-app/) explains the in-app browsers.
- **The path doesn't match.** Verification covers the host, but your intent filter, or on Android 15 the rules in `assetlinks.json`, can still exclude the path. On Android 17 and later, `adb shell am start --debug-link -a android.intent.action.VIEW -d "<URL>"` prints which apps, intent filters and rules matched.

On Strait, your link domain serves `assetlinks.json` for you from the package name and fingerprints in **Dashboard → Apps & stores**. It's served with a `200`, no redirect, `application/json` and fingerprints normalised to uppercase, which takes care of cause 1 for that domain. Causes 2, 3 and 6 live in your app build, so they apply with any provider. The free [App Links checker](https://straitlink.in/tools/app-links-checker/) reads both your Android and iPhone files in one go. The [App Links docs](https://straitlink.in/docs/app-links/) list what we host. On iPhone the same symptom has different causes: see [Universal Links not opening](https://straitlink.in/blog/universal-links-not-opening-causes/).

## Frequently asked questions

### How do I check if Android App Links are verified?

On Android 12 or later, run `adb shell pm get-app-links` with your package name. Each domain shows a state. Only `verified` means it passed. `none` means the check hasn't finished, and a number of 1024 or more is a verifier error.

### What does state 1024 mean in pm get-app-links?

Android documents codes of 1024 and above as custom error codes specific to the device's verifier. It doesn't say what each number means. Check the phone's internet connection, re-verify, then go through the file, fingerprint and intent filter checks.

### How long does App Links verification take?

Android's guide asks you to wait at least 20 seconds after install, and a few minutes after a manual re-verify. A changed `assetlinks.json` reaches Android 15 and later phones within up to seven days. Older versions only re-check on install or update.

### Why do App Links work on my phone but not for Play Store users?

Play App Signing re-signs the app with Google's key, so Play installs carry a different fingerprint from your local builds. Add the app signing key's SHA-256 from Play Console to `assetlinks.json`.

## Sources and how we checked

- Android Developers, [Verify App Links](https://developer.android.com/training/app-links/verify-applinks): the 20-second wait, manual verification (`am compat enable 175408749`, `pm set-app-links`, `pm verify-app-links --re-verify`, `pm get-app-links`), the list of states, `--user cur` output, one app per domain, `ACTION_APP_OPEN_BY_DEFAULT_SETTINGS` and update latency by Android version. Read on 24 October 2026 (page marked last updated 23 October 2026).
- Android Developers, [Troubleshoot App Links](https://developer.android.com/training/app-links/troubleshoot): redirects, uppercase fingerprints, Play App Signing, the trailing-period host, server robustness, non-verifiable links on Android 11 and lower, and the Android 17 `--debug-link` flag.
- Android Developers, [Configure assetlinks.json](https://developer.android.com/training/app-links/configure-assetlinks) and [Add App Links](https://developer.android.com/training/app-links/add-applinks): HTTPS, no redirects, content type, one file per host, wildcard hosts needing the file on the root host, and the Play Console snippet.
- Android Developers, Android 12 [behaviour changes for all apps](https://developer.android.com/about/versions/12/behavior-changes-all) and [for apps targeting 12](https://developer.android.com/about/versions/12/behavior-changes-12): unverified web links open the browser, and `BROWSABLE` plus `https` in verified filters.
- Google, [Digital Asset Links API: statements.list](https://developers.google.com/digital-asset-links/reference/rest/v1/statements/list). We called it on 24 October 2026 for a live domain and it returned the package name and fingerprints from that domain's file.
