iOS SDK V6.X integration guide for developers

This SDK uses the following native frameworks:

AdSupport.framework

This framework is required to collect the IDFA from devices.
Without IDFA you cannot attribute installs to Facebook Ads, Twitter, Google ads and other networks.

iAd.framework

This framework is required to record and measure the performance of Apple Search Ads in your app.

If you want to remove these frameworks and disable IDFA collection:

1. To disable IDFA collection, see the instructions here.
2. To disable iAd.framework, see the instructions here.

To add ad support frameworks:

1. In your Xcode project, select project target.
2. Select the General tab for your target.
3. Expand the Linked Frameworks and Libraries section.
4. Click + to add a framework.
5. Search for AdSupport.framework
6. Select AdSupport.framework from the list.

Repeat the process for iAd.framework.

AppsFlyer uses the dev key to uniquely identify your account. The dev key is mandatory because it allows the SDK to securely send and retrieve data that belongs to your AppsFlyer account.

To do:

1. Go to your app dashboard.
2. In the dashboard, under Configuration click App Settings.
3. Copy your dev key.
   
   

   

SKAdNetwork is a class used by iOS that validates advertiser-driven app installations. The app install validation process involves the source app and the advertised app. 

A source app is an app that participates in ad campaigns by displaying ads signed by an ad network. Configuring your app to display ads is not within the scope of the AppsFlyer SDK. To configure, follow the Apple instructions.

For the advertised app (the app with the AppsFlyer SDK), the AppsFlyer SKAdNetwork Solution uses SKAdNetwork to provide the attribution postback while AppsFlyer collects, translates, and aggregates the data, while maintaining user privacy. On launching the app for the first time, the AppsFlyer platform, using the configuration set by the marketer, instructs the SDK how to set the SKAdNetwork conversion value.

To use the SKAdNetwork Solution:

• The developer does nothing.
• AppsFlyer SDK automatically calls the necessary SKAdNetwork APIs, meaning registerAppForAdNetworkAttribution() and updateConversionValue(). The developer must not call them. 
• Don't allow other SDKs to call SKAdNet APIs. Doing so can delay iOS in sending the postback to AppsFlyer and change the conversion value which we use to calculate SKAdNetwork dashboard user quality metrics. 
• The marketer needs to configure SKAdNetwork measurement in AppsFlyer. 

No action or registration process required in the app store by either the developer or the marketer. 

In order to support deep linking, which starts with directing users to the default scene of the app, add the following code to SceneDelegate for the default scene you want users to deep link into.

1. Importing the library

#import <AppsFlyerLib/AppsFlyerLib.h>

import AppsFlyerLib

2. Adding implementation

#import "SceneDelegate.h"

@interface SceneDelegate ()

@end

@implementation SceneDelegate 

- (void)scene:(UIScene *)scene openURLContexts:(NSSet<UIOpenURLContext *> *)URLContexts API_AVAILABLE(ios(13.0)){
    NSURL* url = [[URLContexts allObjects] objectAtIndex:0].URL;
    if(url){
        [[AppsFlyerLib shared] handleOpenUrl:url options:nil];
    }
}

- (void)scene:(UIScene *)scene continueUserActivity:(NSUserActivity *)userActivity  API_AVAILABLE(ios(13.0)){
    [[AppsFlyerLib shared]continueUserActivity:userActivity restorationHandler:nil];
}

- (void)scene:(UIScene *)scene willConnectToSession:(UISceneSession *)session options:(UISceneConnectionOptions *)connectionOptions {
    // Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
    // If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
    // This delegate does not imply the connecting scene or session are new (see `application:configurationForConnectingSceneSession` instead).
    NSUserActivity *activity = [[connectionOptions userActivities] allObjects].firstObject;
    if (activity) {
        [self scene:scene continueUserActivity:activity];
    }
    [self scene:scene openURLContexts: [connectionOptions URLContexts]];
}


- (void)sceneDidDisconnect:(UIScene *)scene  API_AVAILABLE(ios(13.0)){
    // Called as the scene is being released by the system.
    // This occurs shortly after the scene enters the background, or when its session is discarded.
    // Release any resources associated with this scene that can be re-created the next time the scene connects.
    // The scene may re-connect later, as its session was not neccessarily discarded (see `application:didDiscardSceneSessions` instead).
}


- (void)sceneDidBecomeActive:(UIScene *)scene  API_AVAILABLE(ios(13.0)){
    // Called when the scene has moved from an inactive state to an active state.
    // Use this method to restart any tasks that were paused (or not yet started) when the scene was inactive.
}


- (void)sceneWillResignActive:(UIScene *)scene  API_AVAILABLE(ios(13.0)){
    // Called when the scene will move from an active state to an inactive state.
    // This may occur due to temporary interruptions (ex. an incoming phone call).
}


- (void)sceneWillEnterForeground:(UIScene *)scene  API_AVAILABLE(ios(13.0)){
    // Called as the scene transitions from the background to the foreground.
    // Use this method to undo the changes made on entering the background.
}


- (void)sceneDidEnterBackground:(UIScene *)scene  API_AVAILABLE(ios(13.0)){
    // Called as the scene transitions from the foreground to the background.
    // Use this method to save data, release shared resources, and store enough scene-specific state information
    // to restore the scene back to its current state.
}


@end

import UIKit
import AppsFlyerLib

@available(iOS 13.0, *)
class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?
 
 func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        // Processing Universal Link from the killed state
        if let userActivity = connectionOptions.userActivities.first {
          self.scene(scene, continue: userActivity)
        }
     // Processing URI-scheme from the killed state
          self.scene(scene, openURLContexts: connectionOptions.urlContexts)
          
          guard let _ = (scene as? UIWindowScene) else { return }
    }
    
    func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
        AppsFlyerLib.shared().continue(userActivity, restorationHandler: nil)
    }
    
    func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
        if let url = URLContexts.first?.url {
            AppsFlyerLib.shared().handleOpen(url, options: nil) 
        }
    }


    func sceneDidDisconnect(_ scene: UIScene) {
        // Called as the scene is being released by the system.
        // This occurs shortly after the scene enters the background, or when its session is discarded.
        // Release any resources associated with this scene that can be re-created the next time the scene connects.
        // The scene may re-connect later, as its session was not neccessarily discarded (see `application:didDiscardSceneSessions` instead).
    }

    func sceneDidBecomeActive(_ scene: UIScene) {
        // Called when the scene has moved from an inactive state to an active state.
        // Use this method to restart any tasks that were paused (or not yet started) when the scene was inactive.
        
    }

    func sceneWillResignActive(_ scene: UIScene) {
        // Called when the scene will move from an active state to an inactive state.
        // This may occur due to temporary interruptions (ex. an incoming phone call).
    }

    func sceneWillEnterForeground(_ scene: UIScene) {
        // Called as the scene transitions from the background to the foreground.
        // Use this method to undo the changes made on entering the background.
    }

    func sceneDidEnterBackground(_ scene: UIScene) {
        // Called as the scene transitions from the foreground to the background.
        // Use this method to save data, release shared resources, and store enough scene-specific state information
        // to restore the scene back to its current state.
    }
}

You may want to delay initializing the SDK and sending data until the user gives consent (for example, GDPR or COPPA consent).

Note: This is unrelated to ATT introduced in iOS 14. 

To delay initializing the SDK:

1. Prevent the session from being sent on background-foreground transition. In a sendLaunch() method (that is called on every applicationDidBecomeActive (as per section 3.3), wrap call to start with a condition check. For example:
   
   

   -(void)sendLaunch:(UIApplication *)application {
       if (consent_given) { // check the condition
           [[AppsFlyerLib shared] start]; // Start
       }
   }

2. Send the session as soon as the reason for delaying is no longer relevant (right after condition changes). Call start when you are ready to send first session data. For example:
   
   

   ...
   consent_given = YES; // change the condition
   [[AppsFlyerLib shared] start]; // Start
   ...

Before you start testing installs:

• Make sure your device does not have the app installed.
• Allowlist the device you are going to test on.

Organic installs are unattributed installs which are usually direct installs from app stores.

To simulate an organic install:

1. Make sure you have a mobile device connected to your computer.
2. In Xcode, open the debug terminal.
3. From Xcode Studio, install the app on the device or simulator.
4. Wait for the app to launch.
5. In the debug terminal, look for the app package name.

You should see the following:

Send start() in the log indicates that the SDK reports an install. This data comes from the onConversionDataSuccess method in app delegate. Getting conversion data is discussed later in this guide.

Note: Starting SDK V5, onConversionDataSuccess is the name of the method for getting conversion data. If you are using an SDK version lower than 5.0.0, the name of the method is onConversionDataReceived. We recommend that you upgrade to SDK 5.0.0. To learn more, click here.

An organic install should now appear on the Overview page of the app dashboard.

If you don't see an install in the app dashboard, see SDK troubleshooting guide.

A non-organic install is an attributed install that usually follows an ad engagement. You can simulate a non-organic install by using attribution links.

To do:

1. Find out what is the itunes ID name of your app e.g. id123456789.
2. In the URL below, replace <APP_ID> with your app's itunes ID:
   

   https://app.appsflyer.com/<APP_ID>?pid=sdk_test&c=sdk_test
   

   The pid parameter represents the media source name. The c parameter represents the campaign name.
3. Send this URL to the device (e.g. via email or WhatsApp).
4. On the device, click on the URL.
   • If the app is listed in the app store, you are redirected to the app store. Don't download the app from the app store. Proceed to step 5.
   • If the app is not listed in the app store and is still in development, the screen shows a message that the app is not available in the app store. Simply proceed to step 5.
5. In Xcode Studio, open the debug terminal.
6. Connect the device to your computer using a USB cable.
7. From Xcode, Install the app on the device.
8. In the debug terminal, look for your app's itunes ID.

You should see the following:

A non-organic install should now appear in the Overview page of the app dashboard.

The SDK contains two types of constants that represent in-app event related info.

• Event names - these constants come in the format AFEventEventName.
  For example AFEventPurchase, AFEventAddToCart.
• Event parameters - These constants come in the format AFEventParameterParameterName.
  For example AFEventParameterRevenue, AFEventParamaterContentId.

We strongly recommend using these constants for the following reasons:

• The standard naming allows AppsFlyer to automatically map events to SRNs such as Facebook, Google, Twitter, and Snapchat.
• Backward compatibility - if AppsFlyer decides to change the name of any event or event parameter, your implementation is backward compatible.

To use these two interfaces, import AppsFlyerLib.h if using Objective-C, or AppsFlyerLib if using Swift:

#import AppsFlyerLib.h

import AppsFlyerLib

Here is the list of recommended event names and structures.

You can send revenue with any in-app event. Use the af_revenue (AFEventParameterRevenue) event parameter to include revenue in the in-app event. You can populate it with any numeric value, positive or negative.

af_revenue is the only event parameter that AppsFlyer counts as real revenue on the raw data and dashboard. For more details click here.

When sending events with revenue, keep the following in mind:

• If you set currency code (see example below), it should be a 3 character ISO 4217 code (default currency is USD).
• You can set the currency code for all events by setting the following property:
  • Objective-C: [AppsFlyerLib shared].currencyCode = @"ZZZ";,
  • Swift: AppsFlyerLib.shared().currencyCode = "ZZZ"
  To learn about currency settings, display, and currency conversion, see our guide on revenue currency.
• The revenue value should not contain comma separators, currency sign, or text. A revenue event should be similar to 1234.56, for example.

Example: In-app event purchase event with revenue

[[AppsFlyerLib shared] logEvent: @"purchase" 
withValues:@{
	AFEventParamContentId:@"1234567",
	AFEventParamContentType : @"category_a",
	AFEventParamRevenue: @200,
	AFEventParamCurrency:@"USD"
}];

AppsFlyerLib.shared().logEvent("purchase", 
withValues: [
	AFEventParamContentId:"1234567",
	AFEventParamContentType : "category_a",
	AFEventParamRevenue: 200,
	AFEventParamCurrency:"USD"
]);

The purchase event above has $200 in revenue, appearing as revenue in the dashboard.

Recording negative revenue

There may be situations where you want to record negative revenue.

For example, a user receives a refund or cancels a subscription.

[[AppsFlyerLib shared] logEvent: @"cancel_purchase" 
withValues:@{
	AFEventParamContentId:@"1234567",
	AFEventParamContentType : @"category_a",
	AFEventParamRevenue: @-1.99,
	AFEventParamCurrency:@"USD"
}];

AppsFlyerLib.shared().logEvent("cancel_purchase", 
withValues: [
	AFEventParamContentId:"1234567",
	AFEventParamContentType : "category_a",
	AFEventParamRevenue: -1.99,
	AFEventParamCurrency:"USD"
]);

The AppsFlyers SDK provides server verification for in-app purchases. To validate a purchase, call validateAndLogInAppPurchase.

This call automatically generates an af_purchase in-app event, given that the purchase is validated.

This call has two callback blocks, one for success and one for ‘failure’ (for any reason, including validation fail). On success, a dictionary is returned with the receipt validation data provided by Apple servers.

Usage example of validating a purchase:

- (void) validateAndLogInAppPurchase:(NSString *) productIdentifier
price:(NSString *) price
currency:(NSString *) currency
transactionId:(NSString *) tranactionId
additionalParameters:(NSDictionary *) params
success:(void (^)(NSDictionary *response)) successBlock
failure:(void (^)(NSError *error, id reponse)) failedBlock;

[[AppsFlyerLib shared] validateAndLogInAppPurchase:@"ProductIdentifier" price:@"price"
    currency:@"USD"
    transactionId:@"transactionID"
    additionalParameters:@{@"test": @"val" , @"test1" : @"val 1"}
    success:^(NSDictionary *result){
      NSLog(@"Purchase succeeded And verified!!! response: %@", result[@"receipt"]);
    } failure:^(NSError *error, id response) {
      NSLog(@"response = %@", response);
      if([response isKindOfClass:[NSDictionary class]]) {
        if([response[@"status"] isEqualToString:@"in_app_arr_empty"]){
          // retry with 'SKReceiptRefreshRequest' because
          // Apple has returned an empty response
          // <YOUR CODE HERE>
        }

      } else {
        //handle other errors
        return;
      }
  }];

AppsFlyerLib
      .shared()?
      .validateAndLogInAppPurchase ("productIdentifier",
                   price: "price",
                  currency: "currency",
               transactionId: "transactionId",
            additionalParameters: [:],
                  success: {
      guard let dictionary = $0 as? [String:Any] else { return }
      dump(dictionary)
    }, failure: { error, result in
      guard let emptyInApp = result as? [String:Any],
           let status = emptyInApp["status"] as? String,
             status == "in_app_arr_empty" else {
                // Try to handle other errors
                 return
               }
         
      // retry with 'SKReceiptRefreshRequest' because
      // Apple has returned an empty response
      // <YOUR CODE HERE>
    })

[AppsFlyerLib shared].useReceiptValidationSandbox = YES;

AppsFlyerLib.shared().useReceiptValidationSandbox = true

Validating in-app purchase automatically sends an in-app purchase event to AppsFlyer. See the following sample data that is passed in the event_value parameter:

{
   "some_parameter":"some_value", // from additional_event_values
   "af_currency":"USD", // from currency
   "af_content_id":"test_id", // from purchase
   "af_revenue":"10", // from revenue
   "af_quantity":"1", // from purchase
   "af_validated":true // flag that AF verified the purchase
}

• Event name: up to 45 characters
• Event value: must not exceed 1000 characters - if longer we may truncate it
• Pricing and revenue: use only digits and decimals, e.g. 5 or 5.2
• Pricing and revenue values can have up to 5 digits after the period, e.g. 5.12345
• Non-English characters are supported, in in-app events,  other SDK APIs, starting from Android SDK V4.8.1.

You can record in-app events by calling logEvent with event name and value parameters. See In-App Events documentation for more details.

Below is a simple example of how to record a purchase event. For a comprehensive list of ready-made code snippets per vertical, see our guide for rich in-app events per verticals.

Example: In-app purchase event

[[AppsFlyerLib shared] logEvent:AFEventPurchase
   withValues: @{
    AFEventParamRevenue: @200,
    AFEventParamCurrency: @"USD",
    AFEventParamQuantity: @2,
    AFEventParamContentId: @"092",
    AFEventParamReceiptId: @"9277"
  }];

AppsFlyerLib.shared().logEvent(AFEventPurchase,
  withValues: [
     AFEventParamRevenue: "200",
     AFEventParamCurrency: "USD",
     AFEventParamQuantity: 2,
     AFEventParamContent: "shoes",
     AFEventParamContentId: "092",
     AFEventParamReceiptId: "9277"]);

If a user initiates an event when the internet connection is unavailable, AppsFlyer is still able to record it. This is how it works:

1. SDK sends the events to AppsFlyer servers and waits for a response.
2. If the SDK doesn’t receive a 200 response, the event is stored in the cache.
3. Once the next 200 response is received, the stored event is re-sent to the server.
4. If there are multiple events in the cache, they are sent to the server one promptly after another.

• In-app event recorded successfully.
• An error occurred when recording in-app event.

 [[AppsFlyerLib shared] logEventWithEventName:AFEventPurchase
        eventValues: @{
          AFEventParamRevenue: @200,
          AFEventParamCurrency: @"USD",
          AFEventParamQuantity: @2,
          AFEventParamContentId: @"092",
          AFEventParamReceiptId: @"9277"
        }
        completionHandler:^(NSDictionary<NSString *,id> * _Nullable dictionary, NSError * _Nullable error){
            if(dictionary != nil) {
                NSLog(@"In app callback success:");
                for(id key in dictionary){
                    NSLog(@"Callback response: key=%@ value=%@", key, [dictionary objectForKey:key]);
                }
            }
            if(error != nil) {
                NSLog(@"In app callback error:", error);
            }
    }];
    

AppsFlyerLib.shared().logEvent(name: "In app event name", values: ["id": 12345, "name": "John doe"], completionHandler: { (response: [String : Any]?, error: Error?) in
             if let response = response {
               print("In app event callback Success: ", response)
             }
             if let error = error {
               print("In app event callback ERROR:", error)
             }
           })
        }
            

In the event that an error occurs when recording the in-app event, an error code and string description are provided, as indicated in the table that follows.

OneLink detects the device type upon click and redirects the user to the matching destination, e.g. Google Play, iOS app store, out-of-store markets, or web pages.

The OneLink redirections guide discusses implementing multi-platform attribution links (no SDK coding required). Its also the basis for deep linking.

Deep linking allows you to send users to specific activities and serve them with customized content. This is especially useful when running retargeting campaigns.

To set up deep linking with OneLink, a marketer with access to AppsFlyer dashboard and a developer with access to the app must work together.

See our guide on setting up deep linking with OneLink.

Deferred deep linking allows you to deep link new users and serve them with customized content upon first launch of the app. This is unlike regular deep linking where the app needs to already be installed on the user's device.

To set up deferred deep linking with OneLink, the developer also needs access to the AppsFlyer dashboard.

The setup for deferred deep linking is the same as deep linking. The only difference is that you need to implement additional logic in the app in order to deep link the users and serve them with customized content after they install and launch the app.

See our guide on deferred deep linking to learn more.

The SDK provides you with the conversion or engagement data following every install or deep linking event. You can use this data to customize content and the app's behavior programmatically.

To get deep linking data when the direct deep link is used and the app is opened, implement the onAppOpenAttribution method.

To get deep linking re-engagement data manually at any time, implement the performOnAppAttribution method. This allows access to re-engagement data without recording a new re-engagement.

See our guide on deep linking data to learn more.

You can access user attribution data in real-time for every new install, directly from the SDK.

By doing this you can serve users with personalized content or send them to specific activities within the app (see deferred deep linking in this article), which can greatly enhance their engagement with your app.

To obtain conversion data from the iOS SDK, implement the following methods:

- (void) onAppOpenAttribution:(NSDictionary*) attributionData {
    NSLog(@"onAppOpenAttribution");
    for(id key in attributionData){
        NSLog(@"onAppOpenAttribution: key=%@ value=%@", key, [attributionData objectForKey:key]);
    }
}

- (void)onAppOpenAttributionFailure:(NSError *)error {
     NSLog(@"%@", [error description]);
}

-(void)onConversionDataSuccess:(NSDictionary*) installData {
        
    BOOL first_launch_flag = [[installData objectForKey:@"is_first_launch"] boolValue];
    NSString *status = [installData objectForKey:@"af_status"];
    
    if(first_launch_flag) {
        if ([status isEqualToString:@"Non-organic"]){
            NSString *sourceID = [installData objectForKey:@"media_source"];
            NSString *campaign = [installData objectForKey:@"campaign"];
            NSLog(@"This is a non-organic install. Media source: %@ Campaign: %@", sourceID, campaign);
        } else {
            NSLog(@"This is an organic install");
        }
    } else {
        NSLog(@"Not first launch");
    }
}

-(void)onConversionDataFail:(NSError *) error {
    NSLog(@"%@", [error description]);
}

class AppDelegate: UIResponder, UIApplicationDelegate, AppsFlyerLibDelegate{
 
  func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
    AppsFlyerLib.shared().appsFlyerDevKey = "MY_DEV_KEY"
    AppsFlyerLib.shared().appleAppID = "123456789"
    AppsFlyerLib.shared().delegate = self
    //AppsFlyerLib.shared().isDebug = true
    //AppsFlyerLib.shared().appInviteOneLinkID = "ONELINK_ID";
    return true
  }
  
  func applicationDidBecomeActive(_ application: UIApplication) {
    AppsFlyerLib.shared().start()
  }
  
    func onConversionDataSuccess(_ installData: [AnyHashable: Any]) {
        
        guard let first_launch_flag = installData["is_first_launch"] as? Int else {
            return
        }
        
        guard let status = installData["af_status"] as? String else {
            return
        }
        
        if(first_launch_flag == 1) {
            if(status == "Non-organic") {
                if let media_source = installData["media_source"] , let campaign = installData["campaign"]{
                    print("This is a Non-Organic install. Media source: \(media_source) Campaign: \(campaign)")
                }
            } else {
                print("This is an organic install.")
            }
        } else {
            print("Not First Launch")
        }
    }
  
  func onConversionDataFail(_ error: Error!) {
    if let err = error{
      print(err)
    }
  }
  
  func onAppOpenAttribution(_ attributionData: [AnyHashable : Any]!) {
    if let data = attributionData{
      print("\(data)")
    }
  }
  
  func onAppOpenAttributionFailure(_ error: Error!) {
    if let err = error{
      print(err)
    }
  }

The two most important methods are:

• onConversionDataSuccess - provides conversion data for new installs.
  

  Note: Starting SDK V5, onConversionDataSuccess is the name of the method for getting conversion data. If you are using an SDK version lower than 5.0.0, the name of the method is onConversionDataReceived. We recommend that you upgrade to SDK 5.0.0. To learn more, click here.

• onAppOpenAttribution - provides retargeting conversion data when an existing app is launched, either manually or through deep linking.

To learn more about conversion data, see our guide on conversion data scenarios.

To learn how to setup uninstall measurement, read here.

If you want to receive a confirmation that the SDK started successfully and notified AppsFlyer servers, implement the startWithCompletionHandler handler. You can then apply logic to handle success or failure of the SDK launch.

Implementation example

[[AppsFlyerLib shared] startWithCompletionHandler:^(NSDictionary<NSString *,id> *dictionary, NSError *error) {
        if (error) {
            NSLog(@"%@", error);
            return;
        }
        if (dictionary) {
            NSLog(@"%@", dictionary);
            return;
        }
    }];

 AppsFlyerLib.shared()?.start(completionHandler: { (dictionnary, error) in
            if (error != nil){
                print(error ?? "")
                return
            } else {
                print(dictionnary ?? "")
                return
            }
        })

In the event that an error occurs during the request listener, an error code and string description are provided, as indicated in the table that follows.

The setAdditionalData API is required to integrate on the SDK level with several external partner platforms, including Segment, Adobe and Urban Airship.
Use this API only if the integration article of the platform specifically states setAdditionalData API is needed.

setAdditionalData code example:

NSDictionary* CustomDataMap = [[NSDictionary alloc] initWithObjectsAndKeys:@"value_of_param_1", @"custom_param_1", nil];
[[AppsFlyerLib shared] setAdditionalData:CustomDataMap];

let CustomDataMap: [AnyHashable: Any] = [
  "custom_param_1" : "value_of_param_1"
]
AppsFlyerLib.shared().customData = CustomDataMap

By default, at least 5 seconds must pass between two app launches to count as two separate sessions (more about counting sessions).

Use the following API to set the minimum time between sessions:

[AppsFlyerLib shared].minTimeBetweenSessions = <your_custom_time_in_seconds>;

AppsFlyerLib.shared().minTimeBetweenSessions = <your_custom_time_in_seconds>

Setting a high value to the custom time between launches may badly impact APIs relying on sessions data, such as deep linking.

Unavailable in iOS.

Some 3rd party services such as email service providers wrap links in emails with their own click recording domains. Some even allow you to set your own click recording domains. If OneLink is wrapped in such domains, it might limit its functionality.

To overcome this issue you can use the setResolveDeepLinkURLs API. Use this API to get the OneLink from click domains that launch the app. Make sure to call this API before SDK initialization.

For example, you have three click domains that redirect to your OneLink which is https://mysubdomain.onelink.me/abCD. Use this API to get the OneLink that your click domains redirect toThis API method receives a list of domains that the SDK resolves.

[AppsFlyerLib shared].resolveDeepLinkURLs = @[@"example.com",@"click.example.com"];

AppsFlyerLib.shared().resolveDeepLinkURLs = ["example.com", "click.example.com"]

The code above allows you to use your click domain while preserving OneLink functionality. The click domains are responsible for launching the app. The API, in turn, gets the OneLink from these click domains and then you can use the data from this OneLink to deep link and customize user content.

With AppsFlyer, you can record push notifications as part of retargeting campaigns.

To enable this feature, call the handlePushNotificationData method inside AppDelegate.m.

-(void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
[[AppsFlyerLib shared] handlePushNotification:userInfo];
}

func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
    AppsFlyerLib.shared().handlePushNotification(userInfo)
}

For more information on push notification measurement, read here.

Allowing your existing users to invite their friends and contacts as new users to your app, can be a key growth factor for your app. With AppsFlyer, you can attribute and record installs that originate from user invites within your app.

For details, see the User Invite Attribution article.

An AppsFlyer unique ID is created for every new install of an app. You can this ID for various purposes:

• Send server-to-server in-app events.
• Match it with user records in your backend systems.
• Map entries when merging data from pull and push API.

Use the following API to obtain the unique ID:

NSString *appsflyerId = [AppsFlyerLib shared].getAppsFlyerUID;

let appsflyerId = AppsFlyerLib.shared().getAppsFlyerUID()

To set your Customer User ID:

[AppsFlyerLib shared].customerUserID = @"my user id";

AppsFlyerLib.shared().customerUserID = "my user id"

In iOS, the Customer User ID needs to be set with every app launch. We recommend setting the Customer User ID early in the app flow, as it is only associated with events reported after its setup:

• If setCustomerUserId is called before calling start, the Customer User ID appears in the raw data reports for installs and for events.
• If it is set after, Customer User ID is only associated with events that are recorded after setting the Customer User ID.

Getting Customer User ID:

To avoid setting the Customer User ID value again beyond the first launch, and to reduce calls to your server to get the customer user ID, you can check if its value is empty or not by using:

NSString *customerUserID = [AppsFlyerLib shared].customerUserID;

let customerUserID = AppsFlyerLib.shared().customerUserID

For more information about the Customer User ID, click here.

Delay SDK init for customerUserID

You can delay the SDK Initialization until the Customer User ID is set. This is useful if its important for you that install and event data contain your customer user ID.

Implement the following code:

- (void)applicationDidBecomeActive:(UIApplication *)application {
    NSString *customUserId = [[NSUserDefaults standardUserDefaults] stringForKey:@"customerUserId"]; // Your custom logic of retrieving CUID
    if (customUserId != nil && ![customUserId  isEqual: @""]) {
        [AppsFlyerLib shared].customerUserID = customUserId; // Set CUID in AppsFlyer SDK for this session
        [[AppsFlyerLib shared] start]; // Start
    }
}

func applicationDidBecomeActive(_ application: UIApplication) {
        let customUserId = UserDefaults.standard.string(forKey: "customUserId")  //  your logic to retrieve CUID
        if(customUserId != nil && customUserId != ""){
            AppsFlyerLib.shared().customerUserID = customUserId // Set CUID in AppsFlyer SDK for this session
            AppsFlyerLib.shared().start() // Start
        }
    }

To learn more about delaying the SDK initialization until the Customer User ID is available, go here.

In some extreme cases, you might want to shut down all SDK data logging due to legal and privacy compliance. This can be achieved with the isStopped property. Once this property is set to true, the SDK stops functioning and no longer communicates with AppsFlyer servers.

There are several different scenarios for user opt-out. We highly recommend following the exact instructions for the scenario that is relevant for your app.

[AppsFlyerLib shared].isStopped = true;

AppsFlyerLib.shared().isStopped = true

In any event, the SDK can be reactivated by calling the same API, by passing false.

Use this API during the SDK Initialization to explicitly anonymize a user install, events and sessions:

[AppsFlyerLib shared].anonymizeUser = YES;

AppsFlyerLib.shared().anonymizeUser = true

Logging data can be restarted by setting anonymizeUser to false.

Apple messaging indicates that in the future, iOS 14 will mandate user authorization to collect IDFA.

Currently, IDFA is collected by default. However, for iOS 14 beta 7 and later, you have the option to request user authorization for collecting IDFA via a consent dialog. If the user opts-out, the IDFA is not collected. The timeout interval delays sending a request to AppsFlyer servers. After the timer expires, the request is sent.

To request user authorization to collect IDFA, add the following code before start(): 

// The following block is for applications wishing to give users the option to block IDFA collection.
 // for iOS 14 and above - The user can be prompted to block IDFA collection.
 //                        If user opts-out, the IDFA will not be collected by the SDK.
 // for iOS 13 and below - The IDFA will be collected by the SDK. The user will NOT be prompted to block collection.
 if #available(iOS 14, *) { 
    // Set a timeout for the SDK to wait for the IDFA collection before handling app launch
    // If timeout expires before user asks to block IDFA collection, the IDFA will be collected.
    [[AppsFlyerLib shared] waitForATTUserAuthorizationWithTimeoutInterval:60];
    // Show the user the Apple IDFA consent dialog 
    (AppTrackingTransparency)
    // MUST be called here before start() in order to prevent IDFA collection by the SDK

    [ATTrackingManager requestTrackingAuthorizationWithCompletionHandler:^(ATTrackingManagerAuthorizationStatus status) {
    //....
    }];
}

// The following block is for applications wishing to give users the option to block IDFA collection.
 // for iOS 14 and above - The user can be prompted to block IDFA collection.
 //                        If user opts-out, the IDFA will not be collected by the SDK.
 // for iOS 13 and below - The IDFA will be collected by the SDK. The user will NOT be prompted to block collection.
 if #available(iOS 14, *) {
    // Set a timeout for the SDK to wait for the IDFA collection before handling app launch
    // If timeout expires before user asks to block IDFA collection, the IDFA will be collected.
    AppsFlyerLib.shared().waitForATTUserAuthorization(timeoutInterval: 60)
    // Show the user the Apple IDFA consent dialog (AppTrackingTransparency)
    // MUST be called here before start() in order to prevent IDFA collection by the SDK
    ATTrackingManager.requestTrackingAuthorization { (status) in
    }
 }

To configure the text presented to the user in the popup:

1. Select the project Info.plist file in the Xcode Project Navigator.
2. Add an entry to the list: Press+  next to Information Property List.

   

3. Scroll down and select Privacy - Tracking Usage Description.
4. Add as the value the wording you want to present to the user when asking for permission to collect the IDFA.

   

The possible user actions in the ATT popup and outcomes (based on the timer set by the developer in the waitForATTUserAuthorization method) are listed in the table that follows. 

Note: After the timer expires, the AppsFlyer SDK is launched, with or without collecting the IDFA. 

In some cases, advertisers may want to stop sharing user-level data with ad networks/partners for specific users. Reasons for this include: 

• Privacy policies such as CCPA or GDPR
• User opt-out mechanisms
• Competition with some partners (ad networks, 3rd parties)

AppsFlyer provides two API methods to stop sharing data with some or all partners:

• setSharingFilter: Used by advertisers to prevent sharing data with some (one or more) networks/integrated partners.
• setSharingFilterForAllPartners: Used by advertisers to prevent sharing data with all networks/integrated partners.

These filtering methods are supported as of SDK V5.4.1.

The filtering method must be called every time the SDK is initialized and affects the whole session. If it takes time to determine whether you need to set the sharing filters, then delay the SDK initialization. 

When the method is activated before the first start call:

• Users from SRNs are attributed as Organic, and their data is not shared with integrated partners.
• Users from click ad networks (non-SRNs) are attributed correctly in AppsFlyer, but not shared with the ad networks via postbacks, APIs, raw data reports, or by any other method.

Currently, uninstall data can't be filtered using these methods. However, you can stop sending Uninstall events to partners using their setup pages in AppsFlyer.