AppsFlyer : Guide complet pour l'attribution et le deep linking mobile

AppsFlyer est la plateforme leader mondiale d'attribution mobile et de marketing analytics, utilisée par plus de 12 000 marques (Nike, Uber, HBO...). Elle permet de tracer l'origine de chaque installation d'app, mesurer le ROI des campagnes, et créer des expériences utilisateur fluides via le deep linking.

Chez VOID, nous intégrons AppsFlyer sur des projets bancaires, e-commerce et médias pour optimiser l'acquisition mobile et réduire le coût par installation (CPI) de 30-50%.

Pourquoi utiliser AppsFlyer ?

1. Attribution multi-touch précise

AppsFlyer identifie quelle campagne (Facebook Ads, Google UAC, influenceur, email...) a généré une installation, même dans un parcours complexe avec plusieurs points de contact.

• Last-click attribution : crédit au dernier point de contact
• Multi-touch attribution : pondération entre plusieurs canaux
• View-through attribution : comptabiliser les impressions pub (pas seulement les clics)
• Probabilistic + Deterministic matching : 98% de précision (vs. 60-70% pour Google Analytics)

2. Protection contre la fraude publicitaire

AppsFlyer détecte et bloque automatiquement :

• Install hijacking : fausses attributions par des réseaux malveillants
• Click flooding : clics robots massifs pour voler l'attribution
• SDK spoofing : installations simulées sans réelle installation
• Device farms : fermes de téléphones générant de fausses conversions

Impact : Économie moyenne de 15-25% du budget pub mobile (source : AppsFlyer Fraud Report 2024).

3. Deep linking intelligent

Amener l'utilisateur exactement où vous voulez dans l'app, depuis n'importe quelle source (email, SMS, pub, QR code, site web).

• Deep Link : ouvre l'app sur un écran spécifique (ex : page produit) si l'app est installée
• Deferred Deep Link : redirige vers le store → installe l'app → ouvre l'écran ciblé au 1er lancement
• Web-to-App : bascule fluide du site mobile vers l'app (sans perdre le contexte)

4. Analytics temps réel et cohortes

• Dashboard centralisé (installations, revenus, ROI par canal)
• Analyse de cohortes (retention J1, J7, J30 par source)
• LTV (Lifetime Value) prédictif par segment
• A/B testing de campagnes en temps réel

Concepts clés : OneLink, Short Link vs Long Link

OneLink : un lien unique pour iOS + Android + Web

OneLink est la technologie propriétaire AppsFlyer qui génère un lien universel fonctionnant sur tous les devices :

• iOS : redirige vers l'App Store (ou ouvre l'app si installée)
• Android : redirige vers le Google Play Store (ou ouvre l'app)
• Desktop : affiche une landing page web avec QR code / boutons de téléchargement

Exemple de OneLink :

https://yourapp.onelink.me/AbCd/promo-noel

Fonctionnement intelligent :

1. L'utilisateur clique sur le lien
2. AppsFlyer détecte l'OS et l'état de l'app (installée ou non)
3. Redirection intelligente :
   • App installée → ouverture directe avec deep link
   • App non installée → store → deferred deep link après installation
4. Attribution automatique de l'installation/événement à la campagne source

Short Link vs Long Link

Long Link (paramètres visibles)

Format standard avec tous les paramètres en query string :

https://yourapp.onelink.me/AbCd?pid=facebook&c=black_friday&af_dp=yourapp://product/12345&af_web_dp=https://yoursite.com/product/12345

Paramètres standards :

• pid : Media source (facebook, google, email...)
• c : Campaign name (black_friday, summer_sale...)
• af_adset : Ad set name
• af_ad : Ad creative name
• af_dp : Deep link (URI scheme de l'app)
• af_web_dp : Fallback URL web si l'app n'est pas installée
• af_sub1 à af_sub5 : Paramètres custom (user_id, promo_code...)

✅ Avantages Long Link :

• Paramètres lisibles (debug facile)
• Modification manuelle possible (test rapide)
• Pas de limite de création (génération côté client)

❌ Inconvénients :

• URL longue et moche (mauvais pour SMS, réseaux sociaux)
• Paramètres exposés (risque de manipulation)
• Moins de clics (URL non brandée)

Short Link (URL raccourcie brandée)

Format court, brandé, masquant les paramètres :

https://yourapp.onelink.me/AbCd/bf2024

Derrière cette URL courte, AppsFlyer stocke tous les paramètres (pid, campaign, deep link, custom params...).

✅ Avantages Short Link :

• URL courte : idéal pour SMS (160 caractères), Twitter, QR codes
• Brandée : yourapp.onelink.me (confiance utilisateur)
• Paramètres cachés : pas de manipulation possible
• Suivi des clics : analytics détaillés par lien
• Modifiable après création : changer la destination sans changer l'URL

❌ Inconvénients :

• Nécessite création via API ou dashboard AppsFlyer
• Quota limité selon votre plan (ex : 10 000 liens/mois sur plan Growth)

Quand utiliser Short vs Long Link ?

Cas d'usage	Short Link	Long Link
SMS marketing	✅ Obligatoire	❌ Trop long
QR codes	✅ URL courte = QR simple	⚠️ QR complexe
Réseaux sociaux	✅ Esthétique	❌ URL moche
Email	✅ Préférable	✅ Acceptable
Pub display/video	✅ Tracking précis	✅ Les deux OK
Deep link dynamique	⚠️ Nécessite API	✅ Génération côté client
Debug / Test	❌ Paramètres cachés	✅ Paramètres visibles

Recommandation VOID : Utilisez Short Links pour toute communication externe (marketing, CRM), et Long Links pour la génération dynamique côté app/site (profils utilisateur, partage social in-app).

Générer des liens en masse

Méthode 1 : OneLink API (recommandé pour production)

AppsFlyer expose une API REST pour créer des Short Links programmatiquement.

Endpoint : Create Short Link

POST https://api2.appsflyer.com/v2.0/app/{app_id}/onelink
Authorization: Bearer YOUR_API_TOKEN
Content-Type: application/json

{
  "onelink_id": "AbCd",
  "data": {
    "pid": "email",
    "c": "newsletter_janvier_2025",
    "af_dp": "yourapp://product/12345",
    "af_sub1": "user_7890"
  },
  "brand_domain": "yourapp.onelink.me"
}

Réponse :

{
  "short_link": "https://yourapp.onelink.me/AbCd/jan2025xyz",
  "onelink_id": "AbCd",
  "ttl": null
}

Script Node.js : génération de 10 000 liens

const axios = require('axios');
const csv = require('csv-parser');
const fs = require('fs');

const APPSFLYER_API = 'https://api2.appsflyer.com/v2.0/app';
const APP_ID = 'com.yourapp.mobile'; // Bundle ID iOS ou package Android
const ONELINK_ID = 'AbCd';
const API_TOKEN = 'YOUR_API_TOKEN'; // Généré dans AppsFlyer dashboard

async function createShortLink(params) {
  try {
    const response = await axios.post(
      `${APPSFLYER_API}/${APP_ID}/onelink`,
      {
        onelink_id: ONELINK_ID,
        data: params,
        brand_domain: 'yourapp.onelink.me'
      },
      {
        headers: {
          'Authorization': `Bearer ${API_TOKEN}`,
          'Content-Type': 'application/json'
        }
      }
    );
    return response.data.short_link;
  } catch (error) {
    console.error('Erreur création lien:', error.response?.data);
    return null;
  }
}

async function generateBulkLinks() {
  const links = [];
  
  // Lecture CSV avec 10 000 lignes (user_id, product_id, campaign)
  fs.createReadStream('users.csv')
    .pipe(csv())
    .on('data', async (row) => {
      const shortLink = await createShortLink({
        pid: 'crm',
        c: row.campaign,
        af_dp: `yourapp://product/${row.product_id}`,
        af_sub1: row.user_id,
        af_sub2: row.segment
      });
      
      if (shortLink) {
        links.push({ user_id: row.user_id, link: shortLink });
        console.log(`✅ Lien créé pour user ${row.user_id}: ${shortLink}`);
      }
      
      // Rate limiting : 100 requêtes/min
      await new Promise(resolve => setTimeout(resolve, 600));
    })
    .on('end', () => {
      // Export CSV final
      const output = links.map(l => `${l.user_id},${l.link}`).join('\n');
      fs.writeFileSync('links_generated.csv', output);
      console.log(`🎉 ${links.length} liens générés !`);
    });
}

generateBulkLinks();

Optimisations pour génération massive :

• Batch requests : regrouper 100 liens par requête (si supporté par votre plan)
• Workers parallèles : utiliser 5-10 workers Node.js simultanés
• Redis cache : stocker les liens déjà générés (éviter duplicatas)
• Retry logic : relancer automatiquement en cas d'erreur 5xx

Méthode 2 : Long Links générés côté client (illimité)

Pour des besoins dynamiques (ex : bouton "Partager ce produit" dans l'app), générez des Long Links côté client sans appeler l'API AppsFlyer.

// React Native : génération de Long Link
function generateDeepLink(productId, userId) {
  const baseUrl = 'https://yourapp.onelink.me/AbCd';
  const params = new URLSearchParams({
    pid: 'user_referral',
    c: 'in_app_share',
    af_dp: `yourapp://product/${productId}`,
    af_web_dp: `https://yoursite.com/product/${productId}`,
    af_sub1: userId,
    af_sub2: new Date().toISOString()
  });
  
  return `${baseUrl}?${params.toString()}`;
}

// Utilisation
const shareLink = generateDeepLink('12345', 'user_7890');
// https://yourapp.onelink.me/AbCd?pid=user_referral&c=in_app_share&af_dp=yourapp://product/12345&af_sub1=user_7890...

✅ Avantage : génération instantanée, illimitée, offline-first.

❌ Inconvénient : URL longue (mais fonctionnelle pour partage programmatique).

Deep Link vs Deferred Deep Link

Deep Link (app déjà installée)

Scénario : L'utilisateur clique sur un lien marketing alors que l'app est déjà installée.

Flux :

1. Clic sur https://yourapp.onelink.me/AbCd/promo-noel
2. AppsFlyer détecte que l'app est installée
3. Ouverture immédiate de l'app via URI scheme ou Universal Link (iOS) / App Link (Android)
4. L'app reçoit les paramètres : { deep_link_value: "promo-noel", campaign: "email_noel" }
5. Navigation vers l'écran ciblé (ex : page promo Noël)

Implémentation (pseudo-code) :

// L'app intercepte le deep link au démarrage
onDeepLinkReceived((data) => {
  if (data.deep_link_value === 'promo-noel') {
    navigation.navigate('PromoScreen', { campaign: data.campaign });
  } else if (data.deep_link_value.startsWith('product/')) {
    const productId = data.deep_link_value.split('/')[1];
    navigation.navigate('ProductScreen', { id: productId });
  }
});

Deferred Deep Link (app non installée)

Scénario : L'utilisateur clique sur un lien marketing, l'app n'est pas installée.

Flux :

1. Clic sur https://yourapp.onelink.me/AbCd/promo-noel
2. AppsFlyer détecte que l'app n'est pas installée
3. Redirection vers l'App Store / Play Store
4. AppsFlyer stocke les paramètres du lien (device fingerprint + IDFA/GAID)
5. L'utilisateur installe l'app
6. Au 1er lancement, le SDK AppsFlyer récupère les paramètres stockés
7. L'app navigue automatiquement vers l'écran ciblé (promo Noël)

Magie du Deferred Deep Link : L'utilisateur voit la promo Noël immédiatement après avoir ouvert l'app pour la 1ère fois, sans avoir à chercher.

Impact business :

• +40% de conversion (vs. landing sur home générique)
• -60% de taux d'abandon onboarding
• +25% de retention J1 (expérience personnalisée dès le départ)

Différences techniques

Critère	Deep Link	Deferred Deep Link
App installée ?	✅ Oui	❌ Non
Redirection store ?	❌ Non	✅ Oui
Moment d'exécution	Immédiat (au clic)	Différé (au 1er lancement)
Matching	Direct (URI scheme)	Probabiliste (fingerprint) ou IDFA/GAID
Précision	100%	95-98% (peut échouer si changement de réseau)
Délai	<1s	Dépend du temps d'installation

Implémentation : React Native

Étape 1 : Installation du SDK

# NPM
npm install react-native-appsflyer --save

# Yarn
yarn add react-native-appsflyer

# Link automatique (React Native 0.60+)
cd ios && pod install && cd ..

Étape 2 : Configuration iOS (Info.plist)

<key>CFBundleURLTypes</key>
<array>
  <dict>
    <key>CFBundleURLSchemes</key>
    <array>
      <string>yourapp</string>
    </array>
  </dict>
</array>

<!-- Universal Links (iOS 9+) -->
<key>com.apple.developer.associated-domains</key>
<array>
  <string>applinks:yourapp.onelink.me</string>
</array>

Étape 3 : Configuration Android (AndroidManifest.xml)

<activity android:name=".MainActivity">
  <!-- URI Scheme -->
  <intent-filter>
    <action android:name="android.intent.action.VIEW" />
    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />
    <data android:scheme="yourapp" />
  </intent-filter>

  <!-- App Links (Android 6+) -->
  <intent-filter android:autoVerify="true">
    <action android:name="android.intent.action.VIEW" />
    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />
    <data android:scheme="https" android:host="yourapp.onelink.me" />
  </intent-filter>
</activity>

Étape 4 : Initialisation du SDK (App.tsx)

import React, { useEffect } from 'react';
import appsFlyer from 'react-native-appsflyer';

const App = () => {
  useEffect(() => {
    // Configuration AppsFlyer
    appsFlyer.initSdk(
      {
        devKey: 'YOUR_DEV_KEY', // Clé API AppsFlyer
        isDebug: __DEV__, // Logs en mode dev
        appId: '123456789', // iOS App ID (6 chiffres de l'App Store)
        onInstallConversionDataListener: true, // Deferred Deep Link
        onDeepLinkListener: true, // Deep Link classique
        timeToWaitForATTUserAuthorization: 10, // iOS 14+ ATT prompt
      },
      (result) => {
        console.log('✅ AppsFlyer initialized:', result);
      },
      (error) => {
        console.error('❌ AppsFlyer init error:', error);
      }
    );

    // Listener pour Deferred Deep Link (1er lancement)
    appsFlyer.onInstallConversionData((data) => {
      console.log('📦 Install Conversion Data:', data);
      
      if (data?.data?.is_first_launch === true) {
        const deepLinkValue = data.data.deep_link_value;
        const campaign = data.data.campaign;
        
        console.log(`🎯 Deferred Deep Link: ${deepLinkValue}`);
        
        // Navigation vers l'écran ciblé
        if (deepLinkValue === 'promo-noel') {
          navigation.navigate('PromoScreen', { campaign });
        } else if (deepLinkValue?.startsWith('product/')) {
          const productId = deepLinkValue.split('/')[1];
          navigation.navigate('ProductScreen', { id: productId });
        }
      }
    });

    // Listener pour Deep Link (app déjà installée)
    appsFlyer.onDeepLink((data) => {
      console.log('🔗 Deep Link:', data);
      
      if (data?.deepLinkStatus === 'FOUND') {
        const deepLinkValue = data.data.deep_link_value;
        
        // Même logique de navigation
        if (deepLinkValue === 'promo-noel') {
          navigation.navigate('PromoScreen');
        } else if (deepLinkValue?.startsWith('product/')) {
          const productId = deepLinkValue.split('/')[1];
          navigation.navigate('ProductScreen', { id: productId });
        }
      }
    });
  }, []);

  return ;
};

export default App;

Étape 5 : Tracking d'événements custom

import appsFlyer from 'react-native-appsflyer';

// Event : Achat complété
appsFlyer.logEvent('af_purchase', {
  af_revenue: 49.99,
  af_currency: 'EUR',
  af_order_id: 'ORDER_12345',
  af_content_id: 'PRODUCT_67890',
  af_quantity: 2,
  custom_param: 'black_friday'
});

// Event : Ajout au panier
appsFlyer.logEvent('af_add_to_cart', {
  af_content_id: 'PRODUCT_67890',
  af_price: 24.99,
  af_currency: 'EUR'
});

// Event custom métier
appsFlyer.logEvent('user_completed_onboarding', {
  user_segment: 'premium',
  source: 'facebook_ad'
});

Implémentation : iOS natif (Swift)

Étape 1 : Installation via CocoaPods

# Podfile
pod 'AppsFlyerFramework'

# Terminal
pod install

Étape 2 : Configuration AppDelegate.swift

import UIKit
import AppsFlyerLib

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        
        // Configuration AppsFlyer
        AppsFlyerLib.shared().appsFlyerDevKey = "YOUR_DEV_KEY"
        AppsFlyerLib.shared().appleAppID = "123456789"
        AppsFlyerLib.shared().isDebug = true
        AppsFlyerLib.shared().delegate = self
        
        // Deep Link Delegate
        AppsFlyerLib.shared().deepLinkDelegate = self
        
        return true
    }
    
    // Universal Links (iOS 9+)
    func application(
        _ application: UIApplication,
        continue userActivity: NSUserActivity,
        restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
    ) -> Bool {
        AppsFlyerLib.shared().continue(userActivity, restorationHandler: nil)
        return true
    }
    
    // URI Scheme
    func application(
        _ app: UIApplication,
        open url: URL,
        options: [UIApplication.OpenURLOptionsKey : Any] = [:]
    ) -> Bool {
        AppsFlyerLib.shared().handleOpen(url, options: options)
        return true
    }
}

// MARK: - AppsFlyerLibDelegate
extension AppDelegate: AppsFlyerLibDelegate {
    
    // Deferred Deep Link (1er lancement)
    func onConversionDataSuccess(_ conversionInfo: [AnyHashable : Any]) {
        print("📦 Conversion Data: \(conversionInfo)")
        
        if let status = conversionInfo["af_status"] as? String,
           status == "Non-organic" {
            
            if let isFirstLaunch = conversionInfo["is_first_launch"] as? Bool,
               isFirstLaunch {
                
                // Deep Link Value
                if let deepLinkValue = conversionInfo["deep_link_value"] as? String {
                    print("🎯 Deferred Deep Link: \(deepLinkValue)")
                    handleDeepLink(deepLinkValue)
                }
            }
        }
    }
    
    func onConversionDataFail(_ error: Error) {
        print("❌ Conversion Data Error: \(error)")
    }
}

// MARK: - DeepLinkDelegate
extension AppDelegate: DeepLinkDelegate {
    
    // Deep Link (app déjà installée)
    func didResolveDeepLink(_ result: DeepLinkResult) {
        switch result.status {
        case .found:
            guard let deepLinkValue = result.deepLink?.deeplinkValue else { return }
            print("🔗 Deep Link: \(deepLinkValue)")
            handleDeepLink(deepLinkValue)
            
        case .notFound:
            print("⚠️ Deep Link not found")
            
        @unknown default:
            print("❓ Unknown Deep Link status")
        }
    }
    
    // Logique commune de navigation
    private func handleDeepLink(_ deepLinkValue: String) {
        if deepLinkValue == "promo-noel" {
            // Navigation vers PromoViewController
            let promoVC = PromoViewController()
            window?.rootViewController?.present(promoVC, animated: true)
            
        } else if deepLinkValue.starts(with: "product/") {
            let productId = deepLinkValue.replacingOccurrences(of: "product/", with: "")
            let productVC = ProductViewController(productId: productId)
            window?.rootViewController?.present(productVC, animated: true)
        }
    }
}

Étape 3 : Tracking d'événements

// Achat
AppsFlyerLib.shared().logEvent(
    AFEventPurchase,
    withValues: [
        AFEventParamRevenue: 49.99,
        AFEventParamCurrency: "EUR",
        AFEventParamOrderId: "ORDER_12345",
        AFEventParamContentId: "PRODUCT_67890"
    ]
)

// Event custom
AppsFlyerLib.shared().logEvent(
    "user_completed_onboarding",
    withValues: [
        "user_segment": "premium",
        "source": "facebook_ad"
    ]
)

Implémentation : Android natif (Kotlin)

Étape 1 : Installation (build.gradle)

// App-level build.gradle
dependencies {
    implementation 'com.appsflyer:af-android-sdk:6.12.2'
}

Étape 2 : Configuration (MainApplication.kt)

import com.appsflyer.AppsFlyerLib
import com.appsflyer.AppsFlyerConversionListener
import com.appsflyer.deeplink.DeepLinkListener

class MainApplication : Application() {
    
    override fun onCreate() {
        super.onCreate()
        
        // Configuration AppsFlyer
        AppsFlyerLib.getInstance().apply {
            init("YOUR_DEV_KEY", conversionListener, this@MainApplication)
            setDebugLog(BuildConfig.DEBUG)
            start(this@MainApplication)
        }
        
        // Deep Link Listener
        AppsFlyerLib.getInstance().subscribeForDeepLink(deepLinkListener)
    }
    
    // Deferred Deep Link
    private val conversionListener = object : AppsFlyerConversionListener {
        override fun onConversionDataSuccess(conversionData: Map?) {
            Log.d("AppsFlyer", "Conversion Data: $conversionData")
            
            conversionData?.let { data ->
                if (data["is_first_launch"] as? Boolean == true) {
                    val deepLinkValue = data["deep_link_value"] as? String
                    deepLinkValue?.let { handleDeepLink(it) }
                }
            }
        }
        
        override fun onConversionDataFail(error: String?) {
            Log.e("AppsFlyer", "Conversion Error: $error")
        }
        
        override fun onAppOpenAttribution(data: Map?) {}
        override fun onAttributionFailure(error: String?) {}
    }
    
    // Deep Link
    private val deepLinkListener = DeepLinkListener { deepLinkResult ->
        when (deepLinkResult.status) {
            DeepLinkResult.Status.FOUND -> {
                val deepLinkValue = deepLinkResult.deepLink?.getStringValue("deep_link_value")
                deepLinkValue?.let { handleDeepLink(it) }
            }
            else -> Log.w("AppsFlyer", "Deep Link not found")
        }
    }
    
    private fun handleDeepLink(deepLinkValue: String) {
        val intent = when {
            deepLinkValue == "promo-noel" -> 
                Intent(this, PromoActivity::class.java)
            deepLinkValue.startsWith("product/") -> 
                Intent(this, ProductActivity::class.java).apply {
                    putExtra("product_id", deepLinkValue.replace("product/", ""))
                }
            else -> null
        }
        
        intent?.let {
            it.flags = Intent.FLAG_ACTIVITY_NEW_TASK
            startActivity(it)
        }
    }
}

Étape 3 : Tracking d'événements

// Achat
val eventValues = mapOf(
    AFInAppEventParameterName.REVENUE to 49.99,
    AFInAppEventParameterName.CURRENCY to "EUR",
    AFInAppEventParameterName.ORDER_ID to "ORDER_12345",
    AFInAppEventParameterName.CONTENT_ID to "PRODUCT_67890"
)
AppsFlyerLib.getInstance().logEvent(
    applicationContext,
    AFInAppEventType.PURCHASE,
    eventValues
)

// Event custom
AppsFlyerLib.getInstance().logEvent(
    applicationContext,
    "user_completed_onboarding",
    mapOf(
        "user_segment" to "premium",
        "source" to "facebook_ad"
    )
)

Best practices AppsFlyer (retour d'expérience VOID)

1. Toujours tester les Deep Links avant production

AppsFlyer propose un outil de test intégré au dashboard :

• OneLink Validator : génère un QR code de test
• Scannez avec votre device de test
• Vérifiez que l'app s'ouvre sur le bon écran
• Consultez les logs en temps réel dans le dashboard

2. Utiliser des paramètres custom pour le contexte utilisateur

Exploitez af_sub1 à af_sub5 pour personnaliser l'expérience :

• af_sub1 : user_id (pour retrouver le compte)
• af_sub2 : promo_code (appliquer une réduction)
• af_sub3 : referrer_id (programme de parrainage)
• af_sub4 : landing_screen (forcer une destination spécifique)
• af_sub5 : timestamp (debug)

3. Implémenter un fallback gracieux

// Si le deep link échoue, afficher la home
function handleDeepLink(deepLinkValue) {
  try {
    if (deepLinkValue === 'promo-noel') {
      navigation.navigate('PromoScreen');
    } else if (deepLinkValue?.startsWith('product/')) {
      const productId = deepLinkValue.split('/')[1];
      navigation.navigate('ProductScreen', { id: productId });
    } else {
      // Fallback : home
      navigation.navigate('HomeScreen');
    }
  } catch (error) {
    console.error('Deep Link error:', error);
    navigation.navigate('HomeScreen'); // Toujours une destination par défaut
  }
}

4. Monitorer les événements critiques

Configurez des alertes AppsFlyer pour :

• Baisse soudaine d'installations (>20% vs. moyenne 7 jours)
• Hausse de fraude détectée (>5% du trafic)
• CPI dépassant le seuil budget (ex : >5€/install)
• Taux de deep link failure >10%

5. RGPD / CCPA : demander le consentement

// Désactiver le tracking si l'utilisateur refuse
if (userConsentDeclined) {
  AppsFlyerLib.shared().isStopped = true; // iOS
  AppsFlyerLib.getInstance().stop(true, context); // Android
}

Alternatives à AppsFlyer

Plateforme	Forces	Faiblesses	Prix
AppsFlyer	Leader, fraud protection, deep linking avancé	Cher pour startups	$$$
Adjust	Interface simple, bon support	Moins de features fraud	$$
Branch	Deep linking gratuit, facile	Attribution moins précise	$ (freemium)
Kochava	Bon rapport qualité/prix	UI datée	$$
Singular	ROI focus, marketing automation	Moins connu	$$

Recommandation VOID : AppsFlyer pour projets enterprise (banques, assurances, grandes marques), Branch pour startups avec budget limité.

Conclusion : AppsFlyer, indispensable pour l'acquisition mobile

AppsFlyer est devenu incontournable pour toute stratégie mobile sérieuse :

• ✅ Attribution précise : 98% de matching (vs. 60-70% Google Analytics)
• ✅ Protection fraud : économie 15-25% du budget pub
• ✅ Deep linking : +40% de conversion onboarding
• ✅ Analytics temps réel : LTV, cohortes, ROI par canal
• ✅ Intégration universelle : React Native, iOS, Android, Unity, Flutter...

Chez VOID, nous intégrons AppsFlyer depuis 2018 sur des apps à 1M+ utilisateurs. Notre expertise couvre :

• 🔧 Setup technique : SDK, deep linking, Universal Links/App Links
• 📊 Stratégie d'attribution : multi-touch, view-through, modèles custom
• 🚀 Campagnes optimisées : A/B testing, cohort analysis, LTV prediction
• 🛡️ Fraud management : règles custom, blacklists, monitoring temps réel

Besoin d'aide sur AppsFlyer ?

VOID vous accompagne sur :

• ✅ Audit de votre setup actuel (deep links, événements, fraud)
• ✅ Implémentation SDK React Native / iOS / Android
• ✅ Génération de liens en masse (API, scripts, automatisation)
• ✅ Formation équipes (marketing, tech, product)
• ✅ Optimisation ROI (réduire CPI, maximiser LTV)

« Avec AppsFlyer, nous avons réduit notre CPI de 42% en 3 mois en identifiant les canaux réellement performants et en bloquant 18% de fraude. »

— Directeur Marketing Digital (client VOID)