iOS SDK integration for developers

AppsFlyer's 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.

Note: Starting SDK version 4.8.11, the SDK automatically adds AdSupport.framework. iAd.framework is added automatically from SDK version 4.10.0 and above.
If you are using previous SDK versions, see the following instructions.

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 your project's 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's dashboard.
2. In the dashboard, under Configuration click App Settings.
3. Copy your dev key.
   
   

   

In order to support deeplinking, add the following code to SceneDelegate for every scene your app supports deep linking into.

1. Importing the library

#import <AppsFlyerLib/AppsFlyerTracker.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){
        [[AppsFlyerTracker sharedTracker] handleOpenUrl:url options:nil];
    }
}

- (void)scene:(UIScene *)scene continueUserActivity:(NSUserActivity *)userActivity  API_AVAILABLE(ios(13.0)){
    [[AppsFlyerTracker sharedTracker]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) {
        AppsFlyerTracker.shared().continue(userActivity, restorationHandler: nil)
    }
    
    func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
        if let url = URLContexts.first?.url {
            AppsFlyerTracker.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.
    }
}

Before you start testing installs:

• Make sure your device does not have the app installed.
• Whitelist 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 your app's package name.

You should see the following:

Send Track-App-Launch 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 application's dashboard.

If you don't see an install in the app's dashboard, see our 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 application's 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 AppsFlyerTracker.h if using Objective-C, or AppsFlyerLib if using Swift:

#import AppsFlyerTracker.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: [AppsFlyerTracker sharedTracker].currencyCode = @"ZZZ";,
  • Swift: AppsFlyerTracker.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

[[AppsFlyerTracker sharedTracker] trackEvent: @"cancel_purchase" 
withValues:@{
	AFEventParamContentId:@"1234567",
	AFEventParamContentType : @"category_a",
	AFEventParamRevenue: @-200,
	AFEventParamCurrency:@"USD"
}];

AppsFlyerTracker.shared().trackEvent("cancel_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.

[[AppsFlyerTracker sharedTracker] trackEvent: @"cancel_purchase" 
withValues:@{
	AFEventParamContentId:@"1234567",
	AFEventParamContentType : @"category_a",
	AFEventParamRevenue: @-1.99,
	AFEventParamCurrency:@"USD"
}];

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

AppsFlyer’s SDK provides server verification for in-app purchases. To validate a purchase, call validateAndTrackInAppPurchase.

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’s servers.

Usage example of validating a purchase:

- (void) validateAndTrackInAppPurchase:(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;

[[AppsFlyerTracker sharedTracker] validateAndTrackInAppPurchase:@"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;
      }
  }];

AppsFlyerTracker
      .shared()?
      .validateAndTrack(inAppPurchase: "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>
    })

[AppsFlyerTracker sharedTracker].useReceiptValidationSandbox = YES;

AppsFlyerTracker.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 trackEvent 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

[[AppsFlyerTracker sharedTracker] trackEvent:AFEventPurchase
   withValues: @{
    AFEventParamRevenue: @200,
    AFEventParamCurrency: @"USD",
    AFEventParamQuantity: @2,
    AFEventParamContentId: @"092",
    AFEventParamReceiptId: @"9277"
  }];

AppsFlyerTracker.shared().trackEvent(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's 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.

 [[AppsFlyerTracker sharedTracker] trackEventWithEventName: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);
            }
    }];
    

AppsFlyerTracker.shared().trackEvent(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)
             }
           })
        }
            

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). It's 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.

To learn how to setup uninstall measurement, read here.

If you want to receive a confirmation that the tracking request was successfully received by AppsFlyer servers, implement the trackAppLaunchWithCompletionHandler handler. You can then apply logic to handle success or failure of tracking app launch.

Implementation example

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

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

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];
[[AppsFlyerTracker sharedTracker] setAdditionalData:CustomDataMap];

let CustomDataMap: [AnyHashable: Any] = [
  "custom_param_1" : "value_of_param_1"
]
AppsFlyerTracker.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:

[AppsFlyerTracker sharedTracker].minTimeBetweenSessions = <your_custom_time_in_seconds>;

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

[AppsFlyerTracker sharedTracker].resolveDeepLinkURLs = @[@"example.com",@"click.example.com"];

AppsFlyerTracker.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 {
	[[AppsFlyerTracker sharedTracker] handlePushNotification:userInfo];
  }

func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
    AppsFlyerTracker.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.

AppsFlyer's 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 AppsFlyer’s Unique ID:

NSString *appsflyerId = [AppsFlyerTracker sharedTracker].getAppsFlyerUID;

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

To set your Customer User ID:

[AppsFlyerTracker sharedTracker].customerUserID = @"my user id";

AppsFlyerTracker.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's flow, as it is only associated with events reported after its setup:

• If setCustomerUserId is called before calling trackAppLaunch, 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 = [AppsFlyerTracker sharedTracker].customerUserID;

let customerUserID = AppsFlyerTracker.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 it's 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: @""]) {
        [AppsFlyerTracker sharedTracker].customerUserID = customUserId; // Set CUID in AppsFlyer SDK for this session
        [[AppsFlyerTracker sharedTracker] trackAppLaunch]; // Track App Launch
    }
}

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

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 tracking due to legal and privacy compliance. This can be achieved with the isStopTracking 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.

[AppsFlyerTracker sharedTracker].isStopTracking = true;

AppsFlyerTracker.shared().isStopTracking = 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's install, events and sessions:

[AppsFlyerTracker sharedTracker].deviceTrackingDisabled = YES;

AppsFlyerTracker.shared().deviceTrackingDisabled = true

Tracking can be restarted by setting deviceTrackingDisabled to false.

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 before every trackAppLaunchWithCompletion, trackEvent, and validateAndTrackInAppPurchase call, for every event you don't want to share with partners. You can choose to still share specific events, by not using the filtering method before sending them.

If the method is activated before the first trackAppLaunch 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.