AppsFlyer

Adapty intercambia datos con AppsFlyer en ambas direcciones. AppsFlyer le indica a Adapty qué campaña trajo a cada usuario. Adapty le indica a AppsFlyer cuánto pagó ese usuario — compras, renovaciones, pruebas y reembolsos, con los ingresos y los detalles del producto incluidos.

• Ver todo el ciclo de vida de la suscripción, no solo la primera compra. Las renovaciones y conversiones de prueba son eventos del store, sin sesión de app para que el SDK del cliente de AppsFlyer los registre. Adapty recibe los eventos de suscripción del lado del servidor y los reenvía a AppsFlyer, de modo que las cifras de campaña siguen actualizándose mucho después de la instalación inicial. Los reembolsos siguen el mismo camino, y AppsFlyer los deduce de los ingresos de campaña.
• Optimiza tus campañas publicitarias con datos de eventos de suscripción. AppsFlyer retransmite los eventos in-app de Adapty a tus redes publicitarias como postbacks. Los servicios que gestionan tu presupuesto publicitario pueden optimizar en función de lo que los usuarios realmente pagaron.
• Filtra los análisis de Adapty por campaña. Adapty guarda la atribución de AppsFlyer en cada perfil, hasta el conjunto de anuncios y el creativo, y los gráficos de suscripción pueden filtrarse por ella.
• Muestra un paywall diferente por campaña. Los segmentos de Adapty filtran por los mismos campos de atribución: campaña, conjunto de anuncios y creativo. Usa un segmento como audiencia para asociar el paywall al anuncio que trajo al usuario.

Cómo funciona la integración

Adapty recibe datos de atribución de AppsFlyer y le envía eventos de suscripción. Ambos dependen de un único valor: el AppsFlyer ID, una cadena que AppsFlyer genera cuando tu app se lanza por primera vez.

1. Cuando el usuario instala tu app, el SDK de AppsFlyer le asigna un ID único.
2. Tu app pasa ese ID a Adapty, que lo almacena en el perfil del usuario como appsflyer_id.
3. Tu app también pasa los datos de atribución de AppsFlyer a Adapty, que los guarda en el mismo perfil.
4. Más tarde, cuando el usuario desencadena un evento de suscripción —por ejemplo, inicia una prueba o compra un producto—, los servidores de Adapty envían el evento a la API S2S de AppsFlyer con el mismo appsflyer_id.
5. AppsFlyer relaciona el ID con la instalación que ya había atribuido, de modo que la compra hereda la campaña y la fuente de medios de esa instalación.

Instrucciones de configuración

Antes de comenzar:

• Confirma que tu plan de AppsFlyer admite eventos S2S in-app. El paquete de nivel básico Zero de AppsFlyer no lo permite: su API rechaza todos los eventos que Adapty envía con 403 Forbidden.
• Incluye el SDK de AppsFlyer en tu app. El ID de AppsFlyer del que depende la integración solo existe una vez que ese SDK se inicializa. Una integración solo del lado del servidor no generará el ID.
• Desactiva todas las demás integraciones de atribución. Adapty acepta una sola fuente de atribución por perfil y no puede sobrescribir un valor existente. En iOS, la atribución de Apple Ads no orgánica siempre tiene prioridad; consulta Seleccionar una única fuente de atribución.

Crear un token S2S en AppsFlyer

Adapty se autentica con la API S2S de AppsFlyer mediante un token que tú creas. Solo los administradores de AppsFlyer pueden abrir la página Tokens, así que pide a uno que cree el token si tu cuenta no es de administrador. Salta a Configurar Adapty si ya tienes uno.

1. Inicia sesión en AppsFlyer.

2. Haz clic en tu nombre de cuenta en la esquina superior derecha y abre el Security center.

   

3. En la página Manage your account security, busca la tarjeta AppsFlyer API and S2S tokens y haz clic en Manage your AppsFlyer tokens. Se abrirá la página Tokens.

4. Haz clic en New token.

   

5. Introduce un Name para el token. El nombre es solo para tu referencia y puedes cambiarlo más adelante.

6. Selecciona el tipo de token S2S. Cualquier otro tipo romperá la integración.

7. Haz clic en Create new token.

8. Busca tu nuevo token en la lista. AppsFlyer enmascara el valor, así que haz clic en el icono de copia de la columna Token para obtenerlo.

   

Configurar Adapty

1. Abre Integrations > AppsFlyer en el Adapty Dashboard.
2. Activa el interruptor de AppsFlyer.
3. Si ya conectaste tu app a la App Store, el campo iOS App ID se rellena automáticamente con el Apple ID numérico de tu app. Si está vacío, conecta primero tu cuenta de App Store. Android no requiere un campo equivalente.
4. Pega el token S2S en el campo Production de S2S key for iOS, S2S key for Android, o en ambos.
5. Rellena los campos de Sandbox para que las compras de prueba no aparezcan en tus datos de producción; consulta Mantener los datos de sandbox fuera de producción.

6. En How the revenue data should be send, elige qué cifra de ingresos envía Adapty como af_revenue. Las tres opciones se corresponden con las vistas de ingresos de Adapty Analytics, por lo que tu elección determina también con qué vista deberían coincidir los datos de AppsFlyer.

7. Configura las opciones restantes:

8. Renombra o deshabilita eventos individuales en la sección Events names — consulta Nombres de eventos.

   

9. Haz clic en Save.

Mantén los datos de sandbox fuera de producción

Para que las compras de prueba no contaminen tus datos reales, envíalas a una app de AppsFlyer independiente. Registra una segunda app para tus builds de desarrollo y pega su token en el campo Sandbox de cada sección de plataforma.

Adapty enruta cada transacción según el entorno: las compras reales van a la app cuyo token está en Production, y las compras de prueba, a la app en Sandbox. Si prefieres registrarlo todo en una sola app, pega el mismo token en ambos campos.

Las compras realizadas durante la revisión de App Store y en TestFlight son transacciones de sandbox, aunque se ejecuten en una compilación de producción. Adapty envía estas compras con la clave Sandbox.

Configura el código de tu app

1. Registra un callback de conversión con el SDK de AppsFlyer. En iOS, implementa el protocolo AppsFlyerLibDelegate; en Android, la interfaz AppsFlyerConversionListener; en Unity, la interfaz IAppsFlyerConversionData. En React Native y Flutter, pasa un handler al método onInstallConversionData en su lugar.
2. Espera a que AppsFlyer invoque ese callback. AppsFlyer atribuye cada instalación en sus propios servidores, por lo que el resultado llega a tu app de forma asíncrona y no en el momento del lanzamiento. El SDK invoca el callback de nuevo en cada sesión posterior.
3. Dentro del callback, lee el ID de AppsFlyer del usuario con getAppsFlyerUID y pásalo a Adapty con setIntegrationIdentifier(). Los eventos de Adapty llegan al usuario correcto en AppsFlyer solo con este valor.
4. Dentro del mismo callback, pasa los datos de atribución de AppsFlyer a Adapty con updateAttribution(). Esto le indica a Adapty qué campaña generó la instalación. En iOS y Android SDK 4.1 y versiones posteriores, el método se llama updateExternalAttribution().
5. Usa await Adapty.identify() en lugar de ejecutarlo en paralelo con los pasos 3 y 4. Adapty crea un perfil anónimo en la activación y luego cambia al perfil identificado una vez que identify() se resuelve. Un appsflyer_id establecido durante ese cambio no siempre sobrevive al proceso.

Para la secuencia completa, consulta el orden de llamadas en los SDKs de iOS, Android, React Native, Flutter, Unity, Capacitor y Kotlin Multiplatform.

class YourAppsFlyerLibDelegateImplementation {
    // Find your implementation of AppsFlyerLibDelegate
    // and update onConversionDataSuccess method:
    func onConversionDataSuccess(_ conversionInfo: [AnyHashable : Any]) {
        let uid = AppsFlyerLib.shared().getAppsFlyerUID()
        Adapty.setIntegrationIdentifier(.appsflyerId(uid))
        Adapty.updateExternalAttribution(conversionInfo, provider: .appsflyer)
    }
}

val conversionListener: AppsFlyerConversionListener = object : AppsFlyerConversionListener {
    override fun onConversionDataSuccess(conversionData: Map<String, Any>) {
        val uid = AppsFlyerLib.getInstance().getAppsFlyerUID(context)
        Adapty.setIntegrationIdentifier(AdaptyIntegrationIdentifier.appsflyerId(uid)) { error ->
            if (error != null) {
                // handle the error
            }
        }
        Adapty.updateExternalAttribution(conversionData, AdaptyExternalAttributionProvider.APPSFLYER) { error ->
            if (error != null) {
                //handle the error
            }
        }
    }
}

appsFlyer.onInstallConversionData(installData => {
    appsFlyer.getAppsFlyerUID(async (error, appsFlyerUID) => {
        if (error) {
            // handle the error
            return;
        }
        try {
            await adapty.setIntegrationIdentifier('appsflyer_id', appsFlyerUID);
            await adapty.updateAttribution(installData, 'appsflyer');
        } catch (error) {
            // handle `AdaptyError`
        }
    });
});

// ...
appsFlyer.initSdk(/*...*/);

AppsflyerSdk appsflyerSdk = AppsflyerSdk(<YOUR_OPTIONS>);

appsflyerSdk.onInstallConversionData((data) async {
    try {
        final appsFlyerUID = await appsFlyerSdk.getAppsFlyerUID();

        await Adapty().setIntegrationIdentifier(
          key: "appsflyer_id",
          value: appsFlyerUID,
        );

        await Adapty().updateAttribution(data, source: "appsflyer");
    } on AdaptyError catch (adaptyError) {
        // handle the error
    } catch (e) {
        // handle the error
    }
});

appsflyerSdk.initSdk(
    registerConversionDataCallback: true,
    registerOnAppOpenAttributionCallback: true,
    registerOnDeepLinkingCallback: true,
);

using AdaptySDK;
using AppsFlyerSDK;

// before SDK initialization
AppsFlyer.getConversionData(this.name);

// in your IAppsFlyerConversionData
void onConversionDataSuccess(string conversionData) {
    string appsFlyerId = AppsFlyer.getAppsFlyerId();

    Adapty.SetIntegrationIdentifier(
      "appsflyer_id",
      appsFlyerId,
      (error) => {
        // handle the error
    });

    Adapty.UpdateExternalAttribution(
      conversionData,
      "appsflyer",
      (error) => {
        // handle the error
    });
}

Verificar la integración

1. Activa una compra en sandbox y abre el Event Feed de tu app. Ahí aparece cada intento de envío. Para leer la respuesta de AppsFlyer a un intento fallido, pasa el cursor sobre esa fila.
2. En AppsFlyer, ve a Settings > SDK Integration Tests > Live Events y selecciona tu dispositivo de prueba. Live Events muestra los eventos S2S a medida que llegan, mucho antes de que aparezcan en el dashboard de Activity de AppsFlyer.
3. Abre el dashboard de Activity de tu app y confirma el evento, sus ingresos y su fuente de medios. Espera aproximadamente una hora: los eventos S2S no llegan a este dashboard de inmediato.

Estructura de eventos de AppsFlyer

Adapty envía una solicitud POST por evento a https://api3.appsflyer.com/inappevent/{app_id}, con el token S2S en el encabezado authentication. La API 2 usa https://api2.appsflyer.com/inappevent/{app_id}.

{
  "appsflyer_id": "1699887556000-6192770",
  "eventName": "af_subscribe",
  "eventTime": "2026-03-01 12:00:00",
  "eventValue": "{\"af_content_id\":\"yearly.premium.6999\",\"af_order_id\":\"GPA.3383-4699-1373-07113\",\"store_country\":\"US\",\"profile_country\":\"US\",\"af_content_type\":\"in_app\",\"af_revenue\":\"9.9900\",\"af_currency\":\"USD\",\"af_quantity\":\"1\"}",
  "os": "17.0.1",
  "bundleIdentifier": "com.example.app",
  "customer_user_id": "user_12345",
  "eventCurrency": "USD",
  "ip": "192.168.100.1",
  "advertising_id": "00000000-0000-0000-0000-000000000000",
  "idfa": "00000000-0000-0000-0000-000000000000",
  "idfv": "00000000-0000-0000-0000-000000000000",
  "att": "3"
}

eventValue lleva la compra en sí. Los últimos cuatro parámetros aparecen solo en los eventos que generan ingresos:

Nombres de eventos

Por defecto, Adapty asigna sus eventos de ingresos a los nombres de eventos estándar de AppsFlyer, en lugar de enviarlos como eventos personalizados con sus propios nombres. Esto es importante si reenvías eventos a redes publicitarias: una red actúa sobre los nombres estándar que ya reconoce, por lo que te ahorras crear un mapeo para cada uno.

El resto de eventos de Adapty conservan su propio nombre, por ejemplo subscription_refunded. En la sección Events names de la página de integración de AppsFlyer, puedes renombrar cualquier evento o desactivar los que no necesites. Para ver la lista completa de lo que Adapty puede enviar, consulta Eventos.

Limitaciones

• Un perfil sin appsflyer_id no genera ningún evento. AppsFlyer asocia un evento con la instalación que generó el ID y lee la campaña a partir de esa instalación. Sin él, Adapty no envía nada, y el Event Feed marca estos perfiles — consulta Los eventos no llegan a AppsFlyer.
• Sin relleno histórico. Adapty reenvía eventos desde el momento en que activas la integración. Las compras pasadas nunca llegarán a AppsFlyer.
• Los detalles del dispositivo quedan vacíos en los datos sin procesar de AppsFlyer. Un evento S2S solo contiene lo que incluye la solicitud. El modelo del dispositivo, la categoría del dispositivo, el idioma, el operador, el WIFI, la versión de la app y el nombre de la app no tienen parámetro S2S, por lo que nada enviado de esta forma puede completarlos.

Solución de problemas

• Los eventos no llegan a AppsFlyer
• Las compras aparecen como orgánicas
• Los eventos antiguos llegan con la fecha de hoy
• Las renovaciones caen en el día equivocado
• Los ingresos en AppsFlyer no coinciden con Adapty Analytics
• Failed to authenticate en el Event Feed
• access_level_updated aparece como fallido en el Event Feed

Los eventos no llegan a AppsFlyer

Abre primero el Event Feed. Una entrega fallida muestra el error que devolvió AppsFlyer. Estas causas explican la mayoría de los casos:

• El perfil no tiene appsflyer_id. Confirma que tu app llama a getAppsFlyerUID y pasa el resultado a setIntegrationIdentifier en cada plataforma en la que publicas — consulta Configura el código de tu app.
• Falta el ID de la app para esa plataforma. AppsFlyer identifica cada app por su ID, por lo que Adapty no envía nada si no hay uno. Los eventos de iOS necesitan el iOS App ID en la página de integración; los eventos de Android necesitan el nombre del paquete en App settings > Android SDK — consulta Configura Adapty.
• La compra es una transacción sandbox y la clave Sandbox está vacía. Consulta Mantén los datos de sandbox fuera de producción.
• El evento está desactivado en la sección Events names.

Una entrega correcta no garantiza que AppsFlyer conserve el evento. AppsFlyer devuelve 200 OK para cualquier solicitud bien formada y luego descarta los eventos cuyo appsflyer_id no coincide con ninguna instalación real.

Las compras aparecen como orgánicas

Cada appsflyer_id identifica una instalación, y todos los eventos que llevan ese ID heredan la atribución de esa instalación: la campaña que la generó, o ninguna si la instalación fue orgánica. AppsFlyer necesita entre 20 y 30 segundos o más para atribuir una nueva instalación. Un evento que llega antes de ese tiempo no tiene atribución que heredar, por lo que AppsFlyer lo marca como orgánico no atribuido.

Espera que las primeras compras tras el lanzamiento aparezcan como orgánicas — pruebas que comienzan segundos después de abrir la app. Para evitarlo, retrasa el paywall el tiempo suficiente para que AppsFlyer termine de procesar la instalación.

Si todos los eventos aparecen como orgánicos, no solo las primeras compras tras el lanzamiento, el problema es de atribución y no de tiempo: otra fuente reclamó el perfil primero. Consulta Seleccionar una única fuente de atribución.

Los eventos antiguos llegan con la fecha de hoy

Los eventos pueden llegar a Adapty con retraso por dos motivos:

• Cuando las App Store Server Notifications muestran Delayed en App Store Connect, Apple pone sus notificaciones en cola. Una renovación puede llegar a Adapty mucho después de que se haya producido — consulta App Store Server Notifications muestran “Delayed”.
• Los eventos con fecha retroactiva se procesan siempre que Exclude historical events esté desactivado.

AppsFlyer no acepta marcas de tiempo antiguas como estas. Para garantizar un manejo coherente de los eventos, Adapty reemplaza eventTime con la hora actual para cualquier evento de más de 26 horas de antigüedad. No es posible desactivar esta reescritura.

Las renovaciones aparecen en el día incorrecto

Apple notifica a Adapty las renovaciones y conversiones de prueba antes de que ocurran, y Adapty las reenvía de inmediato con el eventTime futuro sin modificar. AppsFlyer conserva una marca de tiempo futura solo cuando corresponde al día de llegada: si una renovación tiene fecha de mañana, se registra con la hora de llegada de hoy.

Activa Delay events with a future datetime en los ajustes de integración. Adapty retiene cada evento hasta que llegue su momento, de modo que AppsFlyer registre la fecha que Apple anunció. Consulta Marcas de tiempo de eventos con fechas futuras.

Los ingresos en AppsFlyer no coinciden con Adapty Analytics

Adapty y AppsFlyer contabilizan las mismas compras de forma distinta. Estas diferencias explican casi cualquier discrepancia.

• El dashboard Overview de AppsFlyer agrupa los ingresos por fecha de instalación; los gráficos de Adapty los agrupan por fecha de evento. En AppsFlyer, una renovación de julio proveniente de una instalación de enero cuenta para enero. Compara ese dashboard con el análisis de cohortes de Adapty, que también agrupa los ingresos por mes de instalación. Los informes de datos en bruto de AppsFlyer agrupan por fecha de evento, así que compáralos con los gráficos de Adapty.
• Las compras de perfiles sin appsflyer_id nunca llegan a AppsFlyer. Se quedan en Adapty Analytics. Consulta Los eventos no llegan a AppsFlyer.
• AppsFlyer solo muestra la cifra de ingresos que seleccionaste en Adapty. El ajuste How the revenue data should be send decide si Adapty envía ingresos brutos, recaudación neta o ingresos netos. Comparar eso con otra vista de Adapty Analytics genera una diferencia igual a la comisión, el impuesto o ambos.
• Adapty usa la zona horaria de informes de tu app; AppsFlyer recibe UTC. Las integraciones siempre reciben marcas de tiempo en UTC, independientemente de lo que configures en App Settings. Una compra a las 23:30 UTC del 1 de julio aparece el 2 de julio en Adapty si tu zona horaria de informes es +02:00.
• A AppsFlyer le faltan eventos históricos. Hay dos causas probables. Con Exclude historical events activado, el historial de AppsFlyer de un usuario comienza en su primer lanzamiento de una versión con Adapty. Además, Adapty nunca rellena de forma retroactiva los eventos que procesó antes de que habilitaras la integración.
• Las compras en sandbox llegan a la app de AppsFlyer identificada por la clave Sandbox. Si esa es la app de producción, las compras de prueba inflan sus ingresos. Consulta Mantén los datos de sandbox fuera de producción.
• Los eventos desactivados en la integración nunca llegan a AppsFlyer. Adapty Analytics sigue contándolos. Revisa la sección Events names: desactivar subscription_renewed elimina la mayor parte de los ingresos de cualquier app consolidada.

Failed to authenticate en el Event Feed

AppsFlyer rechaza las credenciales cuando no coinciden con la versión de la API. La API 2 espera una Dev key; la API 3 espera un token S2S. Cambiar la versión sin reemplazar la clave genera este error en cada evento.

Crea un nuevo token en el AppsFlyer Security Center y pégalo en los campos S2S key, o sigue Switch from AppsFlyer S2S API 2 to 3.

access_level_updated aparece como fallido en el Event Feed

access_level_updated es un evento exclusivo de webhooks. Adapty nunca lo envía a esta integración. Sin embargo, Adapty registra un resultado para cada integración habilitada, y un evento no compatible se muestra como un error.