Set up deferred deep linking

Deferred deep linking allows users who don’t have your app installed to click an Adjust link, install your app from the app store, and then be directed to their intended content when they first open the app.

How it works

This is the basic flow of deferred deep linking:

The user clicks on an Adjust deep link.
Adjust’s servers redirect the user to the app store.
The user installs or reinstalls your app and opens it.
The Adjust SDK sends a /session request and an /attribution request to Adjust’s servers.
Adjust’s servers match the click to the install or reinstall and return the deferred deep link to the SDK in one of the following responses:
- /session response (Optimized Deferred Deep Linking)
- /attribution response (legacy behavior)
The Adjust SDK delivers the deferred deep link to your app via the deferred deep link callback.
If applicable, your app displays its initial screens, such as onboarding screens and user login.
Your app handles the deep link and navigates to the appropriate screen.

Deferred deep link format

When a user clicks an Adjust branded link (brandname.go.link) and the link is deferred, Adjust’s servers convert it to app scheme format (example://), using the app scheme configured in the iOS platform settings in the Adjust dashboard, before passing it to the Adjust SDK.

Setup

Set up a deferred deep link callback

Conform to the AdjustDelegate protocol in your AppDelegate. If you have already configured attribution callbacks, you can skip this step.

Swift
Objective-C

class AppDelegate: UIResponder, UIApplicationDelegate, AdjustDelegate {
}

@interface AppDelegate : UIResponder <UIApplicationDelegate, AdjustDelegate>

Assign your AppDelegate as the delegate in the Adjust configuration before initializing the SDK.

Swift
Objective-C

1
let yourAppToken = "{YourAppToken}"
2
let environment = ADJEnvironmentSandbox
3
let adjustConfig = ADJConfig(
4
    appToken: yourAppToken,
5
    environment: environment)
6
adjustConfig?.delegate = self
7

8
// ...
9

10
Adjust.initSdk(adjustConfig)

1
ADJConfig *adjustConfig = [[ADJConfig alloc] initWithAppToken:@"{YourAppToken}"
2
                                            environment:ADJEnvironmentSandbox];
3
[adjustConfig setDelegate:self];
4

5
// ...
6

7
[Adjust initSdk:adjustConfig];

Add the adjustDeferredDeeplinkReceived callback method to your app delegate. The Adjust SDK calls this method after receiving a deferred deep link.

Swift
Objective-C

1
func adjustDeferredDeeplinkReceived(_ deeplink: URL?) -> Bool {
2
   // deep link format:
3
   //
4
   // example://summer-clothes?promo=beach&adj_t=def456
5
   //
6
   // TODO: Handle the deep link
7
   // (for example, store it or handle it immediately)
8

9
   return false // or true based on your use case (see below)
10
}

1
- (BOOL)adjustDeferredDeeplinkReceived:(NSURL *)deeplink {
2
      // deep link format:
3
      //
4
      // example://summer-clothes?promo=beach&adj_t=def456
5
      //
6
      // TODO: Handle the deep link
7
      // (for example, store it or handle it immediately)
8

9
      return NO; // or YES based on your use case (see below)
10
}

Return Value Options

The return value of adjustDeferredDeeplinkReceived determines what happens after your callback code executes:

Return `false` (most common)

Use this approach if you want your app to have complete control over when and how to process the deferred deep link. By returning false, the Adjust SDK will not attempt to open the deferred deep link. For example, this approach is appropriate if your app needs to show and move past initial screens (like onboarding or login) before handling the deferred deep link.

Return `true`

Use this approach if you want the Adjust SDK to attempt to open the deferred deep link immediately after the callback code runs. For example, this approach is appropriate if your app does not have any initial screens.

When the Adjust SDK receives the deferred deep link, your callback code runs, and then the Adjust SDK calls application(_:open:options:) with the deferred deep link, which iOS then routes to the appropriate handler based on your app setup:

App Implementation	Handler
UIKit using AppDelegate	application(_:open:options:)
UIKit using SceneDelegate	scene(_:openURLContexts:)
SwiftUI	.onOpenURL modifier

To handle the deep link from the appropriate handler above, ensure that you have already implemented direct deep linking.

Full code example

This example shows how an app with an onboarding process handles deferred deep links. Here is a summary of the app’s internal flow:

The user opens the app, and deferred deep linking is applicable.
The app begins its onboarding process.
The app’s callback receives the deferred deep link from the Adjust SDK and then checks if onboarding is complete:
- If complete, it handles the deep link immediately.
- If not complete, it stores the deep link.
Once onboarding finishes, the app checks for and handles any stored deferred deep link.
The app navigates the user to the deep link screen.

AppDelegate

Deferred deep linking updates to AppDelegate are in the highlighted code. This example is applicable to both the UIKit and SwiftUI examples.

Swift
Objective-C

1
import AdjustSdk
2
import UIKit
3

4
@UIApplicationMain
5
class AppDelegate: UIResponder, UIApplicationDelegate, AdjustDelegate {
6
  func application(
7
    _ application: UIApplication,
8
    didFinishLaunchingWithOptions launchOptions:
9
      [UIApplication.LaunchOptionsKey: Any]?
10
  ) -> Bool {
11
    // Configure Adjust SDK
12
    // Replace {YourAppToken} with your Adjust app token
13
    let appToken = "{YourAppToken}"
14
    var adjustConfig: ADJConfig?
15

16
    // Enable verbose logging for deep link testing
17
    #if DEBUG
18
      let environment = ADJEnvironmentSandbox
19
      adjustConfig = ADJConfig(appToken: appToken, environment: environment)
20
      adjustConfig?.logLevel = ADJLogLevel.verbose
21
    #else
22
      let environment = ADJEnvironmentProduction
23
      adjustConfig = ADJConfig(
24
        appToken: appToken, environment: environment, suppressLogLevel: true)
25
      adjustConfig?.logLevel = ADJLogLevel.suppress
26
    #endif
27

28
    // Create delegate for deferred deep linking
29
    adjustConfig?.delegate = self
30

31
    // Initialize Adjust SDK
32
    Adjust.initSdk(adjustConfig)
33

34
    return true
35
  }
36

37
  // Receive deferred deep link via AdjustDelegate method
38
  func adjustDeferredDeeplinkReceived(_ deeplink: URL?) -> Bool {
39
    // Handle failure if deeplink is nil
40
    guard let deeplink = deeplink else { return false }
41

42
    if UserDefaults.standard.bool(forKey: "hasCompletedOnboarding") {
43
      // If onboarding is complete, handle deferred deep link immediately
44

45
      // deep link format:
46
      //
47
      // example://summer-clothes?promo=beach&adj_t=def456
48
      //
49
      // TODO: Handle the deep link and navigate to the appropriate screen.
50
    } else {
51
      // Store deferred deep link to invoke after onboarding screens and login
52
      UserDefaults.standard.set(
53
        deeplink.absoluteString, forKey: "deferredLink")
54
    }
55

56
    // The app controls when and how it handles the deferred deep link, so return false.
57
    return false
58
  }
59
}

1
#import <AdjustSdk/AdjustSdk.h>
2
#import "AppDelegate.h"
3

4
@implementation AppDelegate
5

6
- (BOOL)application:(UIApplication *)application
7
    didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
8
  // Configure Adjust SDK
9
  // Replace {YourAppToken} with your Adjust app token
10
  NSString *appToken = @"{YourAppToken}";
11
  ADJConfig *adjustConfig;
12

13
// Enable verbose logging for deep linking testing
14
#ifdef DEBUG
15
  adjustConfig = [ADJConfig configWithAppToken:appToken
16
                                   environment:ADJEnvironmentSandbox];
17
  [adjustConfig setLogLevel:ADJLogLevelVerbose];
18
#else
19
  adjustConfig = [ADJConfig configWithAppToken:appToken
20
                                   environment:ADJEnvironmentProduction
21
                         allowSuppressLogLevel:YES];
22
  [adjustConfig setLogLevel:ADJLogLevelSuppress];
23
#endif
24

25
  // Create delegate for deferred deep linking
26
  adjustConfig.delegate = self;
27

28
  // Initialize Adjust SDK
29
  [Adjust initSdk:adjustConfig];
30

31
  return YES;
32
}
33

34
// Receive deferred deep link via AdjustDelegate method
35
- (BOOL)adjustDeferredDeeplinkReceived:(nullable NSURL *)deeplink {
36
  // Handle failure if deeplink is nil
37
  if (!deeplink) return NO;
38

39
  if ([[NSUserDefaults standardUserDefaults]
40
          boolForKey:@"hasCompletedOnboarding"]) {
41
    // If onboarding is complete, handle deferred deep link immediately
42

43
    // deep link format:
44
    //
45
    // example://summer-clothes?promo=beach&adj_t=def456
46
    //
47
    // TODO: Handle the deep link and navigate to the appropriate screen.
48
  } else {
49
    // Store deferred deep link to invoke after onboarding screens and login
50
    [[NSUserDefaults standardUserDefaults] setObject:deeplink.absoluteString
51
                                              forKey:@"deferredLink"];
52
  }
53

54
  // The app controls when and how it handles the deferred deep link, so return NO.
55
  return NO;
56
}
57

58
@end
59

60
// AppDelegate.h
61

62
@interface AppDelegate : UIResponder <UIApplicationDelegate, AdjustDelegate>
63
@end

1
import AdjustSdk
2
import UIKit
3

4
class ViewController: UIViewController {
5
  var hasCompletedOnboarding: Bool {
6
    get {
7
      UserDefaults.standard.bool(forKey: "hasCompletedOnboarding")
8
    }
9
    set {
10
      UserDefaults.standard.set(newValue, forKey: "hasCompletedOnboarding")
11
    }
12
  }
13

14
  override func viewDidAppear(_ animated: Bool) {
15
    super.viewDidAppear(animated)
16

17
    // Check if onboarding has been completed
18
    if hasCompletedOnboarding {
19
      // Show main content
20
      return
21
    }
22

23
    // Show onboarding screens and login prompt
24

25
    // After onboarding, set hasCompletedOnboarding to true
26
    hasCompletedOnboarding = true
27

28
    // Show main content
29

30
    // Check for deferredLink received before or during onboarding
31
    if let deferredLink = UserDefaults.standard.string(forKey: "deferredLink") {
32
      // Remove stored deferred deep link to avoid handling again later
33
      UserDefaults.standard.removeObject(forKey: "deferredLink")
34

35
      // deep link format:
36
      //
37
      // example://summer-clothes?promo=beach&adj_t=def456
38
      //
39
      // TODO: Handle the deep link and navigate to the appropriate screen.
40
    }
41
  }
42
}

1
#import <AdjustSdk/AdjustSdk.h>
2
#import "ViewController.h"
3

4
@implementation ViewController
5

6
- (BOOL)hasCompletedOnboarding {
7
  return [[NSUserDefaults standardUserDefaults]
8
      boolForKey:@"hasCompletedOnboarding"];
9
}
10

11
- (void)setHasCompletedOnboarding:(BOOL)hasCompletedOnboarding {
12
  [[NSUserDefaults standardUserDefaults] setBool:hasCompletedOnboarding
13
                                          forKey:@"hasCompletedOnboarding"];
14
}
15

16
- (void)viewDidAppear:(BOOL)animated {
17
  [super viewDidAppear:animated];
18

19
  // Check if onboarding has been completed
20
  if (self.hasCompletedOnboarding) {
21
    // Show main content
22
    return;
23
  }
24

25
  // Show onboarding screens and login prompt
26

27
  // After onboarding, set hasCompletedOnboarding to YES
28
  self.hasCompletedOnboarding = YES;
29

30
  // Show main content
31

32
  // Check for deferred deep link received before or during onboarding
33
  NSString *deferredLink =
34
      [[NSUserDefaults standardUserDefaults] stringForKey:@"deferredLink"];
35
  if (deferredLink) {
36
    // Remove stored deferred deep link to avoid handling again later
37
    [[NSUserDefaults standardUserDefaults] removeObjectForKey:@"deferredLink"];
38

39
    // deep link format:
40
    //
41
    // example://summer-clothes?promo=beach&adj_t=def456
42
    //
43
    // TODO: Handle the deep link and navigate to the appropriate screen.
44
  }
45
}
46

47
@end

SwiftUI

Swift

1
import AdjustSdk
2
import SwiftUI
3

4
struct ContentView: View {
5
  var body: some View {
6
    NavigationStack {
7
      VStack {
8
        // Check if onboarding has been completed
9
        if !UserDefaults.standard.bool(forKey: "hasCompletedOnboarding") {
10
          // Show onboarding screens and login prompt
11

12
          // After onboarding, set hasCompletedOnboarding to true
13
          UserDefaults.standard.set(true, forKey: "hasCompletedOnboarding")
14

15
          // Show main content
16

17
          // Check for deep link received before or during onboarding
18
          if let deferredLink = UserDefaults.standard.string(
19
            forKey: "deferredLink")
20
          {
21
            // Remove stored deferred deep link to avoid handling again later
22
            UserDefaults.standard.removeObject(forKey: "deferredLink")
23

24
            // deep link format:
25
            //
26
            // example://summer-clothes?promo=beach&adj_t=def456
27
            //
28
            // TODO: Handle the deep link and navigate to the appropriate screen.
29
          }
30
        } else {
31
          // Show main content
32
        }
33
      }
34
    }
35
  }
36
}