Set up direct deep linking

You can configure deep linking in your app after you have set it up in the Adjust dashboard. Direct deep linking occurs when a user has your app installed on their device. The link takes the user to a specific page within your app.

To enable deep linking, you need to do the following:

Set up the same branded domain for your iOS and Android app in AppView in Adjust.
Enable Associated Domains for your app.
Configure your deep links in Xcode.

Enable Associated Domains

To get started, you need to enable Associated Domains in your Apple Developer account. This allows you to set universal link domains in your app. To do this, follow these steps:

Log in to your Apple Developer account.
Select Certificates, IDs & Profiles in the left-hand menu.
Select Identifiers in the left-hand menu.
Find your app and select it to open the edit page.
Ensure that Associated Domains is checked under Capabilities.
Select Save to save your changes.

Configure deep links in Xcode

Follow these steps to add your deep link configuration to your Xcode project.

Adjust universal links and branded domain

Open your app project in Xcode.
Select your project from the left-hand menu.
Select your app under Targets.
Select Signing & Capabilities from the top menu.
Ensure that All is selected in the submenu below.
Select the Add option (+) to add a capability.
Select Associated Domains.
Enter the Adjust Universal Link domain with the prefix applinks:
- Here is an example using the example.adj.st domain: applinks:example.adj.st.
Enter the branded link domain that you set up while setting up the branded domain for your app in Adjust.
- Here is an example using the brandedDomain.go.link domain: brandedDomain.go.link.

If you are already using xxx.adj.st as your universal link domain, do not remove it. Keep both xxx.adj.st and brandedDomain.go.link as the associated domains.

Custom URL scheme

Open your app project in Xcode.
Select your project from the left-hand menu.
Select your app under Targets.
Select Info from the top menu.
Expand the URL Types section.
Select the Add option (+) to add a URL type.
Fill in the following information to create a URL scheme:
- Identifier: $(PRODUCT_BUNDLE_IDENTIFIER)
- URL Schemes: Your custom URL scheme. This must be unique. Don’t use protected schemes such as http, https, or mailto.
- Role: Editor

This scheme will work for your production and debug builds.

Modify your iOS app

You need to update your iOS app to set up different deep linking scenarios. How you update your app depends on whether your app uses scenes.

App doesn’t use scenes

If your app doesn’t uses scenes, you need to update methods in your app delegate.

Universal links

Update the application(_:continue:restorationHandler:) method in your app delegate to call the following methods in the Adjust SDK:

ADJLinkResolution.resolveLink: Call this method only if your marketing team requires the use of Adjust’s Link Resolution solution. If the deep link uses a domain that matches an element in the resolveUrlSuffixArray, then the method attempts to resolve the deep link, and returns the resolved link. If the deep link doesn’t match an element in this array, then the method passes through the original deep link, so you can pass all deep links to this method.
Adjust.processDeeplink - Call this method to send deep links to Adjust’s servers to record information. You can pass both Adjust and non-Adjust deep links to this method. Adjust’s servers will ignore any deep links that don’t have Adjust parameters.

When a user clicks on your universal link, iOS opens your app and delivers the deep link to application(_:continue:restorationHandler:). This occurs whether the user has closed your app or has it running in the background.

Swift
Objective-C

1
func application(
2
    _ application: UIApplication,
3
    continue userActivity: NSUserActivity,
4
    restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void)
5
    -> Bool {
6

7
    if userActivity.activityType == NSUserActivityTypeBrowsingWeb {
8
        if let incomingURL = userActivity.webpageURL {
9
            // call the below method to resolve deep link
10
            ADJLinkResolution.resolveLink(
11
                with: incomingURL,
12
                resolveUrlSuffixArray: ["email.example.com", "short.example.com"],
13
                callback: { resolvedURL in
14
                    // add your code below to handle deep link
15
                    // (for example, open deep link content)
16
                    // resolvedURL object contains the deep link
17
                    if let resolvedDeeplink = resolvedURL {
18
                        // call the below method to send deep link to Adjust's servers
19
                        if let deeplink = ADJDeeplink(deeplink: resolvedDeeplink) {
20
                            Adjust.processDeeplink(deeplink)
21
                        }
22
                    }
23
                })
24
        }
25
      } else {
26
          return false
27
      }
28

29
      return true
30
}

1
- (BOOL)application:(UIApplication *)application
2
    continueUserActivity:(NSUserActivity *)userActivity
3
    restorationHandler:
4
    (void (^)(NSArray *restorableObjects))restorationHandler {
5

6
    if ([[userActivity activityType]
7
        isEqualToString:NSUserActivityTypeBrowsingWeb]) {
8
        NSURL *incomingURL = [userActivity webpageURL];
9

10
        // call the below method to resolve deep link
11
        [ADJLinkResolution
12
        resolveLinkWithUrl:incomingURL
13
        resolveUrlSuffixArray:@[
14
        @"email.example.com", @"short.example.com"
15
        ]
16
        callback:^(NSURL* _Nullable resolvedURL) {
17
            // add your code below to handle deep link
18
            // (for example, open deep link content)
19
            // resolvedURL object contains the deep link
20

21

22
            // call the below method to send deep link to Adjust's servers
23
            ADJDeeplink *deeplink = [[ADJDeeplink alloc] initWithDeeplink:resolvedURL];
24
            [Adjust processDeeplink:deeplink];
25
        }];
26
    } else {
27
        return NO;
28
    }
29

30
    return YES;
31
}

Custom URL scheme

If your marketing team requires you to set up custom URL scheme deep links, update the application(_:open:options:) method in your app delegate to call the Adjust.processDeeplink method in the Adjust SDK. This method sends deep links to Adjust’s servers to record them. You can pass both Adjust and non-Adjust deep links to this method. Adjust’s servers ignore any deep links that don’t have Adjust parameters.

When a user clicks on your custom URL scheme deep link, iOS opens your app and delivers the deep link to application(_:open:options:). This occurs whether the user has closed your app or has it running in the background.

Swift
Objective-C

1
func application(
2
    _ app: UIApplication,
3
    open incomingURL: URL,
4
    options: [UIApplication.OpenURLOptionsKey: Any] = [:]
5
    ) -> Bool {
6

7
    // add your code below to handle deep link
8
    // (for example, open deep link content)
9
    // incomingURL object contains the deep link
10

11

12
    // call the below method to send deep link to Adjust's servers
13
    if let deeplink = ADJDeeplink(deeplink: incomingURL) {
14
        Adjust.processDeeplink(deeplink)
15
    }
16
    return true
17
}

1
- (BOOL)application:(UIApplication *)app
2
    openURL:(NSURL *)incomingURL
3
    options:(NSDictionary *)options {
4

5
    // add your code below to handle deep link
6
    // (for example, open deep link content)
7
    // incomingURL object contains the deep link
8

9

10
    // call the below method to send deep link to Adjust's servers
11
    [Adjust processDeeplink:[[ADJDeeplink alloc] initWithDeeplink:incomingURL]];
12

13
    return YES;
14
}

App uses scenes

If your app uses scenes, you need to update methods in your scene delegate.

Universal links

Update the scene(_:willConnectTo:options:) method in your scene delegate. When a user clicks on your universal links and the user has your app closed, iOS opens your app and delivers the deep link to this method.
Update the scene(_:continue:) method in your scene delegate. When a user clicks on your universal links, and the user has your app running in the background, iOS opens your app and delivers the deep link to this method.

The above methods call the following methods in the Adjust SDK:

ADJLinkResolution.resolveLink: Call this method only if your marketing team requires the use of Adjust’s Link Resolution solution. If the deep link uses a domain that matches an element in the resolveUrlSuffixArray, then the method attempts to resolve the deep link, and returns the resolved link. If the deep link doesn’t match an element in this array, then the method passes through the original deep link, so you can pass all deep links to this method.
Adjust.processDeeplink - Call this method to send deep links to Adjust’s servers to record them. You can pass both Adjust and non-Adjust deep links to this method. Adjust’s servers ignore any deep links that don’t have Adjust parameters.

Swift
Objective-C

1
func scene(
2
    _ scene: UIScene,
3
    willConnectTo session: UISceneSession,
4
    options connectionOptions: UIScene.ConnectionOptions
5
    ) {
6

7
    guard let userActivity = connectionOptions.userActivities.first,
8
      userActivity.activityType == NSUserActivityTypeBrowsingWeb,
9
      let incomingURL = userActivity.webpageURL
10
    else { return }
11

12
    // call the below method to resolve deep link
13
    ADJLinkResolution.resolveLink(
14
      withUrl: incomingURL,
15
      resolveUrlSuffixArray: ["email.example.com", "short.example.com"],
16
      callback: { resolvedURL in
17
        // add your code below to handle deep link
18
        // (for example, open deep link content)
19
        // resolvedURL object contains the deep link
20

21

22
        // call the below method to send deep link to Adjust's servers
23
        if let deeplink = ADJDeeplink(deeplink: resolvedURL) {
24
            Adjust.processDeeplink(deeplink)
25
        }
26
      })
27
}
28

29
func scene(
30
    _ scene: UIScene,
31
    continue userActivity: NSUserActivity) {
32

33
    if userActivity.activityType == NSUserActivityTypeBrowsingWeb {
34
        let incomingURL = userActivity.webpageURL
35

36
        // call the below method to resolve deep link
37
        ADJLinkResolution.resolveLink(
38
        withUrl: incomingURL,
39
        resolveUrlSuffixArray: ["email.example.com", "short.example.com"],
40
        callback: { resolvedURL in
41
            // add your code below to handle deep link
42
            // (for example, open deep link content)
43
            // resolvedURL object contains the deep link
44

45

46
            // call the below method to send deep link to Adjust's servers
47
            if let deeplink = ADJDeeplink(deeplink: resolvedURL) {
48
                Adjust.processDeeplink(deeplink)
49
            }
50
        })
51
    }
52
}

1
- (void)scene:(UIScene *)scene willConnectToSession:(UISceneSession *)session
2
    options:(UISceneConnectionOptions *)connectionOptions {
3

4
    NSUserActivity* userActivity =
5
    [[[connectionOptions userActivities] allObjects] firstObject];
6

7
    if ([[userActivity activityType]
8
        isEqualToString:NSUserActivityTypeBrowsingWeb]) {
9
        NSURL *incomingURL = [userActivity webpageURL];
10

11
        // call the below method to resolve deep link
12
        [ADJLinkResolution
13
        resolveLinkWithUrl:incomingURL
14
        resolveUrlSuffixArray:@[
15
        @"email.example.com", @"short.example.com"
16
        ]
17
        callback:^(NSURL* _Nullable resolvedURL) {
18
            // add your code below to handle deep link
19
            // (for example, open deep link content)
20
            // resolvedURL object contains the deep link
21

22

23
            // call the below method to send deep link to Adjust's servers
24
            ADJDeeplink *deeplink = [[ADJDeeplink alloc] initWithDeeplink:resolvedURL];
25
            [Adjust processDeeplink:deeplink];
26
        }];
27
    }
28
}
29

30
- (void)scene:(UIScene *)scene continueUserActivity:(NSUserActivity *)userActivity{
31
    if ([[userActivity activityType]
32
        isEqualToString:NSUserActivityTypeBrowsingWeb]) {
33
        NSURL *incomingURL = [userActivity webpageURL];
34

35
        // call the below method to resolve deep link
36
        [ADJLinkResolution
37
        resolveLinkWithUrl:incomingURL
38
        resolveUrlSuffixArray:@[
39
        @"email.example.com", @"short.example.com"
40
        ]
41
        callback:^(NSURL* _Nullable resolvedURL) {
42
            // add your code below to handle deep link
43
            // (for example, open deep link content)
44
            // resolvedURL object contains the deep link
45

46

47
            // call the below method to send deep link to Adjust's servers
48
            ADJDeeplink *deeplink = [[ADJDeeplink alloc] initWithDeeplink:resolvedURL];
49
            [Adjust processDeeplink:deeplink];
50
        }];
51
    }
52
}

Custom URL scheme

Update the scene(_:willConnectTo:options:) method in your scene delegate. When a user clicks on your custom URL scheme deep link and the user has your app closed, iOS opens your app and delivers the deep link to this method.
Update the scene(_:openURLContexts:) method in your scene delegate. When a user clicks on your custom URL scheme deep link, and the user has your app running in the background, iOS opens your app and delivers the deep link to this method.

These methods call the Adjust.processDeeplink method in the Adjust SDK. This method sends deep links to Adjust’s servers to recordd them. You can pass both Adjust and non-Adjust deep links to this method. Adjust’s servers ignore any deep links that don’t have Adjust parameters.

Swift
Objective-C

1
func scene(
2
    _ scene: UIScene,
3
    openURLContexts URLContexts: Set<UIOpenURLContext>
4
    ) {
5

6
    guard let incomingURL = URLContexts.first?.url else {
7
        return
8
    }
9

10
    // add your code below to handle deep link
11
    // (for example, open deep link content)
12
    // incomingURL object contains the deep link
13

14

15
    // call the below method to send deep link to Adjust's servers
16
    if let deeplink = ADJDeeplink(deeplink: incomingURL) {
17
        Adjust.processDeeplink(deeplink)
18
    }
19
}

1
- (void)scene:(UIScene *)scene
2
    openURLContexts:(nonnull NSSet<UIOpenURLContext *> *)URLContexts {
3

4
    NSURL *incomingURL = [[URLContexts allObjects] firstObject].URL;
5

6
    if (incomingURL) {
7
        // add your code below to handle deep link
8
        // (for example, open deep link content)
9
        // incomingURL object contains the deep link
10

11

12
        // call the below method to send deep link to Adjust's servers
13
        ADJDeeplink *deeplink = [[ADJDeeplink alloc] initWithDeeplink:incomingURL];
14
        [Adjust processDeeplink:deeplink];
15
    }
16
}