@datalyr/react-native 1.4.8 → 1.5.0

package/README.md

@@ -19,6 +19,7 @@ Mobile analytics and attribution SDK for React Native and Expo. Track events, id
 - [Attribution](#attribution)
   - [Automatic Capture](#automatic-capture)
   - [Deferred Deep Links](#deferred-deep-links)
+  - [Web-to-App Attribution](#web-to-app-attribution)
 - [Event Queue](#event-queue)
 - [Auto Events](#auto-events)
 - [SKAdNetwork](#skadnetwork)
@@ -356,6 +357,23 @@ if (deferred) {
 }
 ```
 
+### Web-to-App Attribution
+
+Automatically recover attribution from a web prelander when users install the app from an ad.
+
+**How it works:**
+- **Android**: Attribution params are passed through the Play Store `referrer` URL parameter (set by the web SDK's `trackAppDownloadClick()`). The mobile SDK reads these via the Play Install Referrer API — deterministic, ~95% accuracy.
+- **iOS**: On first install, the SDK calls the Datalyr API to match the device's IP against recent `$app_download_click` web events within 24 hours — ~90%+ accuracy for immediate installs.
+
+No additional mobile code is needed. Attribution is recovered automatically during `initialize()` on first install, before the `app_install` event fires.
+
+After a match, the SDK:
+1. Merges web attribution (click IDs, UTMs, cookies) into the mobile session
+2. Tracks a `$web_attribution_matched` event for analytics
+3. All subsequent events (including purchases) carry the matched attribution
+
+**Fallback:** If IP matching misses (e.g., VPN toggle during install), email-based attribution is still recovered when `identify()` is called with the user's email.
+
 ### Manual Attribution
 
 Set attribution programmatically:
@@ -478,13 +496,25 @@ await Datalyr.initialize({
 await Datalyr.initialize({
   apiKey: 'dk_your_api_key',
   tiktok: {
-    appId: 'your_app_id',
-    tiktokAppId: '7123456789',
+    appId: 'your_app_id',                    // Events API App ID
+    tiktokAppId: '7123456789',               // TikTok App ID (Developer Portal)
+    accessToken: 'your_access_token',        // Events API Access Token
     enableAppEvents: true,
   },
 });
 ```
 
+**Where to find your TikTok credentials:**
+
+| Credential | Where to get it |
+|------------|----------------|
+| `tiktokAppId` | [TikTok Developer Portal](https://developers.tiktok.com) → Your App → App ID |
+| `appId` | TikTok Business Center → Assets → Events → Your App → App ID |
+| `accessToken` | TikTok Business Center → Assets → Events → Your App → Settings → Access Token |
+
+> **Note:** The `accessToken` enables client-side TikTok SDK features (enhanced attribution, real-time event forwarding). Without it, events are still tracked server-side via Datalyr postbacks — you'll see a warning in debug mode.
+```
+
 ### Apple Search Ads
 
 Attribution for users who install from Apple Search Ads (iOS 14.3+). Automatically fetched on initialization.
@@ -667,12 +697,17 @@ Check status: `Datalyr.getPlatformIntegrationStatus()`
 
 ### TikTok SDK Not Working
 
+1. Make sure you have all three TikTok credentials (see [TikTok setup](#tiktok))
+2. The `accessToken` is required for client-side SDK — without it, you'll see a warning but server-side tracking still works
+3. Check status: `Datalyr.getPlatformIntegrationStatus()`
+
 ```typescript
 await Datalyr.initialize({
   apiKey: 'dk_your_api_key',
   tiktok: {
     appId: 'your_app_id',
     tiktokAppId: '7123456789012345',
+    accessToken: 'your_access_token',
   },
 });
 ```

package/android/build.gradle

@@ -51,4 +51,7 @@ dependencies {
 
     // Google Play Install Referrer
     implementation 'com.android.installreferrer:installreferrer:2.2'
+
+    // Google Advertising ID (GAID) for attribution
+    implementation 'com.google.android.gms:play-services-ads-identifier:18.1.0'
 }

package/android/src/main/java/com/datalyr/reactnative/DatalyrNativeModule.java

@@ -26,6 +26,9 @@ import com.tiktok.TikTokBusinessSdk.TTConfig;
 import com.tiktok.appevents.TikTokAppEvent;
 import com.tiktok.appevents.TikTokAppEventLogger;
 
+import com.google.android.gms.ads.identifier.AdvertisingIdClient;
+import com.google.android.gms.common.GooglePlayServicesNotAvailableException;
+
 import java.math.BigDecimal;
 import java.util.Currency;
 import java.util.HashMap;
@@ -391,6 +394,47 @@ public class DatalyrNativeModule extends ReactContextBaseJavaModule {
         promise.resolve(result);
     }
 
+    // ============================================================================
+    // Advertiser Info (GAID on Android)
+    // ============================================================================
+
+    @ReactMethod
+    public void getAdvertiserInfo(Promise promise) {
+        // GAID must be fetched on a background thread
+        new Thread(() -> {
+            try {
+                WritableMap result = Arguments.createMap();
+
+                // Fetch Google Advertising ID
+                try {
+                    AdvertisingIdClient.Info adInfo = AdvertisingIdClient.getAdvertisingIdInfo(reactContext.getApplicationContext());
+                    boolean limitAdTracking = adInfo.isLimitAdTrackingEnabled();
+                    result.putBoolean("advertiser_tracking_enabled", !limitAdTracking);
+                    result.putInt("att_status", limitAdTracking ? 2 : 3); // 2=denied, 3=authorized
+
+                    if (!limitAdTracking && adInfo.getId() != null) {
+                        result.putString("gaid", adInfo.getId());
+                    }
+                } catch (GooglePlayServicesNotAvailableException e) {
+                    // Google Play Services not available (e.g., Huawei devices)
+                    result.putInt("att_status", 3);
+                    result.putBoolean("advertiser_tracking_enabled", true);
+                    Log.d(TAG, "Google Play Services not available for GAID");
+                } catch (Exception e) {
+                    // Fallback — GAID not available but not blocking
+                    result.putInt("att_status", 3);
+                    result.putBoolean("advertiser_tracking_enabled", true);
+                    Log.d(TAG, "GAID not available: " + e.getMessage());
+                }
+
+                promise.resolve(result);
+            } catch (Exception e) {
+                Log.e(TAG, "Failed to get advertiser info: " + e.getMessage());
+                promise.resolve(null);
+            }
+        }).start();
+    }
+
     // ============================================================================
     // Helper Methods
     // ============================================================================

package/ios/DatalyrNativeModule.swift

@@ -2,6 +2,8 @@ import ExpoModulesCore
 import FBSDKCoreKit
 import TikTokBusinessSDK
 import AdServices
+import AppTrackingTransparency
+import AdSupport
 
 public class DatalyrNativeModule: Module {
   private var tiktokInitialized = false
@@ -280,6 +282,44 @@ public class DatalyrNativeModule: Module {
       ])
     }
 
+    // MARK: - Advertiser Info (IDFA, IDFV, ATT Status)
+
+    AsyncFunction("getAdvertiserInfo") { (promise: Promise) in
+      var result: [String: Any] = [:]
+
+      // IDFV is always available
+      if let idfv = UIDevice.current.identifierForVendor?.uuidString {
+        result["idfv"] = idfv
+      }
+
+      // ATT status
+      if #available(iOS 14, *) {
+        let status = ATTrackingManager.trackingAuthorizationStatus
+        result["att_status"] = status.rawValue
+        result["advertiser_tracking_enabled"] = status == .authorized
+
+        // IDFA only if ATT authorized
+        if status == .authorized {
+          let idfa = ASIdentifierManager.shared().advertisingIdentifier.uuidString
+          let zeroUUID = "00000000-0000-0000-0000-000000000000"
+          if idfa != zeroUUID {
+            result["idfa"] = idfa
+          }
+        }
+      } else {
+        // Pre-iOS 14, tracking allowed by default
+        result["att_status"] = 3  // .authorized equivalent
+        result["advertiser_tracking_enabled"] = true
+        let idfa = ASIdentifierManager.shared().advertisingIdentifier.uuidString
+        let zeroUUID = "00000000-0000-0000-0000-000000000000"
+        if idfa != zeroUUID {
+          result["idfa"] = idfa
+        }
+      }
+
+      promise.resolve(result)
+    }
+
     // MARK: - Apple Search Ads Attribution
 
     AsyncFunction("getAppleSearchAdsAttribution") { (promise: Promise) in

package/lib/datalyr-sdk.d.ts

@@ -9,6 +9,7 @@ export declare class DatalyrSDK {
     private autoEventsManager;
     private appStateSubscription;
     private networkStatusUnsubscribe;
+    private cachedAdvertiserInfo;
     private static conversionEncoder?;
     private static debugEnabled;
     constructor();
@@ -33,6 +34,13 @@ export declare class DatalyrSDK {
      * Called automatically during identify() if email is provided
      */
     private fetchAndMergeWebAttribution;
+    /**
+     * Fetch deferred web attribution on first app install.
+     * Uses IP-based matching (iOS) or Play Store referrer (Android) to recover
+     * attribution data (fbclid, utm_*, etc.) from a prelander web visit.
+     * Called automatically during initialize() when a fresh install is detected.
+     */
+    private fetchDeferredWebAttribution;
     /**
      * Alias a user (connect anonymous user to known user)
      */

package/lib/datalyr-sdk.js

@@ -8,12 +8,14 @@ import { AutoEventsManager } from './auto-events';
 import { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 import { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
 import { metaIntegration, tiktokIntegration, appleSearchAdsIntegration, playInstallReferrerIntegration } from './integrations';
+import { AdvertiserInfoBridge } from './native/DatalyrNativeBridge';
 import { networkStatusManager } from './network-status';
 export class DatalyrSDK {
     constructor() {
         this.autoEventsManager = null;
         this.appStateSubscription = null;
         this.networkStatusUnsubscribe = null;
+        this.cachedAdvertiserInfo = null;
         // Initialize state with defaults
         this.state = {
             initialized: false,
@@ -26,9 +28,11 @@ export class DatalyrSDK {
                 maxRetries: 3,
                 retryDelay: 1000,
                 batchSize: 10,
-                flushInterval: 10000,
+                flushInterval: 30000,
                 maxQueueSize: 100,
                 respectDoNotTrack: true,
+                enableAutoEvents: true,
+                enableAttribution: true,
             },
             visitorId: '',
             anonymousId: '', // Persistent anonymous identifier
@@ -166,6 +170,13 @@ export class DatalyrSDK {
             }
             // Wait for all platform integrations to complete
             await Promise.all(platformInitPromises);
+            // Cache advertiser info (IDFA/GAID, ATT status) once at init to avoid per-event native bridge calls
+            try {
+                this.cachedAdvertiserInfo = await AdvertiserInfoBridge.getAdvertiserInfo();
+            }
+            catch (error) {
+                errorLog('Failed to cache advertiser info:', error);
+            }
             debugLog('Platform integrations initialized', {
                 meta: metaIntegration.isAvailable(),
                 tiktok: tiktokIntegration.isAvailable(),
@@ -176,10 +187,15 @@ export class DatalyrSDK {
             this.state.initialized = true;
             // Check for app install (after SDK is marked as initialized)
             if (attributionManager.isInstall()) {
+                // iOS: Attempt deferred web-to-app attribution via IP matching before tracking install
+                // Android: Play Store referrer is handled by playInstallReferrerIntegration
+                if (Platform.OS === 'ios') {
+                    await this.fetchDeferredWebAttribution();
+                }
                 const installData = await attributionManager.trackInstall();
                 await this.track('app_install', {
                     platform: Platform.OS === 'ios' || Platform.OS === 'android' ? Platform.OS : 'android',
-                    sdk_version: '1.0.2',
+                    sdk_version: '1.4.9',
                     ...installData,
                 });
             }
@@ -357,6 +373,77 @@ export class DatalyrSDK {
             // Non-blocking - continue even if attribution fetch fails
         }
     }
+    /**
+     * Fetch deferred web attribution on first app install.
+     * Uses IP-based matching (iOS) or Play Store referrer (Android) to recover
+     * attribution data (fbclid, utm_*, etc.) from a prelander web visit.
+     * Called automatically during initialize() when a fresh install is detected.
+     */
+    async fetchDeferredWebAttribution() {
+        var _a;
+        if (!((_a = this.state.config) === null || _a === void 0 ? void 0 : _a.apiKey)) {
+            debugLog('API key not available for deferred attribution fetch');
+            return;
+        }
+        try {
+            debugLog('Fetching deferred web attribution via IP matching...');
+            const baseUrl = this.state.config.endpoint || 'https://api.datalyr.com';
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 10000);
+            const response = await fetch(`${baseUrl}/attribution/deferred-lookup`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Datalyr-API-Key': this.state.config.apiKey,
+                },
+                body: JSON.stringify({ platform: Platform.OS }),
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            if (!response.ok) {
+                debugLog('Deferred attribution lookup failed:', response.status);
+                return;
+            }
+            const result = await response.json();
+            if (!result.found || !result.attribution) {
+                debugLog('No deferred web attribution found for this IP');
+                return;
+            }
+            const webAttribution = result.attribution;
+            debugLog('Deferred web attribution found:', {
+                visitor_id: webAttribution.visitor_id,
+                has_fbclid: !!webAttribution.fbclid,
+                has_gclid: !!webAttribution.gclid,
+                utm_source: webAttribution.utm_source,
+            });
+            // Merge web attribution into current session
+            attributionManager.mergeWebAttribution(webAttribution);
+            // Track match event for analytics
+            await this.track('$web_attribution_matched', {
+                web_visitor_id: webAttribution.visitor_id,
+                web_user_id: webAttribution.user_id,
+                fbclid: webAttribution.fbclid,
+                gclid: webAttribution.gclid,
+                ttclid: webAttribution.ttclid,
+                gbraid: webAttribution.gbraid,
+                wbraid: webAttribution.wbraid,
+                fbp: webAttribution.fbp,
+                fbc: webAttribution.fbc,
+                utm_source: webAttribution.utm_source,
+                utm_medium: webAttribution.utm_medium,
+                utm_campaign: webAttribution.utm_campaign,
+                utm_content: webAttribution.utm_content,
+                utm_term: webAttribution.utm_term,
+                web_timestamp: webAttribution.timestamp,
+                match_method: 'ip',
+            });
+            debugLog('Successfully merged deferred web attribution');
+        }
+        catch (error) {
+            errorLog('Error fetching deferred web attribution:', error);
+            // Non-blocking - email-based fallback will catch this on identify()
+        }
+    }
     /**
      * Alias a user (connect anonymous user to known user)
      */
@@ -760,6 +847,13 @@ export class DatalyrSDK {
         }
         metaIntegration.updateTrackingAuthorization(enabled);
         tiktokIntegration.updateTrackingAuthorization(enabled);
+        // Refresh cached advertiser info after ATT status change
+        try {
+            this.cachedAdvertiserInfo = await AdvertiserInfoBridge.getAdvertiserInfo();
+        }
+        catch (error) {
+            errorLog('Failed to refresh advertiser info:', error);
+        }
         // Track ATT status event
         await this.track('$att_status', {
             authorized: enabled,
@@ -835,6 +929,8 @@ export class DatalyrSDK {
             asa_conversion_type: asaAttribution.conversionType,
             asa_country_or_region: asaAttribution.countryOrRegion,
         } : {};
+        // Use cached advertiser info (IDFA/GAID, ATT status) — cached at init, refreshed on ATT change
+        const advertiserInfo = this.cachedAdvertiserInfo;
         const payload = {
             workspaceId: this.state.config.workspaceId || 'mobile_sdk',
             visitorId: this.state.visitorId,
@@ -852,8 +948,24 @@ export class DatalyrSDK {
                 device_model: deviceInfo.model,
                 app_version: deviceInfo.appVersion,
                 app_build: deviceInfo.buildNumber,
+                app_name: deviceInfo.bundleId, // Best available app name
+                app_namespace: deviceInfo.bundleId,
+                screen_width: deviceInfo.screenWidth,
+                screen_height: deviceInfo.screenHeight,
+                locale: deviceInfo.locale,
+                timezone: deviceInfo.timezone,
+                carrier: deviceInfo.carrier,
                 network_type: getNetworkType(),
                 timestamp: Date.now(),
+                sdk_version: '1.4.9',
+                // Advertiser data (IDFA/GAID, ATT status) for Meta CAPI / TikTok Events API
+                ...(advertiserInfo ? {
+                    idfa: advertiserInfo.idfa,
+                    idfv: advertiserInfo.idfv,
+                    gaid: advertiserInfo.gaid,
+                    att_status: advertiserInfo.att_status,
+                    advertiser_tracking_enabled: advertiserInfo.advertiser_tracking_enabled,
+                } : {}),
                 // Attribution data
                 ...attributionData,
                 // Apple Search Ads attribution

package/lib/event-queue.js

@@ -216,7 +216,7 @@ export const createEventQueue = (httpClient, config) => {
     const defaultConfig = {
         maxQueueSize: 100,
         batchSize: 10,
-        flushInterval: 10000, // 10 seconds
+        flushInterval: 30000, // 30 seconds — matches SDK constructor defaults and docs
         maxRetryCount: 3,
     };
     return new EventQueue(httpClient, { ...defaultConfig, ...config });

package/lib/http-client.js

@@ -45,7 +45,7 @@ export class HttpClient {
             const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
             const headers = {
                 'Content-Type': 'application/json',
-                'User-Agent': `@datalyr/react-native/1.0.2`,
+                'User-Agent': `@datalyr/react-native/1.4.8`,
             };
             // Server-side tracking uses X-API-Key header
             if (this.config.useServerTracking !== false) {
@@ -143,7 +143,7 @@ export class HttpClient {
         return {
             event: payload.eventName,
             userId: payload.userId || payload.visitorId,
-            anonymousId: payload.visitorId,
+            anonymousId: payload.anonymousId || payload.visitorId,
             properties: {
                 ...payload.eventData,
                 sessionId: payload.sessionId,
@@ -152,7 +152,7 @@ export class HttpClient {
             },
             context: {
                 library: '@datalyr/react-native',
-                version: '1.0.5',
+                version: '1.4.8',
                 source: 'mobile_app', // Explicitly set source for mobile
                 userProperties: payload.userProperties,
             },

package/lib/integrations/tiktok-integration.js

@@ -62,9 +62,12 @@ export class TikTokIntegration {
                 this.initialized = true;
                 this.log(`TikTok SDK initialized with App ID: ${config.tiktokAppId}`);
             }
+            else {
+                console.warn('[Datalyr/TikTok] TikTok SDK not initialized (accessToken may be missing). Events will still be sent server-side via Datalyr postbacks.');
+            }
         }
         catch (error) {
-            this.logError('Failed to initialize TikTok SDK:', error);
+            console.warn('[Datalyr/TikTok] TikTok SDK init failed. Events will still be sent server-side via Datalyr postbacks.', error);
         }
     }
     /**

package/lib/native/DatalyrNativeBridge.d.ts

@@ -78,6 +78,21 @@ export declare const AppleSearchAdsNativeBridge: {
      */
     getAttribution(): Promise<AppleSearchAdsAttribution | null>;
 };
+export interface AdvertiserInfo {
+    idfa?: string;
+    idfv?: string;
+    gaid?: string;
+    att_status: number;
+    advertiser_tracking_enabled: boolean;
+}
+export declare const AdvertiserInfoBridge: {
+    /**
+     * Get advertiser info (IDFA, IDFV, ATT status)
+     * IDFA is only available when ATT is authorized (iOS 14+)
+     * IDFV is always available on iOS
+     */
+    getAdvertiserInfo(): Promise<AdvertiserInfo | null>;
+};
 export declare const PlayInstallReferrerNativeBridge: {
     /**
      * Check if Play Install Referrer is available

package/lib/native/DatalyrNativeBridge.js

@@ -219,6 +219,24 @@ export const AppleSearchAdsNativeBridge = {
         }
     },
 };
+export const AdvertiserInfoBridge = {
+    /**
+     * Get advertiser info (IDFA, IDFV, ATT status)
+     * IDFA is only available when ATT is authorized (iOS 14+)
+     * IDFV is always available on iOS
+     */
+    async getAdvertiserInfo() {
+        if (!DatalyrNative)
+            return null;
+        try {
+            return await DatalyrNative.getAdvertiserInfo();
+        }
+        catch (error) {
+            console.error('[Datalyr/AdvertiserInfo] Get advertiser info failed:', error);
+            return null;
+        }
+    },
+};
 // MARK: - Play Install Referrer Bridge (Android only)
 export const PlayInstallReferrerNativeBridge = {
     /**

package/lib/native/index.d.ts

@@ -2,4 +2,5 @@
  * Native Module Exports
  */
 export { SKAdNetworkBridge } from './SKAdNetworkBridge';
-export { isNativeModuleAvailable, getSDKAvailability, MetaNativeBridge, TikTokNativeBridge, } from './DatalyrNativeBridge';
+export { isNativeModuleAvailable, getSDKAvailability, MetaNativeBridge, TikTokNativeBridge, AdvertiserInfoBridge, } from './DatalyrNativeBridge';
+export type { AdvertiserInfo } from './DatalyrNativeBridge';

package/lib/native/index.js

@@ -2,4 +2,4 @@
  * Native Module Exports
  */
 export { SKAdNetworkBridge } from './SKAdNetworkBridge';
-export { isNativeModuleAvailable, getSDKAvailability, MetaNativeBridge, TikTokNativeBridge, } from './DatalyrNativeBridge';
+export { isNativeModuleAvailable, getSDKAvailability, MetaNativeBridge, TikTokNativeBridge, AdvertiserInfoBridge, } from './DatalyrNativeBridge';

package/lib/types.d.ts

@@ -83,9 +83,9 @@ export interface DatalyrConfig {
     maxEventQueueSize?: number;
     /** Respect browser Do Not Track setting. Default: true */
     respectDoNotTrack?: boolean;
-    /** Enable automatic event tracking (sessions, app lifecycle). Default: false */
+    /** Enable automatic event tracking (sessions, app lifecycle). Default: true */
     enableAutoEvents?: boolean;
-    /** Enable attribution tracking (deep links, install referrer). Default: false */
+    /** Enable attribution tracking (deep links, install referrer). Default: true */
     enableAttribution?: boolean;
     /** Enable web-to-app attribution matching via email. Default: true */
     enableWebToAppAttribution?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datalyr/react-native",
-  "version": "1.4.8",
+  "version": "1.5.0",
   "description": "Datalyr SDK for React Native & Expo - Server-side attribution tracking with bundled Meta and TikTok SDKs for iOS and Android",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/datalyr-sdk-expo.ts

@@ -34,9 +34,9 @@ import { journeyManager } from './journey';
 import { createAutoEventsManager, AutoEventsManager } from './auto-events';
 import { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 import { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
-import { metaIntegration, tiktokIntegration, appleSearchAdsIntegration } from './integrations';
+import { metaIntegration, tiktokIntegration, appleSearchAdsIntegration, playInstallReferrerIntegration } from './integrations';
 import { DeferredDeepLinkResult } from './types';
-import { AppleSearchAdsAttribution } from './native/DatalyrNativeBridge';
+import { AppleSearchAdsAttribution, AdvertiserInfoBridge } from './native/DatalyrNativeBridge';
 
 export class DatalyrSDKExpo {
   private state: SDKState;
@@ -44,6 +44,7 @@ export class DatalyrSDKExpo {
   private eventQueue: EventQueue;
   private autoEventsManager: AutoEventsManager | null = null;
   private appStateSubscription: any = null;
+  private cachedAdvertiserInfo: any = null;
   private static conversionEncoder?: ConversionValueEncoder;
   private static debugEnabled = false;
 
@@ -59,9 +60,11 @@ export class DatalyrSDKExpo {
         maxRetries: 3,
         retryDelay: 1000,
         batchSize: 10,
-        flushInterval: 10000,
+        flushInterval: 30000,
         maxQueueSize: 100,
         respectDoNotTrack: true,
+        enableAutoEvents: true,
+        enableAttribution: true,
       },
       visitorId: '',
       anonymousId: '',
@@ -198,10 +201,22 @@ export class DatalyrSDKExpo {
 
       // Initialize Apple Search Ads attribution (iOS only, auto-fetches on init)
       await appleSearchAdsIntegration.initialize(config.debug);
+
+      // Initialize Play Install Referrer (Android only)
+      await playInstallReferrerIntegration.initialize();
+
+      // Cache advertiser info (IDFA/GAID, ATT status) once at init to avoid per-event native bridge calls
+      try {
+        this.cachedAdvertiserInfo = await AdvertiserInfoBridge.getAdvertiserInfo();
+      } catch (error) {
+        errorLog('Failed to cache advertiser info:', error as Error);
+      }
+
       debugLog('Platform integrations initialized', {
         meta: metaIntegration.isAvailable(),
         tiktok: tiktokIntegration.isAvailable(),
         appleSearchAds: appleSearchAdsIntegration.isAvailable(),
+        playInstallReferrer: playInstallReferrerIntegration.isAvailable(),
       });
 
       this.state.initialized = true;
@@ -210,7 +225,7 @@ export class DatalyrSDKExpo {
         const installData = await attributionManager.trackInstall();
         await this.track('app_install', {
           platform: Platform.OS,
-          sdk_version: '1.1.0',
+          sdk_version: '1.4.9',
           sdk_variant: 'expo',
           ...installData,
         });
@@ -694,14 +709,23 @@ export class DatalyrSDKExpo {
     return null;
   }
 
-  getPlatformIntegrationStatus(): { meta: boolean; tiktok: boolean; appleSearchAds: boolean } {
+  getPlatformIntegrationStatus(): { meta: boolean; tiktok: boolean; appleSearchAds: boolean; playInstallReferrer: boolean } {
     return {
       meta: metaIntegration.isAvailable(),
       tiktok: tiktokIntegration.isAvailable(),
       appleSearchAds: appleSearchAdsIntegration.isAvailable(),
+      playInstallReferrer: playInstallReferrerIntegration.isAvailable(),
     };
   }
 
+  /**
+   * Get Play Install Referrer data (Android only)
+   */
+  getPlayInstallReferrer(): Record<string, any> | null {
+    const data = playInstallReferrerIntegration.getReferrerData();
+    return data ? playInstallReferrerIntegration.getAttributionData() : null;
+  }
+
   /**
    * Get Apple Search Ads attribution data
    * Returns attribution if user installed via Apple Search Ads, null otherwise
@@ -717,6 +741,13 @@ export class DatalyrSDKExpo {
     if (tiktokIntegration.isAvailable()) {
       tiktokIntegration.updateTrackingAuthorization(authorized);
     }
+
+    // Refresh cached advertiser info after ATT status change
+    try {
+      this.cachedAdvertiserInfo = await AdvertiserInfoBridge.getAdvertiserInfo();
+    } catch (error) {
+      errorLog('Failed to refresh advertiser info:', error as Error);
+    }
   }
 
   private async handleDeferredDeepLink(data: DeferredDeepLinkResult): Promise<void> {
@@ -759,7 +790,7 @@ export class DatalyrSDKExpo {
     const deviceInfo = await getDeviceInfo();
     const fingerprintData = await createFingerprintData();
     const attributionData = attributionManager.getAttributionData();
-    const networkType = await getNetworkType();
+    const networkType = getNetworkType();
 
     // Get Apple Search Ads attribution if available
     const asaAttribution = appleSearchAdsIntegration.getAttributionData();
@@ -777,6 +808,9 @@ export class DatalyrSDKExpo {
       asa_country_or_region: asaAttribution.countryOrRegion,
     } : {};
 
+    // Use cached advertiser info (IDFA/GAID, ATT status) — cached at init, refreshed on ATT change
+    const advertiserInfo = this.cachedAdvertiserInfo;
+
     const payload: EventPayload = {
       workspaceId: this.state.config.workspaceId || 'mobile_sdk',
       visitorId: this.state.visitorId,
@@ -792,9 +826,25 @@ export class DatalyrSDKExpo {
         device_model: deviceInfo.model,
         app_version: deviceInfo.appVersion,
         app_build: deviceInfo.buildNumber,
+        app_name: deviceInfo.bundleId,
+        app_namespace: deviceInfo.bundleId,
+        screen_width: deviceInfo.screenWidth,
+        screen_height: deviceInfo.screenHeight,
+        locale: deviceInfo.locale,
+        timezone: deviceInfo.timezone,
+        carrier: deviceInfo.carrier,
         network_type: networkType,
         timestamp: Date.now(),
+        sdk_version: '1.4.9',
         sdk_variant: 'expo',
+        // Advertiser data (IDFA/GAID, ATT status) for Meta CAPI / TikTok Events API
+        ...(advertiserInfo ? {
+          idfa: advertiserInfo.idfa,
+          idfv: advertiserInfo.idfv,
+          gaid: advertiserInfo.gaid,
+          att_status: advertiserInfo.att_status,
+          advertiser_tracking_enabled: advertiserInfo.advertiser_tracking_enabled,
+        } : {}),
         ...attributionData,
         // Apple Search Ads attribution
         ...asaData,
@@ -1030,10 +1080,14 @@ export class DatalyrExpo {
     return datalyrExpo.getDeferredAttributionData();
   }
 
-  static getPlatformIntegrationStatus(): { meta: boolean; tiktok: boolean; appleSearchAds: boolean } {
+  static getPlatformIntegrationStatus(): { meta: boolean; tiktok: boolean; appleSearchAds: boolean; playInstallReferrer: boolean } {
     return datalyrExpo.getPlatformIntegrationStatus();
   }
 
+  static getPlayInstallReferrer(): Record<string, any> | null {
+    return datalyrExpo.getPlayInstallReferrer();
+  }
+
   static getAppleSearchAdsAttribution(): AppleSearchAdsAttribution | null {
     return datalyrExpo.getAppleSearchAdsAttribution();
   }

package/src/datalyr-sdk.ts

@@ -32,7 +32,7 @@ import { createAutoEventsManager, AutoEventsManager, SessionData } from './auto-
 import { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 import { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
 import { metaIntegration, tiktokIntegration, appleSearchAdsIntegration, playInstallReferrerIntegration } from './integrations';
-import { AppleSearchAdsAttribution } from './native/DatalyrNativeBridge';
+import { AppleSearchAdsAttribution, AdvertiserInfoBridge } from './native/DatalyrNativeBridge';
 import { networkStatusManager } from './network-status';
 
 export class DatalyrSDK {
@@ -42,6 +42,7 @@ export class DatalyrSDK {
   private autoEventsManager: AutoEventsManager | null = null;
   private appStateSubscription: any = null;
   private networkStatusUnsubscribe: (() => void) | null = null;
+  private cachedAdvertiserInfo: any = null;
   private static conversionEncoder?: ConversionValueEncoder;
   private static debugEnabled = false;
 
@@ -58,9 +59,11 @@ export class DatalyrSDK {
         maxRetries: 3,
         retryDelay: 1000,
         batchSize: 10,
-        flushInterval: 10000,
+        flushInterval: 30000,
         maxQueueSize: 100,
         respectDoNotTrack: true,
+        enableAutoEvents: true,
+        enableAttribution: true,
       },
       visitorId: '',
       anonymousId: '',  // Persistent anonymous identifier
@@ -221,6 +224,13 @@ export class DatalyrSDK {
       // Wait for all platform integrations to complete
       await Promise.all(platformInitPromises);
 
+      // Cache advertiser info (IDFA/GAID, ATT status) once at init to avoid per-event native bridge calls
+      try {
+        this.cachedAdvertiserInfo = await AdvertiserInfoBridge.getAdvertiserInfo();
+      } catch (error) {
+        errorLog('Failed to cache advertiser info:', error as Error);
+      }
+
       debugLog('Platform integrations initialized', {
         meta: metaIntegration.isAvailable(),
         tiktok: tiktokIntegration.isAvailable(),
@@ -233,10 +243,16 @@ export class DatalyrSDK {
 
       // Check for app install (after SDK is marked as initialized)
       if (attributionManager.isInstall()) {
+        // iOS: Attempt deferred web-to-app attribution via IP matching before tracking install
+        // Android: Play Store referrer is handled by playInstallReferrerIntegration
+        if (Platform.OS === 'ios') {
+          await this.fetchDeferredWebAttribution();
+        }
+
         const installData = await attributionManager.trackInstall();
         await this.track('app_install', {
           platform: Platform.OS === 'ios' || Platform.OS === 'android' ? Platform.OS : 'android',
-          sdk_version: '1.0.2',
+          sdk_version: '1.4.9',
           ...installData,
         });
       }
@@ -443,6 +459,88 @@ export class DatalyrSDK {
     }
   }
 
+  /**
+   * Fetch deferred web attribution on first app install.
+   * Uses IP-based matching (iOS) or Play Store referrer (Android) to recover
+   * attribution data (fbclid, utm_*, etc.) from a prelander web visit.
+   * Called automatically during initialize() when a fresh install is detected.
+   */
+  private async fetchDeferredWebAttribution(): Promise<void> {
+    if (!this.state.config?.apiKey) {
+      debugLog('API key not available for deferred attribution fetch');
+      return;
+    }
+
+    try {
+      debugLog('Fetching deferred web attribution via IP matching...');
+
+      const baseUrl = this.state.config.endpoint || 'https://api.datalyr.com';
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 10000);
+
+      const response = await fetch(`${baseUrl}/attribution/deferred-lookup`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Datalyr-API-Key': this.state.config.apiKey,
+        },
+        body: JSON.stringify({ platform: Platform.OS }),
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeout);
+
+      if (!response.ok) {
+        debugLog('Deferred attribution lookup failed:', response.status);
+        return;
+      }
+
+      const result = await response.json() as { found: boolean; attribution?: any };
+
+      if (!result.found || !result.attribution) {
+        debugLog('No deferred web attribution found for this IP');
+        return;
+      }
+
+      const webAttribution = result.attribution;
+      debugLog('Deferred web attribution found:', {
+        visitor_id: webAttribution.visitor_id,
+        has_fbclid: !!webAttribution.fbclid,
+        has_gclid: !!webAttribution.gclid,
+        utm_source: webAttribution.utm_source,
+      });
+
+      // Merge web attribution into current session
+      attributionManager.mergeWebAttribution(webAttribution);
+
+      // Track match event for analytics
+      await this.track('$web_attribution_matched', {
+        web_visitor_id: webAttribution.visitor_id,
+        web_user_id: webAttribution.user_id,
+        fbclid: webAttribution.fbclid,
+        gclid: webAttribution.gclid,
+        ttclid: webAttribution.ttclid,
+        gbraid: webAttribution.gbraid,
+        wbraid: webAttribution.wbraid,
+        fbp: webAttribution.fbp,
+        fbc: webAttribution.fbc,
+        utm_source: webAttribution.utm_source,
+        utm_medium: webAttribution.utm_medium,
+        utm_campaign: webAttribution.utm_campaign,
+        utm_content: webAttribution.utm_content,
+        utm_term: webAttribution.utm_term,
+        web_timestamp: webAttribution.timestamp,
+        match_method: 'ip',
+      });
+
+      debugLog('Successfully merged deferred web attribution');
+
+    } catch (error) {
+      errorLog('Error fetching deferred web attribution:', error as Error);
+      // Non-blocking - email-based fallback will catch this on identify()
+    }
+  }
+
   /**
    * Alias a user (connect anonymous user to known user)
    */
@@ -939,6 +1037,13 @@ export class DatalyrSDK {
     metaIntegration.updateTrackingAuthorization(enabled);
     tiktokIntegration.updateTrackingAuthorization(enabled);
 
+    // Refresh cached advertiser info after ATT status change
+    try {
+      this.cachedAdvertiserInfo = await AdvertiserInfoBridge.getAdvertiserInfo();
+    } catch (error) {
+      errorLog('Failed to refresh advertiser info:', error as Error);
+    }
+
     // Track ATT status event
     await this.track('$att_status', {
       authorized: enabled,
@@ -1022,6 +1127,9 @@ export class DatalyrSDK {
       asa_country_or_region: asaAttribution.countryOrRegion,
     } : {};
 
+    // Use cached advertiser info (IDFA/GAID, ATT status) — cached at init, refreshed on ATT change
+    const advertiserInfo = this.cachedAdvertiserInfo;
+
     const payload: EventPayload = {
       workspaceId: this.state.config.workspaceId || 'mobile_sdk',
       visitorId: this.state.visitorId,
@@ -1039,8 +1147,24 @@ export class DatalyrSDK {
         device_model: deviceInfo.model,
         app_version: deviceInfo.appVersion,
         app_build: deviceInfo.buildNumber,
+        app_name: deviceInfo.bundleId,  // Best available app name
+        app_namespace: deviceInfo.bundleId,
+        screen_width: deviceInfo.screenWidth,
+        screen_height: deviceInfo.screenHeight,
+        locale: deviceInfo.locale,
+        timezone: deviceInfo.timezone,
+        carrier: deviceInfo.carrier,
         network_type: getNetworkType(),
         timestamp: Date.now(),
+        sdk_version: '1.4.9',
+        // Advertiser data (IDFA/GAID, ATT status) for Meta CAPI / TikTok Events API
+        ...(advertiserInfo ? {
+          idfa: advertiserInfo.idfa,
+          idfv: advertiserInfo.idfv,
+          gaid: advertiserInfo.gaid,
+          att_status: advertiserInfo.att_status,
+          advertiser_tracking_enabled: advertiserInfo.advertiser_tracking_enabled,
+        } : {}),
         // Attribution data
         ...attributionData,
         // Apple Search Ads attribution

package/src/event-queue.ts

@@ -262,7 +262,7 @@ export const createEventQueue = (httpClient: HttpClient, config?: Partial<QueueC
   const defaultConfig: QueueConfig = {
     maxQueueSize: 100,
     batchSize: 10,
-    flushInterval: 10000, // 10 seconds
+    flushInterval: 30000, // 30 seconds — matches SDK constructor defaults and docs
     maxRetryCount: 3,
   };
 

package/src/http-client.ts

@@ -72,7 +72,7 @@ export class HttpClient {
       
       const headers: Record<string, string> = {
         'Content-Type': 'application/json',
-        'User-Agent': `@datalyr/react-native/1.0.2`,
+        'User-Agent': `@datalyr/react-native/1.4.8`,
       };
 
       // Server-side tracking uses X-API-Key header
@@ -188,7 +188,7 @@ export class HttpClient {
     return {
       event: payload.eventName,
       userId: payload.userId || payload.visitorId,
-      anonymousId: payload.visitorId,
+      anonymousId: payload.anonymousId || payload.visitorId,
       properties: {
         ...payload.eventData,
         sessionId: payload.sessionId,
@@ -197,7 +197,7 @@ export class HttpClient {
       },
       context: {
         library: '@datalyr/react-native',
-        version: '1.0.5',
+        version: '1.4.8',
         source: 'mobile_app',  // Explicitly set source for mobile
         userProperties: payload.userProperties,
       },

package/src/integrations/tiktok-integration.ts

@@ -76,9 +76,11 @@ export class TikTokIntegration {
       if (success) {
         this.initialized = true;
         this.log(`TikTok SDK initialized with App ID: ${config.tiktokAppId}`);
+      } else {
+        console.warn('[Datalyr/TikTok] TikTok SDK not initialized (accessToken may be missing). Events will still be sent server-side via Datalyr postbacks.');
       }
     } catch (error) {
-      this.logError('Failed to initialize TikTok SDK:', error);
+      console.warn('[Datalyr/TikTok] TikTok SDK init failed. Events will still be sent server-side via Datalyr postbacks.', error);
     }
   }
 

package/src/native/DatalyrNativeBridge.ts

@@ -90,6 +90,15 @@ interface DatalyrNativeModule {
   logoutTikTok(): Promise<boolean>;
   updateTikTokTrackingAuthorization(enabled: boolean): Promise<boolean>;
 
+  // Advertiser Info (IDFA, IDFV, GAID, ATT Status)
+  getAdvertiserInfo(): Promise<{
+    idfa?: string;
+    idfv?: string;
+    gaid?: string;
+    att_status: number;
+    advertiser_tracking_enabled: boolean;
+  } | null>;
+
   // Apple Search Ads Methods (iOS only)
   getAppleSearchAdsAttribution(): Promise<AppleSearchAdsAttribution | null>;
 
@@ -374,6 +383,34 @@ export const AppleSearchAdsNativeBridge = {
   },
 };
 
+// MARK: - Advertiser Info Bridge
+
+export interface AdvertiserInfo {
+  idfa?: string;
+  idfv?: string;
+  gaid?: string;
+  att_status: number;
+  advertiser_tracking_enabled: boolean;
+}
+
+export const AdvertiserInfoBridge = {
+  /**
+   * Get advertiser info (IDFA, IDFV, ATT status)
+   * IDFA is only available when ATT is authorized (iOS 14+)
+   * IDFV is always available on iOS
+   */
+  async getAdvertiserInfo(): Promise<AdvertiserInfo | null> {
+    if (!DatalyrNative) return null;
+
+    try {
+      return await DatalyrNative.getAdvertiserInfo();
+    } catch (error) {
+      console.error('[Datalyr/AdvertiserInfo] Get advertiser info failed:', error);
+      return null;
+    }
+  },
+};
+
 // MARK: - Play Install Referrer Bridge (Android only)
 
 export const PlayInstallReferrerNativeBridge = {

package/src/native/index.ts

@@ -8,4 +8,6 @@ export {
   getSDKAvailability,
   MetaNativeBridge,
   TikTokNativeBridge,
+  AdvertiserInfoBridge,
 } from './DatalyrNativeBridge';
+export type { AdvertiserInfo } from './DatalyrNativeBridge';

package/src/types.ts

@@ -105,10 +105,10 @@ export interface DatalyrConfig {
   /** Respect browser Do Not Track setting. Default: true */
   respectDoNotTrack?: boolean;
 
-  /** Enable automatic event tracking (sessions, app lifecycle). Default: false */
+  /** Enable automatic event tracking (sessions, app lifecycle). Default: true */
   enableAutoEvents?: boolean;
 
-  /** Enable attribution tracking (deep links, install referrer). Default: false */
+  /** Enable attribution tracking (deep links, install referrer). Default: true */
   enableAttribution?: boolean;
 
   /** Enable web-to-app attribution matching via email. Default: true */

package/src/utils-expo.ts

@@ -1,5 +1,5 @@
 import AsyncStorage from '@react-native-async-storage/async-storage';
-import { Platform } from 'react-native';
+import { Platform, Dimensions } from 'react-native';
 import * as Application from 'expo-application';
 import * as Device from 'expo-device';
 import * as Network from 'expo-network';
@@ -84,10 +84,14 @@ export interface DeviceInfo {
   isEmulator: boolean;
 }
 
-export const getDeviceInfo = async (): Promise<DeviceInfo> => {
+// Cached device info to avoid repeated async calls (matches utils.ts pattern)
+let cachedDeviceInfo: DeviceInfo | null = null;
+let deviceInfoPromise: Promise<DeviceInfo> | null = null;
+
+const fetchDeviceInfoInternal = async (): Promise<DeviceInfo> => {
   try {
     const deviceId = await getOrCreateDeviceId();
-    
+
     return {
       deviceId,
       model: Device.modelName || Device.deviceName || 'Unknown',
@@ -96,10 +100,10 @@ export const getDeviceInfo = async (): Promise<DeviceInfo> => {
       appVersion: Application.nativeApplicationVersion || '1.0.0',
       buildNumber: Application.nativeBuildVersion || '1',
       bundleId: Application.applicationId || 'unknown.bundle.id',
-      screenWidth: 0, // Would need Dimensions from react-native
-      screenHeight: 0, // Would need Dimensions from react-native  
+      screenWidth: Dimensions.get('window').width,
+      screenHeight: Dimensions.get('window').height,
       timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-      locale: 'en-US', // Would need expo-localization for full locale
+      locale: Intl.DateTimeFormat().resolvedOptions().locale || 'en-US',
       carrier: undefined, // Not available in Expo managed workflow
       isEmulator: !Device.isDevice,
     };
@@ -113,8 +117,8 @@ export const getDeviceInfo = async (): Promise<DeviceInfo> => {
       appVersion: '1.0.0',
       buildNumber: '1',
       bundleId: 'unknown.bundle.id',
-      screenWidth: 0,
-      screenHeight: 0,
+      screenWidth: Dimensions.get('window').width,
+      screenHeight: Dimensions.get('window').height,
       timezone: 'UTC',
       locale: 'en-US',
       isEmulator: true,
@@ -122,6 +126,19 @@ export const getDeviceInfo = async (): Promise<DeviceInfo> => {
   }
 };
 
+export const getDeviceInfo = async (): Promise<DeviceInfo> => {
+  if (cachedDeviceInfo) return cachedDeviceInfo;
+  if (deviceInfoPromise) return deviceInfoPromise;
+
+  deviceInfoPromise = fetchDeviceInfoInternal();
+  try {
+    cachedDeviceInfo = await deviceInfoPromise;
+    return cachedDeviceInfo;
+  } finally {
+    deviceInfoPromise = null;
+  }
+};
+
 // Device ID management
 const getOrCreateDeviceId = async (): Promise<string> => {
   try {
@@ -246,30 +263,49 @@ export const createFingerprintData = async () => {
 // IDFA/GAID collection has been removed for privacy compliance
 // Modern attribution tracking relies on privacy-safe methods:
 
-// Network type detection using Expo Network
-export const getNetworkType = async (): Promise<string> => {
+// Cached network type to avoid per-event native bridge calls
+let cachedNetworkType = 'unknown';
+let networkTypeLastFetched = 0;
+const NETWORK_TYPE_CACHE_MS = 30000; // Refresh every 30s
+
+// Network type detection using Expo Network — cached to avoid per-event async calls
+export const getNetworkType = (): string => {
+  // Trigger background refresh if stale, but always return cached value synchronously
+  const now = Date.now();
+  if (now - networkTypeLastFetched > NETWORK_TYPE_CACHE_MS) {
+    networkTypeLastFetched = now;
+    refreshNetworkType();
+  }
+  return cachedNetworkType;
+};
+
+const refreshNetworkType = async (): Promise<void> => {
   try {
     const networkState = await Network.getNetworkStateAsync();
-    
+
     if (!networkState.isConnected) {
-      return 'none';
+      cachedNetworkType = 'none';
+      return;
     }
-    
+
     switch (networkState.type) {
       case Network.NetworkStateType.WIFI:
-        return 'wifi';
+        cachedNetworkType = 'wifi';
+        break;
       case Network.NetworkStateType.CELLULAR:
-        return 'cellular';
+        cachedNetworkType = 'cellular';
+        break;
       case Network.NetworkStateType.ETHERNET:
-        return 'ethernet';
+        cachedNetworkType = 'ethernet';
+        break;
       case Network.NetworkStateType.BLUETOOTH:
-        return 'bluetooth';
+        cachedNetworkType = 'bluetooth';
+        break;
       default:
-        return 'unknown';
+        cachedNetworkType = 'unknown';
     }
   } catch (error) {
     debugLog('Error getting network type:', error);
-    return 'unknown';
   }
 };