Deferred deep linking that survives the install
WarpLink's deferred deep linking carries a tap through the install, with install attribution and real-time analytics.
What is deferred deep linking?
Deferred deep linking sends a new user to the screen a link named, even when they had to install the app first. The store drops the link, so WarpLink records the tap, matches the first app open back to it, and hands your app the original link with a confidence score.
How it works
- It works on iOS, Android, React Native, and Flutter through one SDK, with no advertising identifier and no App Tracking Transparency prompt.
- The store install drops the URL, so the new app never receives the link that was tapped.
- Of 309 matched installs, 303 went to the correct link (98.1 percent) in our October 2026 device test, and Play Store installs matched 30 of 30.
- The server reads the request address at tap time and again on first launch, because an app cannot see its own public IP.
- Matching walks an ordered cascade: the invitation token on a referral link, then the install referrer, then the device ID (IDFV), then a probabilistic match on address, language, and timezone, then raw signals. The first match wins.
- The onLink callback receives isDeferred, the link's destination and deep link URL, a match type, a confidence score from 0.0 to 1.0 built from the match's signal type and the time since the tap, and matchGuaranteed.
Set it up on your stack
Register your app
Add your iOS bundle ID and team ID, your Android package name, or both. Every organization registers an app before it creates links, and a link tied to that app falls back to its store listings for visitors without it, so the Play Store visit carries the install referrer.
Create a link
Set the web destination and the in-app path, then choose the match window: 6 hours by default, anywhere from 1 to 24, set per link in the dashboard. It only governs probabilistic matches, so the Android referrer path is unaffected by it.
Ship the SDK and route
Add the SDK for iOS, Android, React Native, or Flutter and call configure once at launch. The first-launch check runs on its own and delivers a match to your onLink callback with isDeferred set. Keep sign-in on your own authentication.
Handle the first open in each SDK
import WarpLink
WarpLink.configure(
// SDK key from Keys > SDK
apiKey: "wl_live_yoursdkkeyhere000000000000000000",
options: WarpLinkOptions(onLink: { result in
guard case .success(let deepLink) = result, let deepLink else { return }
if deepLink.isDeferred {
// Survived the App Store install.
navigate(to: deepLink.deepLinkUrl ?? deepLink.destination)
} else {
navigate(to: deepLink.destination)
}
})
)WarpLink.configure(
context = this,
// SDK key from Keys > SDK
apiKey = "wl_live_yoursdkkeyhere000000000000000000",
options = WarpLinkOptions(onLink = { result ->
result.onSuccess { deepLink ->
if (deepLink.isDeferred) {
// Survived the Play Store install.
navigateTo(deepLink.deepLinkUrl ?: deepLink.destination)
} else {
navigateTo(deepLink.destination)
}
}
})
)import { WarpLink } from '@warplink/react-native'
WarpLink.configure({
// SDK key from Keys > SDK
apiKey: 'wl_live_yoursdkkeyhere000000000000000000',
onLink: ({ deepLink }) => {
if (!deepLink) return
if (deepLink.isDeferred) {
// Survived the store install.
navigateTo(deepLink.deepLinkUrl ?? deepLink.destination)
} else {
navigateTo(deepLink.destination)
}
},
})import 'package:warplink_flutter/warplink_flutter.dart';
// Call from your root widget's initState
WarpLink.configure(
// SDK key from Keys > SDK
apiKey: 'wl_live_yoursdkkeyhere000000000000000000',
onLink: (event) {
if (event is! LinkEvent) return;
final deepLink = event.deepLink;
if (deepLink.isDeferred) {
// Survived the store install.
navigateTo(deepLink.deepLinkUrl ?? deepLink.destination);
} else {
navigateTo(deepLink.destination);
}
},
);How does deferred deep linking work?
A tap takes one of three paths. With the app installed, the operating system opens it on the linked screen. Without it on Android, the Play Store carries a referrer through the install and the SDK reads it on first launch. Without it on iOS, the server matches the first launch to the tap by probabilistic matching.
| Compared on | App installed | Not installed, Android | Not installed, iOS |
|---|---|---|---|
| What the tap does | The system opens the app on the linked screen | The browser follows the redirect to the Play Store, with a referrer naming the link | The browser follows the redirect to the App Store |
| What reaches the app | The URL, at the tap | The referrer, on first launch | A server match, on first launch |
| Match type | Exact: the system delivers the URL | Exact: the referrer names the link | Probabilistic, scored from 0.0 to 1.0. A referral link is exact through its invitation token |
| Where you read it | onLink, with isDeferred false | onLink, with isDeferred true and matchGuaranteed true | onLink, with isDeferred true and a matchConfidence |
Deep link vs deferred deep link
A standard deep link opens a screen in an app that is already installed: the operating system hands the URL straight to the app. A deferred deep link covers the visitor who has to install first. The URL cannot pass through the store, so a server matches the first open back to the tap and returns the link then.
| Compared on | Standard deep link | Deferred deep link |
|---|---|---|
| App installed at the tap | Yes | No, the tap leads to the store |
| Install step | None | An App Store or Play Store install comes first |
| How the app gets the link | Universal Links or App Links hand over the URL | The SDK asks the server on first launch |
| Context preserved | The full URL, including its query | The destination and the deep link URL, with any query on it |
| Certainty | Exact: the operating system delivers the URL | Exact with the Play Install Referrer or a referral invitation, a scored match otherwise |
How iOS and Android match an install
Android can name the click exactly, because the Play Store carries a referrer through the install. On iOS, a first install is matched probabilistically on network, language, and timezone and comes back with a confidence score from 0.0 to 1.0, except a referral link, which is exact through its invitation token.
| Compared on | Android | iOS |
|---|---|---|
| What survives the store | The install referrer we add to the Play Store URL | Nothing, except a referral invitation that reaches the app through the system paste control |
| First-install match | Exact: the referrer names the link | Probabilistic match on request address, language, and timezone. Referral links: exact through the invitation token |
| When the exact path is missing | The probabilistic match covers sideloaded builds, devices without the Play Store, and destinations that are not a Play Store URL | Probabilistic matching is the first-install match path. |
| A repeat check from the same install | The referrer answers it again | The IDFV returns the result the install already got |
| Confidence | 1.0 with the referrer, up to 0.85 on the probabilistic match | 1.0 with an invitation token, otherwise up to 0.85, lower as the hours pass |
| matchGuaranteed | True for a referrer match | True for an invitation token match. False for a probabilistic match, which carries a confidence score |
| Permission prompt | None, no advertising ID | None, no IDFA and no ATT prompt |
Deferred deep link match methods
Only the invitation token and the Play Install Referrer are exact, so those matches carry confidence 1.0. A probabilistic match on request address, language, and timezone is an estimate, so it returns a confidence score with the link, and your app can route on that score. The device ID only repeats a result the install already got.
| Method | Where it applies | Result |
|---|---|---|
| Invitation token | iOS referral links, through the system paste control | Exact, confidence 1.0 |
| Play Install Referrer | Android installs from the Play Store | Exact, confidence 1.0 |
| Device ID (IDFV) | A repeat check from the same iOS install | The result the install already got |
| Probabilistic match | A first install on iOS, and Android installs without a referrer | Scored from 0.0 to 1.0, up to 0.85 in the first hour |
Confidence, privacy, and match windows
A probabilistic match is scored from the time since the tap: 0.85 at the top inside the first hour, lower as the hours pass. The match key is a one-way hash. Each tap can be matched only within the link's match window (6 hours by default, 1 to 24 per link), and pending entries expire automatically.
| Time since the tap | Top probabilistic score | What it is good for |
|---|---|---|
| Under 1 hour | 0.85 | Open the exact public screen |
| 1 to 3 hours | 0.65 | Open the screen, or name it on a welcome |
| 3 to 6 hours | 0.50 | Suggest the content on a welcome screen |
| 6 to 24 hours | 0.30 | A hint only, for links set past the 6 hour default |
Specifications
- Exact matches
- A Play Install Referrer match on Android is exact. So is a referral invitation on iPhone. Both score 1.0, set evidence_class to exact, and set matchGuaranteed. Use matchGuaranteed and the confidence score to choose how specific a screen to open.
- Match window
- Set the match window per link, from 1 to 24 hours (6 by default). The check runs once per install, and later launches make no extra request.
- Confidence over time
- The strongest probabilistic matches, within the first hour, score 0.85.
- SDK releases
- The iOS, Android, React Native, and Flutter SDKs are all at version 1.2.0, open source under the MIT license.
- Availability
- Included on every plan with deep linking, install attribution, and real-time analytics. Redirects are never blocked at any click limit.
- Plans
- Free includes every feature. Plans start at Free ($0, 10K clicks a month) and run through Starter ($19), Growth ($49), and Scale ($99) to Unlimited ($149, no click ceiling).
- Sub-10ms redirects
- Never blocked
- Open source SDKs
- MCP server, free on all plans
300+ is the edge network's published node count. How we measure sub-10ms.
Common questions
What is deferred deep linking on iOS?
It sends a new iOS user to the screen a link named after they install from the App Store. WarpLink records the tap, then matches the first launch to it on the request address, the device language, and the IANA timezone name. A first install on iOS comes back with a confidence score, and a referral link adds an exact path: the invitation page hands the app an install token through the system paste control. It needs no IDFA and no App Tracking Transparency prompt.
How does deferred deep linking work on Android?
Through the Play Install Referrer. WarpLink adds a referrer naming the link when it sends a visitor to a play.google.com store URL, the Play Store carries it through the install, and the SDK reads it on first launch for an exact match at confidence 1.0. The SDK uses the probabilistic match as a second path.
What are the different types of deep links?
Three kinds matter on mobile. A custom URL scheme such as myapp://item/7 opens an installed app and fails when the app is missing. Universal Links on iOS and App Links on Android are verified https links that open the app when it is installed and the website when it is not. A deferred deep link adds the install case: it carries the destination through the store so the first launch lands on the right screen.
Which one do I actually need, a deep link or a deferred deep link?
If your links reach people who may not have the app, you need both. A deep link opens an installed app from the tap. A deferred deep link carries the same destination through the store install, so a first-time user lands on the right screen instead of the home screen. One WarpLink link and one SDK callback cover both cases.
Will a user keep their context through a first-time install?
Yes, within the match window. The link's destination and deep link URL, with any query on it, reach the app on first launch through onLink, marked isDeferred. Android matches exactly through the Play Install Referrer. iOS matches probabilistically with a confidence score, and a referral link matches exactly through its invitation token. The window is 6 hours by default, 1 to 24 per link.
The link layer your app is missing.
Set up deep linking, attribution, and analytics in minutes. Free to start.
Have a question?