Deep linking is the technique of using a URL or URI that opens a specific screen, product or piece of content inside a mobile app, rather than launching the app at its home screen. In mobile app development, a deep link connects the web, email, advertising and notifications to an exact destination in the app, the same way a web link points to a page rather than to a site’s front door.
Modern deep linking relies on operating system features that verify domain ownership, so a normal web address can open the app when it is installed and fall back to the website when it is not. Getting this right affects user experience, campaign attribution and security, which is why it is a routine but surprisingly error-prone part of shipping an app.
How deep linking routes a link into an app
A deep link works by letting the operating system intercept a link before the browser handles it and hand it to an installed app that has declared it can process that address. The app then parses the path and parameters and navigates to the matching screen.
The process has three stages. First, the app declares the links it handles in its manifest or entitlements. Second, the operating system matches an incoming link against those declarations when the user taps it. Third, the app’s routing layer maps the path, for example /product/4821, to a screen and loads the required data, often after checking login state.
The table below compares the main mechanisms used on Android and iOS.
| Mechanism | Platform | Link format | Verification |
|---|---|---|---|
| Custom URL scheme | Android and iOS | myapp://product/4821 | None, any app can claim the scheme |
| Universal Links | iOS and iPadOS | https://example.com/product/4821 | apple-app-site-association file on the domain |
| Android App Links | Android 6.0 and later | https://example.com/product/4821 | assetlinks.json file with the signing certificate |
| Intent filter without verification | Android | HTTPS or custom scheme | None, a chooser dialog may appear |
Types of deep links
Deep links are classified by what happens when the app is not installed. This distinction matters for marketing and onboarding, because many users who tap a link do not yet have the app.
| Type | App installed | App not installed | Typical use |
|---|---|---|---|
| Standard deep link | Opens the target screen | Fails or shows an error | Internal navigation, QR codes for existing users |
| Verified web link | Opens the target screen | Opens the matching web page | Shared content, email, search results |
| Deferred deep link | Opens the target screen | Sends to the store, then opens the target after install | Paid acquisition, referral programs |
| Contextual deep link | Opens the target with extra data | Keeps referral data through install | Personalized onboarding, promo codes |
Deferred deep linking is the hardest type, because the link context must survive a trip through the app store. Since Install Referrer on Android and privacy changes on iOS, reliable deferral usually depends on the platform referrer, a clipboard handoff the user approves, or an attribution provider that matches the click to the first app launch.
Deep linking compared with related concepts
Deep linking overlaps with several neighboring ideas in app development, and the terms are often used loosely. The comparison below separates them by purpose.
| Concept | Main purpose | Relation to deep linking |
|---|---|---|
| Push notification | Re-engage users with a message | Often carries a deep link as its tap target |
| App indexing | Show app content in search results | Depends on verified web links |
| Dynamic link services | Build smart links with fallbacks and analytics | A hosted layer on top of deep linking |
| In-app routing | Navigate between screens inside the app | The internal system a deep link feeds into |
| Hybrid app navigation | Load web content in a native shell | Needs bridging so links reach the web view |
Cross-platform frameworks such as Flutter, React Native and Expo provide routing packages that read incoming links, but the platform configuration files and domain verification remain native responsibilities that each project must set up.
Implementing deep links in a project
A dependable implementation starts with a single URL structure shared by the website and the app, so every important screen has one canonical address. Teams then map that structure to app routes and publish the verification files.
- Define the URL patterns that the app supports and document their parameters.
- Publish the association files over HTTPS at the
.well-knownpath, without redirects. - Declare the domains in Xcode entitlements and in Android Studio intent filters with
autoVerifyenabled. - Build a central link router that validates parameters and handles unknown paths gracefully.
- Test cold start, warm start and logged-out states on real devices, using Android Debug Bridge and simulator commands.
The router should treat every incoming link as untrusted input. It should check that identifiers exist, require authentication before showing private data and never execute actions such as payments or account changes directly from link parameters.
Common failures and how to fix them
Most deep linking bugs come from configuration drift between the website and the app, not from the app code itself. The table lists frequent symptoms and their usual causes.
| Symptom | Likely cause | Fix |
|---|---|---|
| Link opens the browser | Association file missing, redirected or cached | Serve the file directly over HTTPS and revalidate |
| Android shows a chooser | App Links verification failed | Match the certificate fingerprint in assetlinks.json |
| App opens on the home screen | Router ignores the path on cold start | Handle the initial link before the first render |
| Link works in Safari but not in an email client | In-app browser blocks app handoff | Add a fallback page with an open-in-app button |
| Attribution data is lost after install | No deferred deep link mechanism | Use the platform referrer or an attribution provider |
Custom URL schemes carry an additional risk: any app can register the same scheme, so a malicious app may intercept links containing tokens. Sensitive flows such as OAuth redirects should use verified HTTPS links with PKCE, not bare custom schemes.
The idea in brief
A deep link is like giving someone the exact room number instead of just the building address. When you tap it, the app opens straight to the right product, article or chat, not to its front page.
If the app is missing from your phone, a well-built link still works: it shows the web page or sends you to the store and remembers where you wanted to go. The key benefit is fewer taps and less searching for the person using the app.
A practical scenario
A regional grocery chain sends a weekly email with links to discounted products. At first the links point to the website, so customers who have the app still land in a mobile browser, must log in again and often abandon their carts. The team decides to adopt verified web links using the same product URLs.
Developers publish the association files on the shop domain, add the domains to the iOS and Android projects and build a router that maps /product/ paths to the product screen. Customers without the app continue to see the web page. After two weekly campaigns, the share of email clicks that open the app rises to roughly 60 percent of clicks from app users, and cart completion from email improves noticeably because shoppers arrive already logged in with their saved payment methods.