S2S developer guide

1
// Create dictionary for params to include on all S2S requests to Adjust
2
var params: [String: String] = [:]
3

4
// Hard-coded
5
params["s2s"] = "1"
6

7
// The name of the operating system running on the device
8
params["os_name"] = "ios"
9

10
// Replace with your Adjust app token
11
params["app_token"] = "4w565xzmb54d"

1
// Create dictionary for params to include on all S2S requests to Adjust
2
NSMutableDictionary *params = [NSMutableDictionary dictionary];
3

4
// Hard-coded
5
params[@"s2s"] = @"1";
6

7
// The name of the operating system running on the device
8
params[@"os_name"] = @"ios";
9

10
// Replace with your Adjust app token
11
params[@"app_token"] = @"4w565xzmb54d";

1
// Create map for params to include on all S2S requests to Adjust
2
val params = mutableMapOf<String, String>()
3

4
// Hard-coded
5
params["s2s"] = "1"
6

7
// The name of the operating system running on the device
8
params["os_name"] = "android"
9

10
// Replace with your Adjust app token
11
params["app_token"] = "4w565xzmb54d"

1
// Create map for params to include on all S2S requests to Adjust
2
Map<String, String> params = new HashMap<>();
3

4
// Hard-coded
5
params.put("s2s", "1");
6

7
// The name of the operating system running on the device
8
params.put("os_name", "android");
9

10
// Replace with your Adjust app token
11
params.put("app_token", "4w565xzmb54d");

1
import AppTrackingTransparency
2
import AdSupport
3

4
struct IDFAInfo {
5
    let idfa: UUID?
6
    let attStatus: ATTrackingManager.AuthorizationStatus?
7
    let trackingEnabled: Bool?
8
}
9

10
func getIDFAInfo(completion: @escaping (IDFAInfo) -> Void) {
11
    // For iOS 14.5+, show ATT prompt to attempt to retrieve IDFA and retrieve ATT
12
    // status afterwards
13
    if #available(iOS 14.5, *) {
14
        // Wait briefly to ensure app is active
15
        DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
16
            ATTrackingManager.requestTrackingAuthorization { status in
17
                let idfa = (status == .authorized) ?
18
                    ASIdentifierManager.shared().advertisingIdentifier : nil
19
                completion(IDFAInfo(idfa: idfa, attStatus: status,
20
                    trackingEnabled: nil))
21
            }
22
        }
23
    // For earlier versions, don't show ATT prompt. Just get IDFA and tracking
24
    // enabled status.
25
    } else {
26
        let manager = ASIdentifierManager.shared()
27
        let idfa = manager.isAdvertisingTrackingEnabled ?
28
            manager.advertisingIdentifier : nil
29
        let trackingEnabled = manager.isAdvertisingTrackingEnabled
30
        completion(IDFAInfo(idfa: idfa, attStatus: nil,
31
            trackingEnabled: trackingEnabled))
32
    }
33
}
34

35
// Usage example
36
getIDFAInfo { info in
37
    // Include IDFA if available
38
    if let idfa = info.idfa?.uuidString {
39
        params["idfa"] = idfa
40
    }
41

42
    // Include ATT status if available,
43
    // otherwise include tracking enabled status, never both
44
    if let attStatus = info.attStatus {
45
        params["att_status"] = String(attStatus.rawValue)
46
    } else if let trackingEnabled = info.trackingEnabled {
47
        params["tracking_enabled"] = trackingEnabled ? "1" : "0"
48
    }
49
}

1
#import <AppTrackingTransparency/AppTrackingTransparency.h>
2
#import <AdSupport/AdSupport.h>
3

4
@interface IDFAInfo : NSObject
5
@property (nonatomic, strong) NSUUID *idfa;
6
@property (nonatomic, assign) ATTrackingManagerAuthorizationStatus attStatus;
7
@property (nonatomic, strong) NSNumber *trackingEnabled;
8
@end
9

10
@implementation IDFAInfo
11
@end
12

13
void getIDFAInfo(void (^completion)(IDFAInfo *)) {
14
    // For iOS 14.5+, show ATT prompt to attempt to retrieve IDFA and retrieve ATT
15
    // status afterwards
16
    if (@available(iOS 14.5, *)) {
17
        // Wait briefly to ensure app is active
18
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC),
19
            dispatch_get_main_queue(), ^{
20
            [ATTrackingManager requestTrackingAuthorizationWithCompletionHandler:
21
                ^(ATTrackingManagerAuthorizationStatus status) {
22
                    IDFAInfo *info = [[IDFAInfo alloc] init];
23
                    if (status == ATTrackingManagerAuthorizationStatusAuthorized) {
24
                        info.idfa = [[ASIdentifierManager sharedManager]
25
                            advertisingIdentifier];
26
                    }
27
                    info.attStatus = status;
28
                    completion(info);
29
                }];
30
        });
31
    // For earlier versions, don't show ATT prompt. Just get IDFA and tracking
32
    // enabled status.
33
    } else {
34
        ASIdentifierManager *manager = [ASIdentifierManager sharedManager];
35
        IDFAInfo *info = [[IDFAInfo alloc] init];
36
        if (manager.isAdvertisingTrackingEnabled) {
37
            info.idfa = manager.advertisingIdentifier;
38
        }
39
        info.trackingEnabled = @(manager.isAdvertisingTrackingEnabled);
40
        completion(info);
41
    }
42
}
43

44
// Usage example
45
getIDFAInfo(^(IDFAInfo *info) {
46
    // Include IDFA if available
47
    if (info.idfa) {
48
        params[@"idfa"] = [info.idfa UUIDString];
49
    }
50

51
    // Include ATT status if available, otherwise tracking enabled status, never both
52
    if (info.attStatus != nil) {
53
        params[@"att_status"] = [NSString stringWithFormat:@"%ld",
54
            (long)info.attStatus];
55
    } else if (info.trackingEnabled != nil) {
56
        params[@"tracking_enabled"] = [info.trackingEnabled boolValue] ?
57
            @"1" : @"0";
58
    }
59
});

1
import AdSupport
2

3
struct TrackingInfo {
4
    let attStatus: ATTrackingManager.AuthorizationStatus?
5
    let trackingEnabled: Bool?
6
}
7

8
func getTrackingInfo(completion: @escaping (TrackingInfo) -> Void) {
9
    // For iOS 14.5+, get ATT status without showing prompt
10
    if #available(iOS 14.5, *) {
11
        let status = ATTrackingManager.trackingAuthorizationStatus
12
        completion(TrackingInfo(attStatus: status, trackingEnabled: nil))
13
    // For earlier versions, get tracking enabled status
14
    } else {
15
        let trackingEnabled = ASIdentifierManager.shared().isAdvertisingTrackingEnabled
16
        completion(TrackingInfo(attStatus: nil, trackingEnabled: trackingEnabled))
17
    }
18
}
19

20
// Usage example
21
getTrackingInfo { info in
22
    // Include ATT status if available, otherwise tracking enabled status, never both
23
    if let attStatus = info.attStatus {
24
        params["att_status"] = String(attStatus.rawValue)
25
    } else if let trackingEnabled = info.trackingEnabled {
26
        params["tracking_enabled"] = trackingEnabled ? "1" : "0"
27
    }
28
}

1
#import <AdSupport/AdSupport.h>
2

3
@interface TrackingInfo : NSObject
4
@property (nonatomic, assign) ATTrackingManagerAuthorizationStatus attStatus;
5
@property (nonatomic, strong) NSNumber *trackingEnabled;
6
@end
7

8
@implementation TrackingInfo
9
@end
10

11
void getTrackingInfo(void (^completion)(TrackingInfo *)) {
12
    // For iOS 14.5+, get ATT status without showing prompt
13
    if (@available(iOS 14.5, *)) {
14
        TrackingInfo *info = [[TrackingInfo alloc] init];
15
        info.attStatus = ATTrackingManager.trackingAuthorizationStatus;
16
        completion(info);
17
    // For earlier versions, get tracking enabled status
18
    } else {
19
        TrackingInfo *info = [[TrackingInfo alloc] init];
20
        BOOL enabled = [ASIdentifierManager sharedManager].isAdvertisingTrackingEnabled;
21
        info.trackingEnabled = @(enabled);
22
        completion(info);
23
    }
24
}
25

26
// Usage example
27
getTrackingInfo(^(TrackingInfo *info) {
28
    // Include ATT status if available, otherwise tracking enabled status, never both
29
    if (info.attStatus != nil) {
30
        params[@"att_status"] = [NSString stringWithFormat:@"%ld",
31
            (long)info.attStatus];
32
    } else if (info.trackingEnabled != nil) {
33
        params[@"tracking_enabled"] = [info.trackingEnabled boolValue] ?
34
            @"1" : @"0";
35
    }
36
});

1
let idfv: UUID? = UIDevice.current.identifierForVendor
2

3
if let idfvString = idfv?.uuidString {
4
   params["idfv"] = idfvString
5
}

1
NSUUID *idfv = [[UIDevice currentDevice] identifierForVendor];
2

3
if (idfv) {
4
    params[@"idfv"] = [idfv UUIDString];
5
}

1
import Foundation
2
import Security
3

4
// App's bundle ID
5
let bundleId = "com.example.app"
6

7
// Collect the primary dedupe token from the keychain
8
func getPrimaryDedupeToken(bundleId: String) -> UUID? {
9
    // Define the query to search for the token in the keychain
10
    let query: [String: Any] = [
11
        kSecClass as String: kSecClassGenericPassword,
12
        kSecAttrAccount as String: "primary_dedupe_token",
13
        kSecAttrService as String: bundleId,
14
        kSecReturnData as String: true
15
    ]
16

17
    var item: CFTypeRef?
18
    // Attempt to fetch the token from the keychain
19
    let status = SecItemCopyMatching(query as CFDictionary, &item)
20

21
    // If the fetch was successful, convert the result to a UUID
22
    guard status == errSecSuccess,
23
          let existingItem = item as? Data,
24
          let uuidString = String(data: existingItem, encoding: .utf8),
25
          let token = UUID(uuidString: uuidString) else {
26
        // Return nil if the token doesn't exist or couldn't be collected
27
        return nil
28
    }
29

30
    return token
31
}
32

33
// Save the primary dedupe token to the keychain
34
func setPrimaryDedupeToken(_ token: UUID, bundleId: String) -> Bool {
35
    let tokenData = token.uuidString.data(using: .utf8)!
36
    // Define the attributes for storing the token in the keychain
37
    let query: [String: Any] = [
38
        kSecClass as String: kSecClassGenericPassword,
39
        kSecAttrAccount as String: "primary_dedupe_token",
40
        kSecAttrService as String: bundleId,
41
        kSecValueData as String: tokenData,
42
        kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlock
43
    ]
44

45
    // Attempt to add the token to the keychain
46
    let status = SecItemAdd(query as CFDictionary, nil)
47

48
    // Return true if the token was successfully added, false otherwise
49
    return status == errSecSuccess
50
}
51

52
// Collect the existing primary dedupe token or create a new one if it doesn't exist
53
func getOrCreatePrimaryDedupeToken() -> UUID {
54
    // Try to collect an existing token
55
    if let existingToken = getPrimaryDedupeToken(bundleId: bundleId) {
56
        return existingToken
57
    } else {
58
        // If no token exists, generate a new one
59
        let newToken = UUID()
60
        // Attempt to save the new token
61
        if setPrimaryDedupeToken(newToken, bundleId: bundleId) {
62
            return newToken
63
        } else {
64
            // If saving fails, throw a fatal error
65
            fatalError("Failed to save primary dedupe token")
66
        }
67
    }
68
}
69

70
// Usage example
71
let primaryDedupeToken = getOrCreatePrimaryDedupeToken()
72

73
// Convert to lowercase string
74
params["primary_dedupe_token"] = primaryDedupeToken.uuidString.lowercased()

1
#import <Foundation/Foundation.h>
2
#import <Security/Security.h>
3

4
// App's bundle ID
5
NSString *const bundleId = @"com.example.app";
6

7
// Collect the primary dedupe token from the keychain
8
NSUUID *getPrimaryDedupeToken(NSString *bundleId) {
9
    // Define the query to search for the token in the keychain
10
    NSDictionary *query = @{
11
        (__bridge id)kSecClass: (__bridge id)kSecClassGenericPassword,
12
        (__bridge id)kSecAttrAccount: @"primary_dedupe_token",
13
        (__bridge id)kSecAttrService: bundleId,
14
        (__bridge id)kSecReturnData: @YES
15
    };
16

17
    CFTypeRef item = NULL;
18
    // Attempt to fetch the token from the keychain
19
    OSStatus status = SecItemCopyMatching((__bridge CFDictionaryRef)query,
20
        &item);
21

22
    // If the fetch was successful, convert the result to a UUID
23
    if (status == errSecSuccess && item != NULL) {
24
        NSData *existingItem = (__bridge_transfer NSData *)item;
25
        NSString *uuidString = [[NSString alloc]
26
            initWithData:existingItem encoding:NSUTF8StringEncoding];
27
        return [[NSUUID alloc] initWithUUIDString:uuidString];
28
    }
29

30
    // Return nil if the token doesn't exist or couldn't be collected
31
    return nil;
32
}
33

34
// Save the primary dedupe token to the keychain
35
BOOL setPrimaryDedupeToken(NSUUID *token, NSString *bundleId) {
36
    NSData *tokenData = [[token UUIDString]
37
        dataUsingEncoding:NSUTF8StringEncoding];
38
    // Define the attributes for storing the token in the keychain
39
    NSDictionary *query = @{
40
        (__bridge id)kSecClass: (__bridge id)kSecClassGenericPassword,
41
        (__bridge id)kSecAttrAccount: @"primary_dedupe_token",
42
        (__bridge id)kSecAttrService: bundleId,
43
        (__bridge id)kSecValueData: tokenData,
44
        (__bridge id)kSecAttrAccessible:
45
            (__bridge id)kSecAttrAccessibleAfterFirstUnlock
46
    };
47

48
    // Attempt to add the token to the keychain
49
    OSStatus status = SecItemAdd((__bridge CFDictionaryRef)query, NULL);
50
    // Return YES if the token was successfully added, NO otherwise
51
    return status == errSecSuccess;
52
}
53

54
// Collect the existing primary dedupe token or create a new one if it doesn't exist
55
NSUUID *getOrCreatePrimaryDedupeToken(void) {
56
    // Try to collect an existing token
57
    NSUUID *existingToken = getPrimaryDedupeToken(bundleId);
58
    if (existingToken) {
59
        return existingToken;
60
    } else {
61
        // If no token exists, generate a new one
62
        NSUUID *newToken = [NSUUID UUID];
63
        // Attempt to save the new token
64
        if (setPrimaryDedupeToken(newToken, bundleId)) {
65
            return newToken;
66
        } else {
67
            // If saving fails, throw an exception
68
            @throw [NSException exceptionWithName:@"TokenSaveError"
69
                reason:@"Failed to save primary dedupe token"
70
                userInfo:nil];
71
        }
72
    }
73
}
74

75
// Usage example
76
NSUUID *primaryDedupeToken = getOrCreatePrimaryDedupeToken();
77

78
// Convert to lowercase string
79
params[@"primary_dedupe_token"] = [[primaryDedupeToken UUIDString]
80
    lowercaseString];

1
import com.google.android.gms.ads.identifier.AdvertisingIdClient
2
import kotlinx.coroutines.Dispatchers
3
import kotlinx.coroutines.withContext
4

5
suspend fun getGoogleAdvertisingIdInfo(
6
   context: Context): AdvertisingIdClient.Info? {
7
   return withContext(Dispatchers.IO) {
8
      try {
9
          AdvertisingIdClient.getAdvertisingIdInfo(context)
10
      } catch (e: Exception) {
11
          // Handle exceptions
12
          // (for example: Google Play Services not available)
13
          null
14
      }
15
   }
16
}
17

18
// Usage example
19
// As getGoogleAdvertisingIdInfo is a suspending function,
20
// it should be called from within a coroutine scope.
21
lifecycleScope.launch {
22
   val adInfo = getGoogleAdvertisingIdInfo(context)
23
   adInfo?.let { info ->
24
      // Include Google Advertising ID if tracking is not limited
25
      if (!info.isLimitAdTrackingEnabled) {
26
          params["gps_adid"] = info.id
27
      }
28
      // Set tracking status
29
      params["tracking_enabled"] = if (info.isLimitAdTrackingEnabled)
30
          "0" else "1"
31
   }
32
}

1
import com.google.android.gms.appset.AppSet
2
import com.google.android.gms.appset.AppSetIdClient
3
import com.google.android.gms.appset.AppSetIdInfo
4
import com.google.android.gms.tasks.Tasks
5
import kotlinx.coroutines.Dispatchers
6
import kotlinx.coroutines.withContext
7

8
suspend fun getAppSetId(context: Context): String? {
9
   return withContext(Dispatchers.IO) {
10
      try {
11
            val client: AppSetIdClient = AppSet.getClient(context)
12
            val taskResult = Tasks.await(client.appSetIdInfo)
13
            taskResult.id
14
      } catch (e: Exception) {
15
            // Handle exceptions (for example: Google Play Services not available)
16
            null
17
      }
18
   }
19
}
20

21
// Usage example
22
// As getAppSetId is a suspending function,
23
// it should be called from within a coroutine scope.
24
lifecycleScope.launch {
25
   val appSetId = getAppSetId(context)
26
   appSetId?.let { id ->
27
      val params = mutableMapOf<String, String>()
28
      params["google_app_set_id"] = id
29
   }
30
}

1
// Unix timestamp of when activity occurred on device
2
// Code example shows how to retrieve current time in seconds
3
// Example value: "1484085154"
4
params["created_at_unix"] = String(Int(Date().timeIntervalSince1970))

1
// Unix timestamp of when activity occurred on device
2
// Code example shows how to retrieve current time in seconds
3
// Example value: "1484085154"
4
params["created_at_unix"] = (System.currentTimeMillis() / 1000).toString()

1
import UIKit
2

3
// Device name
4
// Example value: "iPhone10,5"
5
var systemInfo = utsname()
6
uname(&systemInfo)
7
let machineMirror = Mirror(reflecting: systemInfo.machine)
8
let deviceName = machineMirror.children.reduce("") {
9
    identifier, element in
10
    guard let value = element.value as? Int8, value != 0
11
    else { return identifier }
12
    return identifier + String(UnicodeScalar(UInt8(value)))
13
}
14
params["device_name"] = deviceName
15

16
// Device type
17
// Example value: "iPhone"
18
params["device_type"] = UIDevice.current.model
19

20
// OS version
21
// Example value: "17.5.1"
22
params["os_version"] = UIDevice.current.systemVersion
23

24
// IP address
25
// Retrieve the device's IP address from requests to your server
26
params["ip_address"] = "192.0.0.1"  // Example value

1
import android.content.Context
2
import android.content.res.Configuration
3
import android.os.Build
4
import android.content.pm.PackageManager
5

6
// Usage example
7
val context: Context = // ... get your context here ...
8

9
val isGooglePlayGamesForPC = context.packageManager
10
    .hasSystemFeature("com.google.android.play.feature
11
    .HPE_EXPERIENCE")
12

13
// Device name
14
params["device_name"] = if (isGooglePlayGamesForPC) null
15
    else Build.MODEL
16

17
// OS version
18
params["os_version"] = if (isGooglePlayGamesForPC) null
19
    else Build.VERSION.RELEASE
20

21
// Device type
22
params["device_type"] = when {
23
    isGooglePlayGamesForPC -> "pc"
24
    (context.resources.configuration.uiMode and
25
    Configuration.UI_MODE_TYPE_MASK) == Configuration
26
    .UI_MODE_TYPE_TELEVISION -> "tv"
27
    else -> when (context.resources.configuration.screenLayout
28
        and Configuration.SCREENLAYOUT_SIZE_MASK) {
29
        Configuration.SCREENLAYOUT_SIZE_SMALL,
30
        Configuration.SCREENLAYOUT_SIZE_NORMAL -> "phone"
31
        Configuration.SCREENLAYOUT_SIZE_LARGE,
32
        Configuration.SCREENLAYOUT_SIZE_XLARGE -> "tablet"
33
        else -> null
34
    }
35
}
36

37
// IP address
38
// Retrieve the device's IP address from requests to
39
// your server
40
params["ip_address"] = "192.0.0.1"  // Example value

1
// For testing (sandbox environment)
2
params["environment"] = "sandbox"
3

4
// For production use
5
params["environment"] = "production"

1
// For testing (sandbox environment)
2
params["environment"] = "sandbox"
3

4
// For production use
5
params["environment"] = "production"

1
params["callback_params"] = '{"user_id": "2696775149", "user_category": "high value"}'

1
params["callback_params"] = '{"user_id": "2696775149", "user_category": "high value"}'

1
params["partner_params"] = '{"analytics_user_id": "3913132433", "analytics_visitor_id": "nzFC9LKSqM"}'

1
params["partner_params"] = '{"analytics_user_id": "3913132433", "analytics_visitor_id": "nzFC9LKSqM"}'

1
// Add event token to existing params
2
params["event_token"] = "2y7e81"
3

4
// Add revenue and currency, if applicable
5
// These parameters are equivalent to $19.99
6
params["revenue"] = "19.99"
7
params["currency"] = "USD"

1
// Add event token to existing params
2
params["event_token"] = "2y7e81"
3

4
// Add revenue and currency, if applicable
5
// These parameters are equivalent to $19.99
6
params["revenue"] = "19.99"
7
params["currency"] = "USD"

1
// If callback_params exists, add the event callback parameters to it (for example: txn_id)
2
params["callback_params"] = '{"user_id": "2696775149", "user_category": "high value", "txn_id": "8837853376"}'
3

4
// If callback_params does not exist, create it
5
params["callback_params"] = '{"txn_id": "8837853376"}'

1
// If callback_params exists, add the event callback parameters to it (for example: txn_id)
2
params["callback_params"] = '{"user_id": "2696775149", "user_category": "high value", "txn_id": "8837853376"}'
3

4
// If callback_params does not exist, create it
5
params["callback_params"] = '{"txn_id": "8837853376"}'

1
// If partner_params exists, add the event partner parameters to it (for example: item_id)
2
params["partner_params"] = '{"analytics_user_id": "3913132433", "analytics_session_id": "nzFC9LKSqM", "item_id": "[\"76524\",\"62599\"]"}'
3

4
// If partner_params does not exist, create it
5
params["partner_params"] = '{"item_id": "[\"76524\",\"62599\"]"}'

1
// If partner_params exists, add the event partner parameters to it (for example: item_id)
2
params["partner_params"] = '{"analytics_user_id": "3913132433", "analytics_session_id": "nzFC9LKSqM", "item_id": "[\"76524\",\"62599\"]"}'
3

4
// If partner_params does not exist, create it
5
params["partner_params"] = '{"item_id": "[\"76524\",\"62599\"]"}'