Complying with Data Privacy Laws

Implement privacy-compliant data collection by notifying Singular of user consent choices for GDPR, CCPA, and other consumer privacy regulations.

When users consent or decline to share their information with third parties, use Singular's privacy methods to communicate their choice. This ensures compliance with regulations like California Consumer Privacy Act (CCPA) and enables partners to respect user privacy preferences.

Limit Data Sharing

Control Third-Party Data Sharing

Notify Singular whether users have consented to share their personal data with third-party partners using the limitDataSharing method.

Method Signature:

+ (void)limitDataSharing:(BOOL)shouldLimitDataSharing;

Parameters:

• NO (false): User has opted in and consented to share their data
• YES (true): User has opted out and does not consent to share their data

Usage Examples

// User has opted in to share their data
Singular.limitDataSharing(false)

// User has opted out and declined to share their data
Singular.limitDataSharing(true)

// Example: Set based on user preference
func handlePrivacyConsent(userConsented: Bool) {
    // Pass inverse: false = opted in, true = opted out
    Singular.limitDataSharing(!userConsented)
    
    print("Data sharing: \(userConsented ? "Enabled" : "Limited")")
}

// User has opted in to share their data
[Singular limitDataSharing:NO];

// User has opted out and declined to share their data
[Singular limitDataSharing:YES];

// Example: Set based on user preference
- (void)handlePrivacyConsent:(BOOL)userConsented {
    // Pass inverse: NO = opted in, YES = opted out
    [Singular limitDataSharing:!userConsented];
    
    NSLog(@"Data sharing: %@", userConsented ? @"Enabled" : @"Limited");
}

How It Works:

Singular uses this setting in User Privacy Postbacks and passes it to partners who require it for regulatory compliance.

Per-Event Limit Data Sharing

Override Data Sharing on a Single Event

You can override the global limitDataSharing setting for a single event or custom revenue call by passing the ATTRIBUTE_SNG_LIMIT_DATA_SHARING attribute alongside your other event arguments. This is useful when a user updates their consent inline with an action and you want that specific event to reflect the new choice immediately, without changing the SDK-wide setting for subsequent events.

Accepted Values:

• NO (false): User has opted in for this event only
• YES (true): User has opted out for this event only

Usage Examples

// Example 1: Standard event, opt out only for this event
var dic: [AnyHashable: Any] = [:]
dic[ATTRIBUTE_SNG_LIMIT_DATA_SHARING] = true
dic["order_id"] = "12345"

Singular.event("checkout_completed", withArgs: dic)

// Example 2: Custom revenue, opt in only for this event
var attributes: [AnyHashable: Any] = [:]
attributes[ATTRIBUTE_SNG_LIMIT_DATA_SHARING] = false
attributes["sku"] = "premium_monthly"

Singular.customRevenue("premium_purchase",
                      currency: "USD",
                      amount: 9.99,
                      withAttributes: attributes)

// Example 1: Standard event, opt out only for this event
NSMutableDictionary *dic = [[NSMutableDictionary alloc] init];
[dic setValue:@YES forKey:ATTRIBUTE_SNG_LIMIT_DATA_SHARING];
[dic setValue:@"12345" forKey:@"order_id"];

[Singular event:@"checkout_completed" withArgs:dic];

// Example 2: Custom revenue, opt in only for this event
NSMutableDictionary *attributes = [[NSMutableDictionary alloc] init];
[attributes setValue:@NO forKey:ATTRIBUTE_SNG_LIMIT_DATA_SHARING];
[attributes setValue:@"premium_monthly" forKey:@"sku"];

[Singular customRevenue:@"premium_purchase"
               currency:@"USD"
                 amount:9.99
         withAttributes:attributes];

How It Works:

When a valid boolean is supplied, the SDK removes the attribute from the event's arguments and writes it to the request's data_sharing_options.limit_data_sharing field — overriding the global limitDataSharing setting for that single request only. The global setting and the result of getLimitDataSharing are not modified, so any subsequent events that do not supply the attribute continue to use the global choice.

GDPR Compliance Methods

Manage user tracking consent and control SDK functionality to comply with GDPR (General Data Protection Regulation) and other privacy regulations.

Tracking Consent Management

trackingOptIn

Record explicit user consent for tracking by sending a GDPR opt-in event to Singular servers.

Method Signature:

+ (void)trackingOptIn;

When to Use:

• GDPR Compliance: Call when users explicitly consent to tracking in GDPR-regulated regions
• Consent Recording: Marks users as having provided GDPR consent in Singular's systems
• Default Behavior: Without this call, SDK continues tracking but doesn't specifically record consent

// User accepted tracking consent
Singular.trackingOptIn()

// Example: Call after consent dialog
func onUserAcceptedTracking() {
    Singular.trackingOptIn()
    print("User opted in to tracking")
}

// User accepted tracking consent
[Singular trackingOptIn];

// Example: Call after consent dialog
- (void)onUserAcceptedTracking {
    [Singular trackingOptIn];
    NSLog(@"User opted in to tracking");
}

Tracking Control Methods

stopAllTracking

Completely disable all SDK tracking activities for the current user on this device.

Method Signature:

+ (void)stopAllTracking;

Behavior:

• Immediate Effect: Stops all tracking, event reporting, and data collection instantly
• Persistent State: Remains disabled even after app closes and reopens
• No Automatic Reset: Must explicitly call resumeAllTracking to re-enable

// User declined all tracking
Singular.stopAllTracking()

// Example: Handle user opt-out
func onUserDeclinedTracking() {
    Singular.stopAllTracking()
    print("All tracking stopped")
    
    // Optionally store preference
    saveUserTrackingPreference(false)
}

// User declined all tracking
[Singular stopAllTracking];

// Example: Handle user opt-out
- (void)onUserDeclinedTracking {
    [Singular stopAllTracking];
    NSLog(@"All tracking stopped");
    
    // Optionally store preference
    [self saveUserTrackingPreference:NO];
}

resumeAllTracking

Re-enable tracking after it was stopped with stopAllTracking .

Method Signature:

+ (void)resumeAllTracking;

Use Cases:

• Consent Change: User changes privacy preferences and opts back into tracking
• Privacy Settings: User updates consent through app settings menu
• Regional Compliance: Re-enable tracking when user moves to non-regulated regions

// User opted back in to tracking
Singular.resumeAllTracking()

// Example: Handle consent update
func onUserResumedTracking() {
    Singular.resumeAllTracking()
    print("Tracking resumed")
    
    // Optionally update stored preference
    saveUserTrackingPreference(true)
}

// User opted back in to tracking
[Singular resumeAllTracking];

// Example: Handle consent update
- (void)onUserResumedTracking {
    [Singular resumeAllTracking];
    NSLog(@"Tracking resumed");
    
    // Optionally update stored preference
    [self saveUserTrackingPreference:YES];
}

isAllTrackingStopped

Check whether tracking has been disabled for the current user.

Method Signature:

+ (BOOL)isAllTrackingStopped;

Returns:

• YES (true): Tracking is currently stopped via stopAllTracking
• NO (false): Tracking is active (either never stopped or resumed)

// Check current tracking status
let isTrackingStopped = Singular.isAllTrackingStopped()

// Example: Display privacy status in settings
func getPrivacyStatusText() -> String {
    return Singular.isAllTrackingStopped() ? "Tracking: Disabled" : "Tracking: Enabled"
}

// Example: Sync UI with tracking state
func updatePrivacyToggle() {
    let isStopped = Singular.isAllTrackingStopped()
    privacyToggle.isOn = !isStopped
    print("Current tracking state: \(isStopped ? "Stopped" : "Active")")
}

// Check current tracking status
BOOL isTrackingStopped = [Singular isAllTrackingStopped];

// Example: Display privacy status in settings
- (NSString *)getPrivacyStatusText {
    return [Singular isAllTrackingStopped] ? @"Tracking: Disabled" : @"Tracking: Enabled";
}

// Example: Sync UI with tracking state
- (void)updatePrivacyToggle {
    BOOL isStopped = [Singular isAllTrackingStopped];
    self.privacyToggle.on = !isStopped;
    NSLog(@"Current tracking state: %@", isStopped ? @"Stopped" : @"Active");
}

Children's Privacy Protection

trackingUnder13

Notify Singular that the user is under 13 years old to comply with COPPA (Children's Online Privacy Protection Act) and other child privacy regulations.

Method Signature:

+ (void)trackingUnder13;

Compliance Requirements:

• COPPA Compliance: Required for apps that collect data from children under 13 in the United States
• Age-Gated Content: Use when users identify themselves as under 13 during registration or age verification
• Restricted Tracking: Limits data collection to comply with children's privacy protection laws

// User identified as under 13
Singular.trackingUnder13()

// Example: Call after age verification
func onAgeVerified(userAge: Int) {
    if userAge < 13 {
        Singular.trackingUnder13()
        print("COPPA mode enabled for user under 13")
    }
}

// User identified as under 13
[Singular trackingUnder13];

// Example: Call after age verification
- (void)onAgeVerified:(int)userAge {
    if (userAge < 13) {
        [Singular trackingUnder13];
        NSLog(@"COPPA mode enabled for user under 13");
    }
}

limitAdvertisingIdentifiers

Restrict the collection and use of advertising identifiers (IDFA on iOS) during SDK initialization for mixed audience apps.

Configuration Property:

@property (assign) BOOL limitAdvertisingIdentifiers;

Use Cases:

• Mixed Audience Apps: Apps that serve both adults and children where age is determined before app launch
• Known COPPA Users: When you know at initialization time that the user is under 13
• Privacy-First Approach: Apply advertising identifier limitations from the first SDK session

Configuration Method

Set advertising identifier limitations during SDK initialization for apps that know privacy requirements upfront.

// Limit advertising identifiers at initialization
let config = SingularConfig(apiKey: "SDK_KEY", andSecret: "SDK_SECRET")
config?.limitAdvertisingIdentifiers = true

Singular.start(config)

// Limit advertising identifiers at initialization
SingularConfig *config = [[SingularConfig alloc]
    initWithApiKey:@"SDK_KEY"
    andSecret:@"SDK_SECRET"];
config.limitAdvertisingIdentifiers = YES;

[Singular start:config];

Runtime Method

Toggle advertising identifier collection at any point after +start: . Useful for mixed-audience apps where the age gate, consent prompt, or content selection happens after the SDK has already started.

+ (void)setLimitAdvertisingIdentifiers:(BOOL)enabled;

// Apply identifier limit after the user enters kids mode
func onKidsModeSwitched(isKidsMode: Bool) {
    Singular.setLimitAdvertisingIdentifiers(isKidsMode)
}

// Apply identifier limit after the user enters kids mode
- (void)onKidsModeSwitched:(BOOL)isKidsMode {
    [Singular setLimitAdvertisingIdentifiers:isKidsMode];
}

Implementation Best Practices

Complete Privacy Management Example

Implement comprehensive privacy controls that respect user preferences and comply with regulations.

import Foundation

class PrivacyManager {
    
    private let userDefaults = UserDefaults.standard
    private let consentKey = "user_consent"
    private let dataSharingKey = "data_sharing"
    
    // Initialize privacy settings on app start
    func initializePrivacy() {
        let hasUserConsent = getUserConsent()
        let allowDataSharing = getDataSharingPreference()
        
        // Apply stored preferences
        if hasUserConsent {
            Singular.trackingOptIn()
            Singular.resumeAllTracking()
        } else {
            Singular.stopAllTracking()
        }
        
        // Set data sharing preference
        Singular.limitDataSharing(!allowDataSharing)
        
        print("Privacy initialized: consent=\(hasUserConsent), sharing=\(allowDataSharing)")
    }
    
    // User accepts tracking via consent dialog
    func userAcceptedTracking() {
        saveUserConsent(true)
        Singular.trackingOptIn()
        Singular.resumeAllTracking()
        print("User accepted tracking")
    }
    
    // User declines tracking
    func userDeclinedTracking() {
        saveUserConsent(false)
        Singular.stopAllTracking()
        print("User declined tracking")
    }
    
    // User updates data sharing preference
    func setDataSharingEnabled(_ enabled: Bool) {
        saveDataSharingPreference(enabled)
        // Note: limitDataSharing uses inverse logic
        Singular.limitDataSharing(!enabled)
        print("Data sharing: \(enabled ? "Enabled" : "Limited")")
    }
    
    // Get current tracking status
    func isTrackingEnabled() -> Bool {
        return !Singular.isAllTrackingStopped()
    }
    
    // Private helper methods
    private func getUserConsent() -> Bool {
        return userDefaults.bool(forKey: consentKey)
    }
    
    private func saveUserConsent(_ consent: Bool) {
        userDefaults.set(consent, forKey: consentKey)
    }
    
    private func getDataSharingPreference() -> Bool {
        return userDefaults.bool(forKey: dataSharingKey)
    }
    
    private func saveDataSharingPreference(_ enabled: Bool) {
        userDefaults.set(enabled, forKey: dataSharingKey)
    }
}

#import <Foundation/Foundation.h>
#import <Singular/Singular.h>

@interface PrivacyManager : NSObject

- (void)initializePrivacy;
- (void)userAcceptedTracking;
- (void)userDeclinedTracking;
- (void)setDataSharingEnabled:(BOOL)enabled;
- (BOOL)isTrackingEnabled;

@end

@implementation PrivacyManager

static NSString *const kConsentKey = @"user_consent";
static NSString *const kDataSharingKey = @"data_sharing";

// Initialize privacy settings on app start
- (void)initializePrivacy {
    BOOL hasUserConsent = [self getUserConsent];
    BOOL allowDataSharing = [self getDataSharingPreference];
    
    // Apply stored preferences
    if (hasUserConsent) {
        [Singular trackingOptIn];
        [Singular resumeAllTracking];
    } else {
        [Singular stopAllTracking];
    }
    
    // Set data sharing preference
    [Singular limitDataSharing:!allowDataSharing];
    
    NSLog(@"Privacy initialized: consent=%d, sharing=%d", hasUserConsent, allowDataSharing);
}

// User accepts tracking via consent dialog
- (void)userAcceptedTracking {
    [self saveUserConsent:YES];
    [Singular trackingOptIn];
    [Singular resumeAllTracking];
    NSLog(@"User accepted tracking");
}

// User declines tracking
- (void)userDeclinedTracking {
    [self saveUserConsent:NO];
    [Singular stopAllTracking];
    NSLog(@"User declined tracking");
}

// User updates data sharing preference
- (void)setDataSharingEnabled:(BOOL)enabled {
    [self saveDataSharingPreference:enabled];
    // Note: limitDataSharing uses inverse logic
    [Singular limitDataSharing:!enabled];
    NSLog(@"Data sharing: %@", enabled ? @"Enabled" : @"Limited");
}

// Get current tracking status
- (BOOL)isTrackingEnabled {
    return ![Singular isAllTrackingStopped];
}

// Private helper methods
- (BOOL)getUserConsent {
    return [[NSUserDefaults standardUserDefaults] boolForKey:kConsentKey];
}

- (void)saveUserConsent:(BOOL)consent {
    [[NSUserDefaults standardUserDefaults] setBool:consent forKey:kConsentKey];
}

- (BOOL)getDataSharingPreference {
    return [[NSUserDefaults standardUserDefaults] boolForKey:kDataSharingKey];
}

- (void)saveDataSharingPreference:(BOOL)enabled {
    [[NSUserDefaults standardUserDefaults] setBool:enabled forKey:kDataSharingKey];
}

@end