Mobile App Development

Deep Linking in Mobile Apps: A Complete Guide

Master mobile deep linking — universal links, app links, and deferred deep linking — so every user-acquisition funnel lands users exactly where they need to go.

By Laxaar Engineering Team Nov 21, 2026 10 min read
Deep Linking in Mobile Apps: A Complete Guide

Every campaign link, email CTA, and QR code is a bet that a user will land on the right screen inside your app. When that bet fails (iOS opens a browser page instead of your checkout flow, or Android drops an uninstalled user on the store homepage with no memory of what they wanted), you lose the conversion. That failure isn't a marketing problem. It's a mobile deep linking problem, and it's entirely solvable in code.

Deep linking routes inbound URLs to specific content or states inside a native app rather than the app's home screen. Done right, every touchpoint in your acquisition funnel behaves like a direct link. Done wrong, it produces silent failures that don't show up in crash reporters and only surface as mysteriously flat conversion rates.

The Laxaar team has wired deep linking for apps across fintech, e-commerce, and SaaS products. Three categories of approach actually work: universal links, app links, and deferred deep linking. Picking the wrong one for the wrong funnel stage costs real users.

What you'll learn

What mobile deep linking actually is

Mobile deep linking is a mechanism that maps an HTTP(S) URL (or a custom URI scheme) to a specific route inside a native iOS or Android application. When the device intercepts that URL, it passes the path and query parameters to the app rather than opening the browser.

Three things have to work together for a link to succeed: the operating system has to know that your app claims the URL, the app has to be installed and registered to handle it, and the app's router has to parse the incoming path and navigate to the right screen. Failure in any of those three layers produces a different symptom, which is why debugging broken links requires checking all three before you draw conclusions.

There's one opinionated take worth stating plainly: HTTP(S) universal/app links should be the default for every new project. Custom URI schemes (myapp://) are fine for internal cross-app communication, but they don't work when the app isn't installed and they can be hijacked by competing apps on Android. Every funnel-facing link should be an HTTPS URL your server can also serve as a fallback web page.

Universal links on iOS: how they work

Universal links are iOS's mechanism for associating an HTTPS domain with a specific app. When a user taps a registered URL, iOS checks a local cache of domain-to-app associations and, if a match is found, routes the URL to the app instead of Safari.

The association is established via an Apple App Site Association (AASA) file served at https://<yourdomain>/.well-known/apple-app-site-association with no file extension and an application/json content type. Apple's servers fetch and cache this file during app installation or update. If the file isn't reachable, or returns the wrong content type, universal links silently stop working. The device falls back to Safari with no error.

{
  "applinks": {
    "details": [
      {
        "appIDs": ["TEAMID.com.yourcompany.yourapp"],
        "components": [
          {
            "/": "/product/*",
            "comment": "Match any product detail URL"
          },
          {
            "/": "/checkout/*"
          }
        ]
      }
    ]
  }
}

A few points that burn teams: the appIDs field must use your Apple Team ID prefix, not the bundle ID alone. The components array in iOS 14+ replaces the older paths key; mix them and older OS versions may ignore your newer patterns. And Apple re-fetches the AASA through its own CDN, so changes to the file can take 24 hours to propagate to devices that have already cached a previous version.

On the app side, handle incoming links in the application(_:continue:restorationHandler:) delegate method, parse the userActivity.webpageURL, and route accordingly. In React Native, this surfaces through Linking's getInitialURL() and addEventListener('url', ...) APIs.

App links on Android: the parallel story

App links are Android's equivalent, introduced in Android 6.0 and working through a Digital Asset Links JSON file served at https://<yourdomain>/.well-known/assetlinks.json.

[
  {
    "relation": ["delegate_permission/common.handle_all_urls"],
    "target": {
      "namespace": "android_app",
      "package_name": "com.yourcompany.yourapp",
      "sha256_cert_fingerprints": [
        "AB:CD:EF:..."
      ]
    }
  }
]

The sha256_cert_fingerprints array must match the signing certificate your release APK or AAB is built with. This is the single most common source of broken app links after a key rotation or when a team switches between debug and release builds. Keep a separate assetlinks entry if you need both signing keys active simultaneously.

In your AndroidManifest.xml, add an intent-filter with android:autoVerify="true" and android:scheme="https". Without autoVerify, the OS shows a disambiguation dialog instead of launching directly. That extra tap tanks conversion rates on paid-acquisition campaigns where every friction point is lost revenue.

URI schemes: when the old approach is still fine

Custom URI schemes (myapp://path) predate universal and app links and still have two legitimate uses: triggering deep links between your own apps (for example, a companion app opening the main app), and testing deep link routing on simulators where AASA/Digital Asset Links verification isn't always reliable.

The trade-off is real. Any app can register the same URI scheme on Android, meaning a malicious or carelessly named competing app can intercept your links. iOS is stricter but not immune. URI schemes also don't survive an uninstalled state: if the app isn't installed, the link fails entirely rather than routing through a store listing or web fallback.

For external-facing links in any acquisition funnel, URI schemes are the wrong tool. Use them for internal tooling, testing, and cross-app communication where you control both ends of the handshake.

Deferred deep linking and why install attribution depends on it

Deferred deep linking is the pattern that covers the gap between "user taps a link when the app isn't installed" and "user opens the app for the first time after installing." Standard universal and app links can't survive an app install; the context is lost the moment the user lands on the App Store or Play Store.

The solution involves a redirect service (first-party or via a provider like Branch, AppsFlyer, or Adjust) that stores the intended destination path tied to a device fingerprint or click ID before bouncing the user to the store. On first launch, the SDK queries its service, retrieves the stored path, and fires the navigation as if the link had been tapped directly.

This is the mechanism that makes paid acquisition funnels work. Without it, a user who taps a product-specific ad, installs, and opens the app lands on the home screen with no idea why. With deferred deep linking, they land on the exact product they were looking at. The conversion difference is substantial, often 20-40% on install-to-purchase flows.

The trade-off: fingerprint-based matching is probabilistic, not deterministic. On iOS 14.5+, with AppTrackingTransparency restrictions, fingerprint accuracy drops on Apple devices unless you have a verified click ID from the ad network. Plan for a small percentage of mis-attributed or unmatched deferred links and design the fallback experience accordingly.

A decision tree for picking the right approach

The right deep linking strategy depends entirely on which funnel stage the link serves.

ScenarioRecommended approach
App is installed, link from web or emailUniversal links (iOS) / App links (Android)
App is NOT installed, paid acquisition campaignDeferred deep linking via redirect service
Internal cross-app navigation, your apps onlyURI scheme or universal link
Testing routing on simulatorURI scheme (easiest to trigger)
Link needs a working web fallback if app absentUniversal/App links with server-side fallback page
Attribution required across install boundaryDeferred deep linking with SDK (Branch, AppsFlyer, etc.)

Two rules that hold regardless of scenario: always serve a real web page at your HTTPS link URLs as a fallback, and always test deep links on real devices across fresh-install, installed, and backgrounded states. Simulator testing misses a large class of verification failures.

Implementation checklist for React Native and Expo

React Native's Linking module handles both universal/app links and URI schemes through the same API. Expo wraps this further and adds EAS-managed entitlements for iOS.

For iOS, add the Associated Domains entitlement to your app in Xcode (or in app.json under expo.ios.associatedDomains for managed Expo builds):

{
  "expo": {
    "ios": {
      "associatedDomains": [
        "applinks:yourdomain.com"
      ]
    }
  }
}

For Android, Expo can inject the intent-filter automatically when you provide the correct config plugin or set expo.android.intentFilters in app.json:

{
  "expo": {
    "android": {
      "intentFilters": [
        {
          "action": "VIEW",
          "autoVerify": true,
          "data": [
            {
              "scheme": "https",
              "host": "yourdomain.com",
              "pathPrefix": "/product"
            }
          ],
          "category": ["BROWSABLE", "DEFAULT"]
        }
      ]
    }
  }
}

Inside the app, use a URL-to-route parser. React Navigation's linking config is a natural fit:

const linking = {
  prefixes: ['https://yourdomain.com', 'myapp://'],
  config: {
    screens: {
      ProductDetail: 'product/:productId',
      Checkout: 'checkout/:orderId',
      Home: '',
    },
  },
};

One thing we see teams skip: testing the cold-start path. Linking.getInitialURL() returns the URL that opened the app from a terminated state. If your navigation initializes before that promise resolves, the initial deep link is silently dropped. Await it before rendering the navigator.

At Laxaar, we treat deep linking verification as a release gate, not an afterthought. Automated tests that fire known deep link URLs on device farms catch registration and routing regressions before they hit a campaign.

If you're building a mobile app that needs robust deep linking across complex acquisition funnels, the Laxaar mobile development practice has done this across React Native, Flutter, and native iOS/Android projects.

Frequently Asked Questions

What's the difference between a universal link and a URI scheme?

A universal link uses your standard HTTPS domain and requires your server to host a verification file. When the app is installed, iOS routes the HTTPS URL directly to the app; when it's not, Safari opens normally. A URI scheme uses a custom protocol like myapp:// and only works when the app is already installed. Universal links are more reliable and provide a web fallback, making them the right choice for public-facing links.

Why are my universal links opening in Safari instead of my app?

The most common causes are: the AASA file is unreachable or has wrong content-type headers, the app's Associated Domains entitlement doesn't match the domain exactly, or the user navigated to the link from Safari's address bar (iOS intentionally excludes this case to prevent hijacking). Test with a link tapped from Notes, Mail, or Messages (not pasted into Safari's address bar) and use Apple's AASA validation tool to confirm the file is correctly served.

Does deferred deep linking work without a third-party SDK?

You can build a minimal version yourself: store the destination path server-side tied to a device fingerprint or click token before redirecting to the store, then query your own endpoint on first launch. The challenge is fingerprint accuracy under privacy restrictions on iOS 14.5+ and the operational overhead of maintaining the service. For most production acquisition funnels, using an established provider is worth the cost.

How should we handle deep links when the destination screen requires authentication?

Store the deep link path before checking auth state, complete the login or sign-up flow, then navigate to the stored path. Don't try to navigate directly to the protected screen before auth resolves. React Navigation's linking config processes links before the navigator is fully ready, so the pattern is to hold the intended URL in state, check auth, and trigger navigation after the auth gate clears.

Can deep links pass parameters like promo codes or referral IDs?

Yes, and this is one of their most valuable uses. Encode parameters as standard URL query strings (?promoCode=LAUNCH20&ref=email) and parse them in the screen's route params. For deferred deep links, the SDK preserves query parameters through the install boundary so a promo code in an ad click is still available when the user first opens the app.


Getting deep linking right unlocks every downstream marketing and growth investment you make. A broken link silently deflates the ROI on paid campaigns, email sequences, and referral programs. If you'd like the Laxaar team to audit your current linking setup or build out a full attribution-aware deep linking architecture, get in touch. We'll map out what's broken and what to fix first.

Working on something like this?

Get a fixed scope, timeline, and price within one business day — no obligation.

Mobile App DevelopmentDeep LinkingUniversal Links
Grow your business with us

Take your business to the next level.

Tell us what you're building. We'll come back inside one business day with a fixed scope, timeline, and team — or an honest “this isn't a fit”.

ENGINEERING PHILOSOPHY

Code is useless if it's not comprehensible to those who maintain it. We write code the next person can actually understand.