Integración con Tenjin

Tenjin es una plataforma de atribución y análisis móvil para desarrolladores de apps y marketers. Proporciona herramientas para medir y optimizar campañas de adquisición de usuarios, ofreciendo información detallada sobre el rendimiento de la app y el comportamiento de los usuarios. Con su enfoque transparente y flexible, Tenjin agrega datos de redes publicitarias y stores de aplicaciones, lo que permite a los equipos analizar el ROI, rastrear conversiones y monitorear métricas clave de rendimiento. Al reenviar eventos de suscripción a Tenjin, puedes ver exactamente de dónde provienen las conversiones y qué campañas generan más valor en todos los canales, plataformas y dispositivos. En esencia, los dashboards de Tenjin ofrecen analíticas avanzadas para campañas de marketing.

Al reenviar la atribución de Tenjin a Adapty, enriqueces las analíticas de Adapty con criterios de filtrado adicionales que puedes usar en análisis de cohortes y conversiones.

Esta integración funciona de dos maneras principales:

Recibir datos de atribución de Tenjin Una vez integrado, Adapty recopila datos de atribución de Tenjin. Puedes consultar esta información en la página de perfil del usuario en el Adapty Dashboard.
Enviar eventos de suscripción a Tenjin Adapty envía eventos de compra a Tenjin en tiempo real. Estos eventos ayudan a evaluar la efectividad de tus campañas publicitarias directamente en el dashboard de Tenjin. | Característica de integración | Descripción | | ----------------------------- | ------------------------------------------------------------ | | Frecuencia | Tiempo real | | Dirección de datos |
Transmisión bidireccional:
- Eventos de Adapty: Del servidor de Adapty al servidor de Tenjin
- Atribución de Tenjin: Del SDK de Tenjin al servidor de Adapty
| | Punto de integración de Adapty |
- SDKs de Tenjin y Adapty en el código de la app
- Servidor de Adapty
|

Configurar la integración

Conectar Adapty con Tenjin

Abre la página Integrations -> Tenjin en el Adapty Dashboard.
Activa el toggle para habilitar la integración.
Inicia sesión en el Tenjin Dashboard.
Ve a Configuration -> Apps en el menú de navegación.
Selecciona la app de tu plataforma (iOS o Android) y ve a la pestaña App and SDK.
En la pestaña App and SDK, haz clic en Copy en la columna SDK Key. Si todavía no tienes una SDK key, haz clic en el botón Generate SDK Key para crear una.
Vuelve al Adapty Dashboard y pega el SDK Key copiado en el campo correspondiente a tu plataforma:
- Para apps iOS: pégalo en el campo iOS SDK Key o iOS Sandbox SDK Key
- Para apps Android: pégalo en el campo Android SDK Key o Android Sandbox SDK Key
Info

Tenjin no dispone de un modo Sandbox específico para la integración server-to-server. Usa una app de Tenjin separada o la misma clave tanto para eventos de producción como de sandbox.

Si tienes apps en ambas plataformas, repite los pasos 5-7 para la otra plataforma.
(opcional) Ajusta la sección How the revenue data should be sent si es necesario. Para una explicación detallada de sus opciones, consulta los Ajustes de integración.
Haz clic en Save para finalizar la configuración.

Adapty enviará ahora los eventos de compra a Tenjin y recibirá datos de atribución. Puedes ajustar el intercambio de eventos en la sección Events names.

Configurar eventos y etiquetas

Tenjin solo acepta eventos de compra y Trial started. En la sección Events names, selecciona qué eventos compartir con Tenjin según tus objetivos de seguimiento.

Conectar tu app a Tenjin

Usa el método del SDK Adapty.updateExternalAttribution() (llamado updateAttribution() antes de la versión 4.1 del SDK) para obtener los datos de atribución de Tenjin y pasárselos a Adapty.


func updateTenjinId() {
    guard let tenjinId = TenjinSDK.getAnalyticsInstallationId() else { return }

    do {
        try await Adapty.setIntegrationIdentifier(.tenjinAnalyticsInstallationId(tenjinId))
    } catch {
        // handle the error
    }
}

func updateTenjinAttribution() {
    let instance = TenjinSDK.getInstance("<YOUR_TENJIN_API_TOKEN>")
        
    instance?.getAttributionInfo { info, _ in
        guard let info else { return }

        Task {
            do {
                try await Adapty.updateExternalAttribution(info, provider: .tenjin)
            } catch {
                // handle the error
            }
        }
    }
}

Adapty.setIntegrationIdentifier("tenjin_analytics_installation_id", tenjinSdk.analyticsInstallationId) { error ->
    if (error != null) {
        // handle the error
    }
}

tenjinSdk.getAttributionInfo { attribution ->
    if (attribution == null) return@getAttributionInfo

    Adapty.updateAttribution(attribution, "tenjin") { error ->
        if (error != null) {
            // handle the error
        }
    }
}

Adapty.setIntegrationIdentifier("tenjin_analytics_installation_id", tenjinSdk.getAnalyticsInstallationId(), error -> {
    if (error != null) {
        // handle the error
    }
});

tenjinSdk.getAttributionInfo(attribution -> {
    if (attribution == null) return;

    Adapty.updateAttribution(attribution, "tenjin", error -> {
        // handle the error
    });
});

try {
    final tenjinId = await TenjinSDK.instance.getAnalyticsInstallationId();
    
    if (tenjinId != null) {
        await Adapty().setIntegrationIdentifier(
            key: 'tenjin_analytics_installation_id', 
            value: tenjinId,
        );
    }

    final attribution = await TenjinSDK.instance.getAttributionInfo();
    if (attribution != null) {
        await Adapty().updateAttribution(attribution, source: 'tenjin');
    }
} catch (e) {
    // handle the error
}

using AdaptySDK;
using System.Linq;

BaseTenjin instance = Tenjin.getInstance("<SDK_KEY>");
var tenjinId = instance.GetAnalyticsInstallationId();

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

instance.GetAttributionInfo((attribution) => {
    var dynamicAttribution = attribution.ToDictionary(
        kvp => kvp.Key,
        kvp => (dynamic)kvp.Value
    );
                
Adapty.UpdateAttribution(
    dynamicAttribution,
    "tenjin",
    (error) => {
        // handle the error
    });
});


// ...
const posthog = usePostHog()

// ...
try {
  await adapty.setIntegrationIdentifier("tenjin_analytics_installation_id", await Tenjin.getAnalyticsInstallationId());
} catch (error) {
  // handle `AdaptyError`
}

Estructura del evento

Adapty envía los eventos seleccionados a Tenjin según la configuración de la sección Events names en la página de integración de Tenjin. Cada evento tiene la siguiente estructura:

{
  "price": 99.0,
  "locale": "en-US",
  "country": "ME",
  "postcut": "false",
  "currency": "USD",
  "platform": "ios",
  "quantity": 1,
  "bundle_id": "com.adapty.adaptydemoapp",
  "ip_address": "127.0.0.1",
  "os_version": "18.1.1",
  "product_id": "month.premium.99",
  "app_version": "3.2.0",
  "sdk_version": "server",
  "device_model": "iPhone 13 Mini",
  "advertising_id": "00000000-0000-0000-0000-000000000000",
  "os_version_release": "18.1.1",
  "developer_device_id": "00000000-0000-0000-0000-000000000000",
  "analytics_installation_id": "00000000-0000-0000-0000-000000000000"
}

Where

Parámetro	Tipo	Descripción
price	Float	El precio unitario del artículo comprado en la unidad estándar de la moneda (p. ej., USD se reporta en dólares).
locale	String	El idioma y región del dispositivo. Para Android: `Locale.getDefault().toString()`. Para iOS: `[[NSLocale currentLocale] localeIdentifier]`.
country	String	El código de país estándar ISO (p. ej., US para Estados Unidos).
postcut	String (Boolean)	Indica si la compra se envió tras el recorte de la plataforma. 1 para verdadero, 0 para falso.
currency	String	El código de moneda ISO (p. ej., USD para dólares estadounidenses).
platform	String	La plataforma del dispositivo (p. ej., ios, android, windows, amazon).
quantity	Integer	El número de unidades compradas.
bundle_id	String	El identificador del paquete de la app (p. ej., `com.example.app`).
ip_address	String (IPv4)	La dirección IP del usuario. Se usa para determinar el país.
os_version	String	La versión del SO del dispositivo. Para Android: `String.valueOf(Build.VERSION.SDK_INT)`. Para iOS: `[[UIDevice currentDevice] systemVersion]`.
product_id	String	Identificador único del producto comprado.
app_version	Float, Decimal	La versión de la app. Para Android: `context.getPackageManager().getPackageInfo()`. Para iOS: `[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleShortVersionString"]`.
sdk_version	String	La versión del SDK en uso, siempre establecida en `server`.
device_model	String	El modelo del dispositivo. Para Android: `Build.MODEL`. Para iOS: `sysctl("hw.machine")`.
advertising_id	UUID	El ID publicitario del dispositivo. Obligatorio para Android. En iOS puede estar vacío o con todos ceros.
os_version_release	String	La versión de lanzamiento del SO. Para Android: `String.valueOf(Build.VERSION.RELEASE)`. Para iOS: `[[UIDevice currentDevice] systemVersion]`.
developer_device_id	UUID	El identificador del proveedor (solo iOS).
analytics_installation_id	UUID	ID de instalación de analíticas. Para más detalles, consulta la documentación en `https://docs.tenjin.com`.

Solución de problemas

Algunos eventos aparecen como fallidos en el Event Feed

Tenjin solo acepta los eventos enumerados en Configurar eventos y etiquetas. El resto de eventos sigue generando una fila en el Event Feed, marcada como entrega fallida con el tooltip “The event type is not supported for integration.” Esto incluye access_level_updated, que no encontrarás en la sección Events names, ya que es exclusivo de la integración con webhook.