Android Deep Linking Setup: App Links, assetlinks.json, and No-Code Setup

blog-image

Published on:

18 November, 2026

Rimjhim

By Rimjhim

Technical Content Writer

TL;DR:

Your Android app opens a website link only when your domain is verified for that particular app. This type of link is called an App Link. On Android 12 and later versions, a link that is not verified opens in the browser. Only the pages your app is set to handle will open inside the app. To get verified, put an assetlinks.json file on your website and ensure its fingerprint matches the build you publish.

Check these before you begin:

  • You must own the domain and can upload files to its .well-known folder.

  • Your website loads using HTTPS without any redirects.

  • You can open your app in Google Play Console.

  • You must know the package name of your Android app.

  • You can release a new version of the Android app.

Think of it like this. You click on a link, and Android asks one question. Does this app own this website? If yes, the link opens in the app. If no, the link opens inside the browser.

This works on Android 6 and above. Now, on Android 12, there is no way to move back. If your domain is not verified, the link goes straight to the browser. If the app is not installed, the link opens your website, because an App Link is a normal web link.

What HappensWhat Opens
App installed + Domain verified + Page is handledYour Android app on the right screen
App installed + Domain not verified + Android 12 & laterThe browser
App installed + Domain not verified + Android 11 & lowerMight be a choice dialogue
App not installedYour website inside the browser
Custom scheme link + App not installedNothing opens because there is no website behind it

Deep links open a specific screen inside your app, not the home screen. For example, a link to shop for shoes that opens inside an app. The user does not get lost, research the product again, explore more products, and spend more time inside the app.

App Link is a Deep Link that uses your own website address. It also states that you own this website. Android does this by reading your assetlinks.json file and matching the fingerprint inside it with your app’s signing certificate. This restricts other apps from stealing your links.

There is one more type of deep linking called Deferred Deep Linking. In this case, the user clicks on the link, then installs the app first, and then lands on the right screen where it came from. It requires additional setup for proper functioning. If you want to know more, read our blog on Deferred Deep Linking.

If the links point towards your own website, Android recommends app links. So, you have two options.

The first option is to use your existing website links. As your domain is verified, a link like https://yourdomain.com/product/123 becomes a deep link on its own. It opens your app when the app is installed and your website when the app is not opened.

The second option is a registered custom scheme like example://gizmos. This works only when the app is installed. It can still trigger the chosen dialog if another app registers the same scheme.

Steps to Configure Deep Linking in Webtonative Without Coding

People who want to configure deep linking without coding on Android, Webtonative offers a no-code setup that handles the complete configuration from the dashboard.

Step 1: Log In to Webtonative

Navigate to Webtonative and log in to your account. From the dashboard, look for the apps you have built. And click on the app in which you want to configure deep linking. Now, click on the Edit button to edit your Android app.

Step 2: Look for Link Handling

Navigate to the Link Handling section. Click on the link handling.

Step 3: Configure Deep Linking

As you open the Link Handling section. You will see Deep Linking. Click on Configure to start the configuration of the deep linking.

Step 4: Add Your Domain

As you click on "Configure," a pop-up will open to enter the domain of your website. For example, mystore.com is in the field. This will define that whenever a user clicks a link from this domain through a mobile device, they should open the app instead of redirecting them to the browser.

Webtonative handles the app part of the deep linking. Now, you have to handle a few things at your website level also.

If you build the Android app by yourself, add an intent filter to the activity that should open your links. Android requires the line and android:autoVerify=”true” along with data elements for both HTTP and HTTPS.

<intent-filter android:autoVerify="true">
  <action android:name="android.intent.action.VIEW" />
  <category android:name="android.intent.category.DEFAULT" />
  <category android:name="android.intent.category.BROWSABLE" />
  <data android:scheme="http" />
  <data android:scheme="https" />
  <data android:host="www.example.com" />
</intent-filter>

If you want only specific pages to open in the app, add android:pathPrefix or android:pathPattern to a data element, and only matching links will reach the app. On Android 15 and later, you can also define path rules inside assetlinks.json. These rules can only narrow what your manifest allows. Your app receives the complete link through getData(), which you can use to open the right screen.

Creating the assetlinks.json File

The assetlinks.json file tells Android which apps are allowed to open links for your domain. It contains your app’s package name and the SHA-256 fingerprints of its signing certificates.

Now, log in to Google Play Console, select your app, and use one of the two methods below.

MethodWhere To Go in Google Play ConsoleWhat to Copy
App Signing PageRelease, Setup, App SigningThe Digital Asset Links JSON
Deep Links PageGrow users, Deep links, Domains tableThe JSON generated for your domain

Save the copied JSON as assetlinks.json. Two points about fingerprints worth knowing.

  • If you use Play App Signing, use the fingerprint that Play Console shows. A fingerprint taken from your local keystore usually will not match the one on your devices.

  • If you test with a debug build, add its fingerprint also. The file can hold more than one.

A finished file looks like this when everything is placed properly.

[{
  "relation": ["delegate_permission/common.handle_all_urls"],
  "target": {
    "namespace": "android_app",
    "package_name": "com.example.yourapp",
    "sha256_cert_fingerprints": ["<release_fingerprint>", "<debug_fingerprint>"]
  }
}]

Once the assetlinks.json file is ready. You have to upload it on your website at a particular location to make it easily accessible for Android to fetch and verify at the same time.

Step 1: Upload the JSON file

Upload the JSON file to your website’s root directory at this location: https://yourdomain.com/.well-known/assetlinks.json. You might need to create a folder called .well-known in your website’s root directory before uploading the JSON file. You must place the assetlinks.json file inside this folder.

Step 2: Confirm the Three Conditions

After uploading the file, verify all three of the following conditions are true:

  • The file must be accessible through HTTPS. Open the URL in your browser and confirm it loads successfully without any errors.

  • The file must be served with an application or JSON content type. No plain text or HTML inside the file is accepted.

  • It should directly respond with the JSON without redirecting to another URL.

Step 3: Publish Your Updated App to the Play Store

This is the step that is ignored by most people. Once deep linking is configured successfully, you must publish it on the Google Play Store with the updated version of your app. Google only verifies the published apps, not your local app builds.

Step 4: Verification Status

Once your app’s updated version is published, you have to wait for 1 to 3 days for the verification confirmation. Then log in to your Google Play Console → navigate to the Deep Links section → view the verification status of your Android app.

If configured successfully, you will see a confirmation that the domain is verified and Android App Links are active. If there are any problems, they will let you know if the problem is with the app's configuration or the assetlinks.json file.

You must run these three tests through the Android Debug Bridge on a device or emulator.

1. Domain Verification Test

Domain Verification Test confirms whether an Android has verified your domain or not. On Android 12 and later versions, reset the link state, and run verification again. And wait a few minutes, then read the result. The device must be online while this happens.

adb shell pm set-app-links --package com.your.package 0 all
adb shell pm verify-app-links --re-verify com.your.package
adb shell pm get-app-links com.your.package

NOTE: Each domain should show verified. A state of none can simply mean that the verification has not finished yet.

2. Link Resolution Test

Link Resolution Test works like an actual app showing whether Android picks your app or not. When no package is named, Android resolves the URL the same way a normal click would. So this shows whether the system picks your app. You must wait for at least 20 seconds after installing before you run it.

adb shell am start -a android.intent.action.VIEW \
  -c android.intent.category.BROWSABLE \
  -d "https://yourdomain.com/page"

Your app must open, not the browser or chooser dialog. On Android 17 and later, adding debug-link also shows which app, filter, and rule matched.

**3. App Routing Test

App Routing Test does not confirm verification. It only checks that your app opens at the right screen.

adb shell am start -W -a android.intent.action.VIEW \
  -d "https://yourdomain.com/page" com.your.package

Which Failure Are You Seeing?

SYMPTOMSREASONWHAT TO DO
Link opens in the browser on Android 12 & laterDomain not verifiedRun pm get-app-links and look for verification
State stays noneCheck unfinished or phone offlineWait, go online, and run verification again
Works from Play Console but not from a local buildFile lists only when releasing fingerprintAdd the debug fingerprint
Google Play Console shows Not OKFile missing, wrong fingerprint, or redirectHover over the status and check the file link
App opens the wrong screenApp is not reading the path or queryRun the app routing test
Some links open the app and some do notPath rules are blocking themReview path settings and dynamic rules
Chooser dialog on Android 11 or lowerOne host failed, leaving nothing verifiedUpload the file on every host

Who Shouldn't Use the No-Code Route?

The Webtonative’s no-code route is best suited for opening a web page. It may not be suitable in the following situations:

  • Native-only screens. The no-code setup can't help if a link has to open a screen that doesn't correspond to any web page. Every app link requires a real page behind it, meaning that you should have a website address for each link.

  • Games. Games are not based on website pages but rather on their own in-app screens and logic. In this case, there's not much to be linked, so in most cases the deep link should be incorporated into the game's code.

  • Apps that focus on offline usability. These apps depend on content within the app, not pages accessed from a website. The no-code route is based on website links, which isn't like apps.

  • Applications requiring specific link logic. If your application needs to determine what each link will open, such as by reading certain parameters and opening a native screen, then you will need custom Android development, and you need to write your own code for each link.

Frequently Asked Questions

Q1. Do I need coding skills to configure deep linking with Webtonative?

A. No. The app’s deep linking does not require any coding skills. You simply have to open the Webtonative dashboard and look for your Android app. Then, move forward to Link Handling and start the configuration process. Enter your domain, build the updated app, and publish it on the Google Play Store. The next step is to put the assetlinks.json file on your website, uploaded to the .well-known folder. If you can upload a file to your website or ask a web developer to do it, you can complete the entire setup without writing a single line of code.

Q2. Why are my links still opening in the browser after configuration?

A. It states that Android has not verified your domain. The usual reasons are an assetlinks.json file that is invalid or redirected to other pages. A fingerprint that does not match the key that signed the installed app, or a missing Android: autoVerify setting in your code. Even a redirection from HTTP to HTTPS or www to www can interrupt the verification. As Android 12 shows no chooser dialog, the failure is silent. You must run the domain verification test with ADB first and read the result to know what you actually have to fix.

Q3. How long does the entire verification process take?

A. Android recommends waiting at least 20 seconds after installing the app to give enough time for the verification process to complete. If you trigger the check manually with ADB, wait for a few minutes before reading the result and ensure the phone is connected to a stable internet connection. A state of none usually means the test is still running. Google Play Console Help does not state a particular time for the Domains table to update. You have to open Grow users and then Deep Links again once your new version is live. If the status still shows "Not Ok," hover over it to see which check has failed.

Q4. What is the assetlinks.json file, and why is it necessary?

A. The assetlinks.json file is a file hosted at /.well-known/assetlinks.json on your domain. It lists the apps that are allowed to open your links with their package name and signing fingerprint. When your app is installed, Android reads this file and compares the fingerprint with the app’s signing certificate. The match signals Android that you own both the website and the app. It ensures other apps can't take over your links. Without this file, Android 12 and later will open your links in the browser. So, the setup remains incomplete until the file is live.

Q5. Can I deep link multiple pages?

A. Yes. Once your domain is verified, every page that your intent filter allows can open inside the app, like category, checkout, or product pages. Pages outside those filters will open in the browser. On Android 15 and later, you can also add path rules in the assetlinks.json to keep specific links out of the app. After the setup, test a few actual links, including ones with extra parameters, to confirm that each link opens the right page.

Q6. Does deep linking work on Samsung Android devices?

A. Yes. It does work on Samsung Android devices. App links work on Android 6 and later on devices with Google services. It does not list any separate rule for other phone brands. A verified domain must work properly on a Samsung phone as on any other phone. Still, manufacturers ship their own browsers and settings, so testing is worth the effort. Before launch, install the app on a Samsung device that users commonly have, run the link resolution test with ADB, and click on a real link from the chat app. Your app must open the link directly, without a chooser dialog or browser.

Q7. What happens if someone hasn't installed my app?

A. The link opens the same page on your website inside the browser. This is one of the biggest advantages of App Link. As they are ordinary web links, nobody lands on a dead link, whether they have the app installed or not. A custom scheme link behaves differently, as there is no website behind it, and it simply fails when the app is missing. If you want to make users reach the right screen inside the app after app installation, you require deferred deep linking.

Q8. Do I need to configure deep linking separately for iOS?

A. Yes, there is a setup for iOS. Apple relies on a different file, called apple-app-site-association, that is hosted on your domain and on the Associated Domains setting within the app. In iOS, the assetlinks.json file you created for Android will not work, but it can be placed on the same website using different names. Also, Webtonative supports deep linking on iOS, so you can set your deep link for both devices and one domain. For the full process, read our guide on deep linking in iOS.

Q9. Can I test deep linking before publishing to Google Play?

A. Yes. Android checks your domain when any build says it is installed. So testing the build is necessary. Add that build’s fingerprint to the assetlinks.json next to your released fingerprint, install the build and wait for 20 seconds. Then run the three ADB tests. This confirms the verification of the domain and also helps find issues before a new release.

Conclusion

Deep linking works when three things line up. Your app publishes information about the links that it can handle, your website provides evidence of ownership with a properly hosted assetlinks.json file, and the fingerprint in that file is the same as the one present in your users' build. Testing is just as important as the setup itself, since on Android 12 and up, they will be directed to the browser if any one of these is missing. In Webtonative, the app side is just a dashboard setting, so the bulk of your effort is in the file, hosting rules, and final check.

When all is set up, send yourself a link to a product page in the chat application and click on it from a phone with an app installed and one that doesn't have an app. The first should open the app for that product. The second should open the same page in the browser. If either test fails, look at the failure table above for your symptom.

Similar Blogs