We’ve all been there: You build a slick mobile app, you launch a marketing campaign, and you send users a link. You expect them to land exactly where you sent them.

But sometimes, they don’t.

If the user doesn’t have the app installed, they land on the home screen. The magic is lost. The conversion drops. The marketing budget burns.

This is where the difference between Deep Links, Universal Links/App Links, and Deferred Deep Links becomes critical. And this is why tools like AppsFlyer OneLink exist.

Let’s break it down.

1. Why do we need this when Native Links exist?

You might be thinking: “Wait, isn’t Apple’s Universal Link and Android’s App Link enough? They’re free and built-in.”

Technically? Yes. Practically? No.

Native Links (Universal/App Links) are great for existing users. If I have your app, clicking a link opens the specific product page. Simple.

But they fall apart the moment a new user is involved:

1. The Install Gap: If I don’t have the app, a Universal Link just opens a website or the App Store. Once I install the app, the OS "forgets" what I clicked. I land on the home screen. Context lost.
2. The Fragmentation Problem: You can’t run one campaign URL for both iOS and Android. You need two links. If a user clicks an iOS link on an Android device, it breaks.
3. Zero Attribution: Native links don’t tell you which ad brought the user. Was it the email? The Facebook ad? The QR code? You’re flying blind.

AppsFlyer OneLink solves this by acting as the "brain" behind the scenes. It creates a single, smart URL that works for everyone, on every device, and remembers exactly where the user wanted to go—even if they had to install the app first.

2. How to create one (The Setup)

You don’t need to build this from scratch. Here’s the high-level flow:

1. The Domain: You need a domain (e.g., link.yourapp.com).
2. The Native Files: You must host two specific files on that domain:
   • iOS: apple-app-site-association (No extension!) at /.well-known/.
   • Android: assetlinks.json at /.well-known/.
3. The AppsFlyer Config:
   • In the AppsFlyer dashboard, you generate a OneLink domain.
   • You map your iOS Bundle ID and Android Package Name.
   • You verify the domain by ensuring the native files are accessible.
4. The Link: You create a link like link.yourapp.com/product/123.

Pro Tip: If your iOS file downloads instead of displaying JSON in your browser, check your S3/CloudFront Content-Type header. It must be application/json. If it’s binary/octet-stream, iOS might ignore it (or cache it weirdly).

3. How it tracks (The Attribution Magic)

This is the secret sauce. When you click a OneLink:

1. The Click: AppsFlyer’s server logs the click, capturing your IP, device model, and the destination (e.g., product/123).
2. The Redirect: You are sent to the App Store or Google Play.
3. The Install: You download and open the app.
4. The Handshake: The AppsFlyer SDK in your app wakes up, sends a "fingerprint" (IP + Device Model + Time) to the server.
5. The Match: The server matches your "fingerprint" to the original click.
6. The Result: The app receives the data product/123 and navigates you there.

You now know exactly which campaign drove that install and exactly which screen the user saw.

👁 Appsflyer The Attribution Magic

---

Deferred Deep Linking: The Real Magic

Now, let’s get into the deep end. Deferred Deep Linking is the specific technology that bridges the "Install Gap."

👁 Deferred Deep Linking: The Real Magic

What is it?

A Deferred Deep Link is a link that preserves the user’s intent across the installation process.

• Standard Deep Link: Works if app is installed.
• Deferred Deep Link: Works if app is not installed. It waits for the install, then delivers the specific content.

How it works (End-to-End Flow)

This is where the engineering gets interesting. Here is the minute-by-minute breakdown of what happens when a new user clicks a link.

Step 1: The Click & Fingerprinting

• User clicks link.yourapp.com/shoes-101.
• The request hits AppsFlyer’s server first.
• The Server: Captures a "snapshot" of the device:
  • IP Address
  • User Agent (Device model, OS version, Browser)
  • Screen dimensions
  • The Destination: shoes-101
• This data is stored in a database with a short expiration (e.g., 24 hours).

Step 2: The Redirect

• Since the app isn’t installed, the server redirects the user to the App Store (iOS) or Play Store (Android).
• Android: The Play Store passes a referrer string containing a unique click ID.
• iOS: Apple doesn’t pass a referrer. The server relies on the fingerprint match later.

Step 3: The Install & First Launch

• User installs the app and opens it for the first time.
• The AppsFlyer SDK initializes immediately (before your app logic runs).
• The SDK: Sends the device’s current "fingerprint" (IP, Model, OS) back to the AppsFlyer server.

Step 4: The Match (The "Magic" Moment)

• Deterministic Match (Android): If the referrer ID was passed, the server matches it directly. 100% accuracy.
• Probabilistic Match (iOS/Android): If no ID exists, the server compares the new fingerprint against the stored fingerprints from the last hour.
  • Example: "Device X with IP 192.168.1.1 clicked a link 10 mins ago. Device X just opened the app. Match!"
• Privacy Note: With iOS 14.5+ (ATT), if the user denied tracking, the match relies heavily on IP + User Agent. It’s not 100% perfect, but it’s the best we have without invasive tracking.

Step 5: The Routing

• The server returns the data: {"screen": "shoes-101", "campaign": "summer_sale"}.
• Your app’s code receives this data in the onStart or onLaunch handler.

• Your Logic:
  

  if (deferredData.screen) {
   navigateTo(deferredData.screen);
  } else {
   navigateTo('home');
  }
  

• The user lands on the shoe page, sees the discount, and buys.

👁 Android vs IOS appsflyer deferred deeplink

Conclusion

Native Deep Links are the foundation, but they are incomplete. They are great for re-engagement but terrible for acquisition.

Deferred Deep Linking is the bridge that turns a generic install into a personalized experience. It ensures that the user’s first moment in your app is the exact moment they intended.

Tools like AppsFlyer OneLink handle the complexity of fingerprinting, server-side matching, and cross-platform routing so you don’t have to.

If you are serious about mobile growth, you can’t just rely on applink or universal link. You need the "memory" that only a deferred deep linking solution can provide.

---

Have you struggled with "broken" deep links in your app? Let me know in the comments how you solved it!