Most mobile developers are familiar with deep linking. However, there is a critical gap in standard implementations – the “Installation Gap” – that consistently breaks the user journey for React Native, Flutter, and iOS apps. While standard deep linking can seamlessly route users to specific content, its utility ends the moment it hits a device where the app isn’t installed.

In the landscape of mobile attribution, this friction in the user experience is incredibly costly. This is where deferred deep linking comes in: a technique focused on passing custom data through the app installation to preserve the user’s intent and context.

Native redirection: universal links & app links

When a user clicks a link, the outcome depends on whether the app is already on their device. For users who already have the app, Detour leverages native OS mechanisms to ensure a seamless “warm” open. We host the necessary configuration files to establish this trust:

• For iOS (Universal Links): Detour hosts the Apple App Site Association (AASA) file, which links your domain to the app using your Bundle ID and Team ID.

• For Android (App Links): Detour hosts the assetlinks.json file, connecting the domain to your app via the package name and a generated SHA-256 certificate.

With these files in place, the operating system automatically detects the association and opens the application natively. As a developer, your only task is to handle the incoming link in your navigation logic and redirect the user to the appropriate view.

However, this native handler is entirely dependent on the app already being present on the device. If that connection doesn’t exist, the journey is interrupted by an app installation, which typically strips away the additional data you intended to pass to the application.

Why standard deep links fall short: the installation gap

A deferred deep link is a link that preserves the user's intended destination and context through the app installation process, routing them to the right screen on the very first open — even if the app wasn't installed when they clicked the link.

Whether dealing with user invites, referral IDs, or product links, you need a “middleman” to bridge the gap between a browser click and the first app open.

While Android has a straightforward process via the Google Play Install Referrer, iOS treats this as a privacy boundary. This is why bypassing the App Store attribution gap is not supported directly by the OS.

As an alternative, Apple encourages developers to use their own platform solutions:

• Universal Links: great for opening the app if it’s already installed, but they offer zero deferred utility. Furthermore, they are quite fragile – if your marketing flow involves a JavaScript redirect or a middleman tracking URL, iOS often ignores the “Universal” aspect entirely and just opens the link in a browser tab.

• App Clips: extracted parts of the app that don’t require a full install. While useful, they still don’t support complex referral flows and have strict size limitations.

• SKAdNetwork: this is primarily a marketing measurement toolkit. It’s great for aggregating data, but not for improving the individual user’s UX.

All of these, while excellent solutions in their respective areas, don’t quite meet the requirements for deferred deep linking to the desired extent. That’s why a proper deferred deep-linking solution must use accurate deterministic matching on Android while falling back on probabilistic matching on iOS.

How deferred deep link matching works: deterministic vs probabilistic

Deterministic matching on Android

Android offers a highly reliable way to pass data through the Play Store using the Google Play Install Referrer API.

When a user clicks a Detour link, we generate a unique click_id. This ID is passed as a referrer parameter to the Play Store. Once the app is installed and launched, the Detour SDK retrieves this click_id from the API and sends it to our servers. Because this ID is persisted by the Play Store itself, the match is 100% accurate.

If the matching is perfect, why use Detour for Android?

Even with a 100% match rate, managing links manually can be a headache. Using a platform like Detour is convenient because it provides:

• Unified SDK: handle both iOS and Android logic with a single listener.

• Centralized link management: define short links, parameters, and campaigns in a single place.

• Unified analytics: Track the entire user journey and specific in-app events.

Probabilistic matching on iOS

The logic is straightforward: when a user clicks a link in their mobile browser, they are redirected to an intermediary page. Ideally, this should be barely noticeable, but in some scenarios, you might want to consider a “copy to clipboard” fallback to improve accuracy – an intermediary “bridge” page that encourages the user to copy a referral token or link before heading to the App Store.

During this click, Detour captures a “snapshot” of the user’s environment. Since we don’t have a persistent ID that survives the App Store on iOS, we rely on temporary fingerprinting – using a combination of non-identifying signals that are passed to our platform.

Once the user installs and opens the app for the first time, we collect a second snapshot on the mobile side. If the match confidence exceeds your configured threshold and the installation occurs within the allowed time window, the original parameters are passed through.

Note: while Detour works for almost any use case, probabilistic matching isn’t 100% foolproof on shared networks. It’s great for marketing, but avoid using it to pass highly sensitive info like medical data without an extra validation step in your app. You can read more about it in documentation.

The real challenge: handling deferred deep links after the match

Matching a user to a link is the heavy technical lift happening under the hood, but for a developer, the real friction starts after the match is made, especially when the app has a complicated navigation structure or user flow. In most legacy SDKs, you are handed a matched object and left to manually connect that intent through splash screens, auth gates, and deep nesting. 

This "first-open" logic is notoriously brittle. It’s where the user experience usually breaks – not because the link didn't match, but because the app's navigation state wasn't ready to consume it. We realized that for deferred links to actually feel native, they shouldn't live in a separate third-party listener; they should be a core part of the routing itself.

Looking for a Branch.io or AppsFlyer alternative? Here's why we built Detour

When I asked my colleagues what they used for this specific purpose, their answers were either Branch or AppsFlyer. It was a bit of a surprise to me, since deferred deep links in the context of both platforms seem more like an addition. Both are noticeably marketing-oriented and focus heavily on attribution flow and data analysis.

While we wouldn’t like to resign from the marketing utilities entirely, our background is strictly technical, so we really wanted to create something that would be:

• Comfortable: simple integration without the “enterprise” bloat.

• Flexible: including options for self-hosted deferred deep linking for those in need of more data control.

• Affordable: functionality that doesn’t overcharge for basic routing.

That's exactly what we built Detour to be – a developer-first alternative that gets out of your way.

What’s next for Detour?

Some time ago we released Detour 1.0, which already includes core utilities such as:

• Deferred deep linking with matching config

• Custom domains

• SDKs for React Native, iOS, Android, and Flutter

• Basic analytics (retention, events, and link analysis)

To support large-scale applications, our upcoming focus includes SSO, expanded self-hosting options, and ad-provider integrations.

Get started with Detour 

Detour is free to start and takes minutes to integrate with your React Native, iOS, Android, or Flutter app. Check out the documentation to get started, or reach out to us directly – we're happy to help!

• Read the docs 

• Discord 

• contact@godetour.dev