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 your app and opens it.
Adjust’s servers perform attribution and send the deep link to the Adjust SDK.
If applicable, your app displays its initial screens, such as onboarding screens and user login.
The Adjust SDK delivers the deferred deep link to your app. Your app then handles this link to direct the user to the appropriate screen. (The exact mechanism for this step depends on your setup, as described below.)

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 SDK.

As a result, you should configure your app to handle Adjust branded links and app scheme deep links in the same way. For example, both of the following links should open the same screen:

Adjust branded link: https://brandname.go.link/summer-clothes?promo=beach
App scheme deep link: example://summer-clothes?promo=beach

Your app has to handle the deferred deep link by parsing its components (example: path, query parameters) and navigating to the appropriate screen.

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.appDidLaunch(adjustConfig)

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

5
// ...
6

7
[Adjust appDidLaunch:adjustConfig];

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

Swift
Objective-C

1
func adjustDeeplinkResponse(_ deeplink: URL?) -> Bool {
2
   // TODO: Handle deeplink
3
   // (for example, store deep link or handle it immediately)
4

5
   return false // or true based on your use case (see below)
6
}

1
- (BOOL)adjustDeeplinkResponse:(NSURL *)deeplink {
2
      // TODO: Handle deeplink
3
      // (for example, store deep link or handle it immediately)
4

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

Return Value Options

The return value of adjustDeeplinkResponse 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 an app that has an onboarding process that has to complete before the app can handle deferred deep links. Here is a summary of how the example code works.

A user who doesn’t have the app installed clicks an Adjust deep link, which redirects them to the app store.
The user installs and opens the app.
The Adjust SDK sends session and attribution requests to Adjust’s servers.
The app begins its onboarding process.
Adjust’s servers respond with attribution data, including the deep link the user clicked on (“deferred deep link”).
The Adjust SDK triggers a deferred deep link callback in the app (shown in AppDelegate below). The callback checks whether onboarding is complete:
- If onboarding is complete, it handles the deep link immediately.
- If onboarding isn’t complete, it stores the deep link.
Once onboarding completes, the app checks for and handles any stored deferred deep link (shown in the ViewController and ContentView examples below).
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.appDidLaunch(adjustConfig)
33

34
    return true
35
  }
36

37
  // Receive deferred deep link via AdjustDelegate method
38
  func adjustDeeplinkResponse(_ 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
      // TODO: Handle the deferred deep link by parsing its components
46
      // (example: path, query parameters) and
47
      // navigating to the appropriate screen.
48
    } else {
49
      // Store deferred deep link to invoke after onboarding screens and login
50
      UserDefaults.standard.set(
51
        deeplink.absoluteString, forKey: "deferredLink")
52
    }
53

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

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 appDidLaunch:adjustConfig];
30

31
  return YES;
32
}
33

34
// Receive deferred deep link via AdjustDelegate method
35
- (BOOL)adjustDeeplinkResponse:(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
    // TODO: Handle the deferred deep link by parsing its components
44
    // (example: path, query parameters) and
45
    // navigating to the appropriate screen.
46
  } else {
47
    // Store deferred deep link to invoke after onboarding screens and login
48
    [[NSUserDefaults standardUserDefaults] setObject:deeplink.absoluteString
49
                                              forKey:@"deferredLink"];
50
  }
51

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

56
@end
57

58
// AppDelegate.h
59

60
@interface AppDelegate : UIResponder <UIApplicationDelegate, AdjustDelegate>
61
@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
      // TODO: Handle deferredLink by parsing its components
36
      // (example: path, query parameters) and
37
      // navigating to the appropriate screen.
38
    }
39
  }
40
}

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
    // TODO: Handle deferredLink by parsing its components
40
    // (example: path, query parameters) and
41
    // navigating to the appropriate screen.
42
  }
43
}
44

45
@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
            // TODO: Handle deferredLink by parsing its components
25
            // (example: path, query parameters) and
26
            // navigating to the appropriate screen.
27
          }
28
        } else {
29
          // Show main content
30
        }
31
      }
32
    }
33
  }
34
}