# Deep Link vs Deferred Deep Link: Which One Do You Need?

> Deep link vs deferred deep link: one opens an installed app on the right screen, the other carries the link through the install. Which you need, with code.

_Last updated: 2026-10-26_

A deep link opens an app that is already installed on a specific screen. A deferred deep link does the same for someone who does not have the app yet: the link goes through the store, and the app opens on that screen after the first launch. You need both when links reach people who may not have installed.

This guide separates the two by the question each one answers, shows the code for each, and gives a short test to decide where your app stands.

## One question, two situations

Every link tap starts the same way. A person taps `https://acme.aplnk.to/spring-sale` in a message, an email, a post, or a printed code. What happens next depends on one fact: is the app on the phone?

| | App installed | App not installed |
|---|---|---|
| What the tap does | The system opens the app | The link goes to the store listing |
| The name | Deep link | Deferred deep link |
| What routes to the screen | Universal Link (iOS) or App Link (Android) | A match made on first launch |
| What you need | A verified domain and a handler | The SDK, plus a link that carries a destination |
| Without it | The browser opens instead | A new user lands on the home screen |

The first row is the version most guides stop at. The second column is the reason deferred deep linking exists.

## What a deep link is

A deep link is a URL that opens a specific screen in an installed app, not just the app. `acme://product/42` is a deep link. So is `https://acme.aplnk.to/spring-sale` when the domain is verified for your app.

Modern deep links are Universal Links on iOS and App Links on Android. Both use ordinary `https` URLs. The operating system checks a file on the domain (`apple-app-site-association` on iOS, `assetlinks.json` on Android) to confirm your app owns the link, and opens the app directly. Where the app is missing, the same URL still works in a browser.

Handling one in the app takes a few lines. On iOS, with SwiftUI:

```swift
import SwiftUI

@main
struct AcmeApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
                .onOpenURL { url in
                    Router.shared.open(url) // /spring-sale -> the sale screen
                }
        }
    }
}
```

On Android, the link arrives as the intent data:

```kotlin
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    intent?.data?.let { uri -> Router.open(uri) } // /spring-sale -> the sale screen
}
```

With WarpLink, the domain files are generated and served for you, and the SDK's `onLink` callback delivers the link with its destination, parameters, and a flag saying how it arrived. The full background is in [The Complete Guide to Deep Linking](https://warplink.app/blog/deep-linking-guide).

## What a deferred deep link is

A deferred deep link starts with the same tap, on a phone without the app. The system cannot open an app that is not there, so the visitor goes to the App Store or Google Play. They install and open the app.

At that moment the app has no memory of the tap. The store does not pass the URL to the app it installs. A deferred deep link is the mechanism that restores it: on first launch the SDK asks WarpLink which link brought this install, and the answer arrives in the same callback as any other link, marked `isDeferred`.

```swift
import WarpLink

WarpLink.configure(
    apiKey: "wl_live_yoursdkkeyhere000000000000000000",
    options: WarpLinkOptions(
        onLink: { result in
            Task { @MainActor in Router.shared.handle(result) }
        }
    )
)
```

In React Native, one callback covers all three cases:

```tsx
import { WarpLink } from '@warplink/react-native';

WarpLink.configure({
  apiKey: 'wl_live_yoursdkkeyhere000000000000000000',
  onLink: ({ deepLink, error }) => {
    if (error || !deepLink) return;
    if (deepLink.isDeferred) {
      const confidence = deepLink.matchConfidence ?? 0;
      if (confidence > 0.5) navigateTo(deepLink.deepLinkUrl ?? deepLink.destination);
    } else {
      navigateTo(deepLink.destination); // a tap on an installed app
    }
  },
});
```

The check runs once per install, automatically, from `configure()`. If the phone is offline on first launch, the failure arrives in `onLink` and the next launch tries again by itself.

## How the match is made

The tap and the first launch are two events on two screens, so something has to join them.

- **Android** hands the SDK the Play Install Referrer, a value attached to the store URL that survives the install. WarpLink puts the link identity inside it, so the match is deterministic.
- **iPhone** has no equivalent. The match uses probabilistic matching: the request IP, the device language, and the timezone, hashed, scored against recent taps. It returns a link with a `matchConfidence`.
- **A referral invitation** is the exception on iPhone. When a person pastes the invitation your app asked for, the match is exact. That path is described in [how a referral link survives the install](https://warplink.app/blog/ios-referral-link-after-install).

None of this reads an advertising identifier. There is no App Tracking Transparency prompt, because the data restores the link the person tapped and reports the install to your app. The [Apple privacy page](https://warplink.app/docs/trust/apple-privacy-and-matching) states the position in full, and the [attribution accuracy](https://warplink.app/docs/trust/attribution-accuracy) page publishes the test method.

## Which one do you need

Answer three questions about your links.

1. **Will anyone tap a link without the app installed?** If yes, you need deferred deep linking. Every link shared in a message, a post, an email, or a printed code reaches such a person eventually.
2. **Does the link carry a destination, a code, or a campaign?** If yes, losing it at the store loses the value. A generic home screen wastes the invitation, the discount, or the product the person asked for.
3. **Do you need to know which link produced an install?** The same match that restores the destination also credits the install to the link, which is install attribution.

If you answered no to all three, a plain deep link is enough. In practice almost every shared link answers yes to at least one.

## Common mix-ups

**Treating deferred deep linking as a Universal Link feature.** Universal Links and App Links open an installed app from a tap. They never see the install. Deferred deep linking is a separate step that runs on first launch.

**Routing on the deferred result without a threshold.** A deferred match on iPhone carries a `matchConfidence`. Route to a specific screen above a threshold you choose, and fall back to the home screen below it. The deferred guides for [iOS](https://warplink.app/blog/deferred-deep-linking-ios), [Android](https://warplink.app/blog/deferred-deep-linking-android), [React Native](https://warplink.app/blog/deferred-deep-linking-react-native), and [Flutter](https://warplink.app/blog/deferred-deep-linking-flutter) show the callback for each.

**Testing on a device that still has the app.** A deferred link tests only on a fresh install. Delete the app, tap the link, install from the store or TestFlight, and open the app inside the link's match window.

**Sending the same link everywhere and expecting attribution.** One link per placement keeps the install attributed to the placement. [Pass campaign values with UTM parameters](https://warplink.app/blog/pass-utm-parameters-through-deep-links) covers the parameters.

## Frequently Asked Questions

### What is the difference between a deep link and a deferred deep link?

A deep link opens an app that is already installed on a specific screen. A deferred deep link covers the case where the app is not installed: the link goes through the store, and the app opens on the same screen after the first launch.

### Do I need both?

If your links are shared with people who may not have your app, yes. A deep link alone sends a new user to a generic home screen after install. A deferred deep link alone cannot open an installed app from a tap.

### Is a deferred deep link a Universal Link or an App Link?

No. Universal Links on iOS and App Links on Android are the mechanisms that open an installed app from a tap. A deferred deep link is the install-time match that restores the link after the store.

### How does the app learn which link was tapped after an install?

The SDK checks on first launch and WarpLink matches the install to the tap. On Android the Play install referrer carries the link identity. On iPhone the match uses probabilistic matching, and a referral invitation matches exactly when the person pastes it.

### Does a deferred deep link need an App Tracking Transparency prompt?

No. WarpLink reads no advertising identifier and shows no ATT prompt. See the Apple privacy page in the docs for the position in full.

## Related Guides

- **The mechanism underneath:** [The Complete Guide to Deep Linking](https://warplink.app/blog/deep-linking-guide).
- **The concept page:** [Deferred deep links](https://warplink.app/docs/concepts/deferred-deep-links) in the docs.
- **The overview page:** [Deferred deep linking](https://warplink.app/deferred-deep-linking).
- **Invitations that survive the install:** [App referral programs](https://warplink.app/use-cases/app-referral-programs) and [invite-friends onboarding](https://warplink.app/use-cases/invite-friends-onboarding).
- **Campaign tracking:** [Campaign attribution for apps](https://warplink.app/use-cases/campaign-attribution-for-apps).

## How WarpLink Helps

We handle both halves with one link. The domain files for Universal Links and App Links are generated and served for you, the SDK delivers installed-app taps and deferred matches through the same `onLink` callback, and the install is credited to the link that produced it.

One workflow, three pillars. Deep linking puts the tap on the right screen, install attribution credits the link, and real-time analytics turns a month of that into a report. Sub-10ms redirects on the way in, one SDK on the way out.

[Create a free WarpLink account](https://dash.warplink.app/auth/signup) and get deep linking, install attribution, and real-time analytics in one SDK, with 10,000 clicks a month on the free plan.