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:

1. The user clicks on an Adjust deep link.
2. Adjust’s servers redirect the user to the app store.
3. The user installs or reinstalls your app and opens it.
4. The Adjust SDK sends an /attribution request to Adjust’s servers.
5. Adjust’s servers match the click to the install or reinstall and return the deferred deep link in the /attribution response. The Adjust SDK delivers the deferred deep link to your app via the deferred deep link callback.
6. If applicable, your app displays its initial screens, such as onboarding screens and user login.
7. 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 platform settings in the Adjust dashboard, before passing it to the Adjust SDK.

Setup

Set up a deferred deep link callback

1. Create an AdjustConfig object.
2. Set a deferred deep link callback on the AdjustConfig object. The Adjust SDK calls this callback after receiving a deferred deep link.
3. Set the launchDeferredDeeplink property to control whether the SDK opens the deep link automatically.
4. Initialize the SDK.

1
AdjustConfig adjustConfig = new AdjustConfig('{YourAppToken}', AdjustEnvironment.sandbox);
2
adjustConfig.deferredDeeplinkCallback = (String? uri) {
3
  /*
4
   * TODO: Handle the deep link
5
   * (for example, store it or handle it immediately)
6
   *
7
   * deep link format:
8
   *
9
   * example://summer-clothes?promo=beach&adj_t=def456
10
   */
11
};
12

13
adjustConfig.launchDeferredDeeplink = false; // or true based on your use case (see below)
14

15
Adjust.start(adjustConfig);

Deep link opening options

The launchDeferredDeeplink property determines what happens after your callback code executes:

Set to 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 setting this to 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.

Set to true (default)

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 opens the deep link URL using native OS methods (application(_:open:options:) on iOS, startActivity(Intent) on Android). The OS then delivers the link to your app_links uriLinkStream listener.

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:

1. The user opens the app for the first time.
2. The app begins its onboarding process.
3. 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.
4. Once onboarding finishes, the app checks for and handles any stored deferred deep link.
5. The app navigates the user to the deep link screen.

1
import 'package:adjust_sdk/adjust.dart';
2
import 'package:adjust_sdk/adjust_config.dart';
3
import 'package:flutter/foundation.dart';
4

5
String? _pendingDeeplink;
6

7
void initAdjust() {
8
  // Configure Adjust SDK
9
  // Replace {YourAppToken} with your Adjust app token
10
  const appToken = '{YourAppToken}';
11
  AdjustConfig? adjustConfig;
12

13
  // Enable verbose logging for deep link testing
14
  if (kDebugMode) {
15
    adjustConfig = AdjustConfig(appToken, AdjustEnvironment.sandbox);
16
    adjustConfig.logLevel = AdjustLogLevel.verbose;
17
  } else {
18
    adjustConfig = AdjustConfig(appToken, AdjustEnvironment.production);
19
    adjustConfig.logLevel = AdjustLogLevel.suppress;
20
  }
21

22
  // Disable automatic opening so we can handle it manually
23
  adjustConfig.launchDeferredDeeplink = false;
24

25
  // Set up deferred deep link callback
26
  adjustConfig.deferredDeeplinkCallback = (String? uri) {
27
    if (uri == null) return;
28

29
    if (hasCompletedOnboarding) {
30
      // If onboarding is complete, handle deferred deep link immediately
31

32
      // deep link format:
33
      //
34
      // example://summer-clothes?promo=beach&adj_t=def456
35
      //
36
      // TODO: Handle the deep link and navigate to the appropriate screen.
37
    } else {
38
      // Store deferred deep link to handle after onboarding
39
      _pendingDeeplink = uri;
40
    }
41
  };
42

43
  // Initialize Adjust SDK
44
  Adjust.start(adjustConfig);
45
}
46

47
// When onboarding completes:
48
void onOnboardingComplete() {
49
  if (_pendingDeeplink != null) {
50
    // deep link format:
51
    //
52
    // example://summer-clothes?promo=beach&adj_t=def456
53
    //
54
    // TODO: Handle the deep link and navigate to the appropriate screen.
55
    _pendingDeeplink = null;
56
  }
57
}