Atribución de ingresos publicitarios

Conecta los ingresos publicitarios con las campañas de marketing específicas que llevaron usuarios a tu app, obteniendo visibilidad completa de los costos de campaña, los ingresos in-app y los ingresos publicitarios para medir el ROI con precisión.

Descripción general

Qué es la atribución de ingresos publicitarios

La atribución de ingresos publicitarios vincula los ingresos publicitarios de una app móvil con las campañas de marketing que generaron los usuarios, lo que te permite medir el rendimiento real de la campaña al conectar los costos de adquisición de usuarios con los ingresos de por vida, incluida la monetización publicitaria.

• ROI de campaña: Consulta el costo de la campaña, las compras in-app y los ingresos publicitarios en informes unificados para calcular el retorno real de la inversión publicitaria
• Optimización de red: Envía los datos de ingresos publicitarios de vuelta a las redes publicitarias para mejorar los algoritmos de puja y el rendimiento de las campañas
• Fuentes de datos: Admite datos a nivel de usuario y de impresión de plataformas de mediación como AdMob, AppLovin MAX, Unity LevelPlay (IronSource) y TradPlus

Para más detalles, consulta las Preguntas frecuentes sobre atribución de ingresos publicitarios.

Requisitos de implementación

El tracking de ingresos publicitarios requiere la integración con el SDK de tu plataforma de mediación y la configuración de callbacks de ingresos.

1. Versión del SDK: Actualiza a la versión más reciente del SDK de React Native de Singular
2. Plataforma de mediación: Integra el SDK de React Native de tu plataforma de mediación (AdMob, AppLovin MAX, IronSource o TradPlus)
3. Callbacks de ingresos: Implementa los handlers de eventos pagados específicos de cada plataforma para capturar datos de ingresos a nivel de impresión
4. Lógica de validación: Agrega validación de ingresos y moneda antes de enviar los datos a Singular

Método del SDK

Singular.adRevenue

Reporta los datos de ingresos publicitarios a Singular con la plataforma, la moneda y el monto de ingresos para atribuirlos a la campaña de adquisición del usuario.

Firma del método:

static adRevenue(adData: SingularAdData | {
    ad_platform: string;
    ad_currency: string;
    ad_revenue: number;
    [key: string]: any;
}): void

Parámetros obligatorios:

• ad_platform: Nombre de la plataforma de mediación (por ejemplo, "AdMob", "AppLovin", "IronSource", "TradPlus")
• ad_currency: Código de moneda ISO 4217 de tres letras (por ejemplo, "USD", "EUR")
• ad_revenue: Monto de ingresos en la moneda especificada (debe ser mayor que 0)

Construir el payload con SingularAdData

SingularAdData recibe los tres valores obligatorios en su constructor y expone un método encadenable para cada campo opcional. Impórtalo desde el paquete junto con Singular.

import { Singular, SingularAdData } from 'singular-react-native';

const adData = new SingularAdData('AdMob', 'USD', 0.05)
  .withAdUnitId('ca-app-pub-1234567890123456/9876543210')
  .withAdType('Rewarded')
  .withPrecision('precise');

Singular.adRevenue(adData);

Campos opcionales de datos publicitarios

Todos los campos siguientes son opcionales. Envía todo lo que reporte tu plataforma de mediación: cuanto más completo sea el payload, más granular será tu reporte de ingresos publicitarios en Singular. Si construyes un objeto plano en lugar de usar el builder, utiliza la clave del payload de la segunda columna.

Para la documentación completa del método, consulta la referencia de adRevenue.

Integraciones de plataformas

Integración con AdMob

Implementa el tracking de ingresos publicitarios de AdMob usando los callbacks de eventos pagados del SDK de Google Mobile Ads para reportar ingresos a nivel de impresión.

Requisitos previos

• Habilita el reporte de ingresos publicitarios en tu cuenta de AdMob. Consulta Soporte de AdMob
• Integra el paquete React Native Google Mobile Ads. Consulta la Guía de inicio

Descripción general de la implementación

Al cargar formatos de anuncio (App Open, Banner, Interstitial, Native, Rewarded), configura un handler de eventos pagados que se active cuando los anuncios generen ingresos. Extrae el valor del ingreso y la moneda de los datos del evento, valida ambos valores y envíalos a Singular.

Ejemplo de anuncio rewarded de AdMob

Carga un anuncio rewarded con AdMob y captura los eventos pagados para el tracking de ingresos.

// TurboModule direct API (React Native 0.76+ New Architecture)
import React, { useEffect } from 'react';
import NativeSingular from 'singular-react-native/js/NativeSingular';
import { RewardedAd, AdEventType } from 'react-native-google-mobile-ads';
import { Platform } from 'react-native';

const AD_UNIT_ID = 'ca-app-pub-xxxxxxxxxxxxx/yyyyyyyyyy';

export default function AdMobRevenueTracker() {
  useEffect(() => {
    loadRewardedAd();
  }, []);

  const loadRewardedAd = () => {
    // Create RewardedAd instance
    const rewardedAd = RewardedAd.createForAdRequest(AD_UNIT_ID);

    // Set up event listener for ad events
    rewardedAd.addAdEventListener((type, error, data) => {
      if (type === AdEventType.LOADED) {
        console.log('Rewarded ad loaded');
      } else if (type === AdEventType.ERROR) {
        console.error('Rewarded ad failed to load:', error);
      } else if (type === AdEventType.PAID_EVENT) {
        // Handle paid event with revenue data
        handleAdRevenue(data);
      }
    });

    // Load the ad
    rewardedAd.load();
  };

  const handleAdRevenue = (data) => {
    const { value, currencyCode } = data;

    // Validate revenue and currency
    if (!value || value <= 0) {
      console.error('Invalid ad revenue value:', value);
      return;
    }

    if (!currencyCode || currencyCode.trim() === '') {
      console.error('Invalid currency code:', currencyCode);
      return;
    }

    // Convert revenue based on platform
    let revenue;
    if (Platform.OS === 'android') {
      // Android reports in micros - convert to dollars
      revenue = value / 1_000_000.0;
    } else {
      // iOS reports in dollars directly
      revenue = value;
    }

    const adRevenueData = {
      ad_platform: 'AdMob',
      ad_currency: currencyCode,
      ad_revenue: revenue
    };

    // Send to Singular
    NativeSingular.adRevenue(adRevenueData);

    console.log('Ad Revenue reported to Singular:', adRevenueData);
  };

  return null;
}

import React, { useEffect } from 'react';
import { Singular, SingularAdData } from 'singular-react-native';
import { RewardedAd, AdEventType } from 'react-native-google-mobile-ads';
import { Platform } from 'react-native';

const AD_UNIT_ID = 'ca-app-pub-xxxxxxxxxxxxx/yyyyyyyyyy';

export default function AdMobRevenueTracker() {
  useEffect(() => {
    loadRewardedAd();
  }, []);

  const loadRewardedAd = () => {
    // Create RewardedAd instance
    const rewardedAd = RewardedAd.createForAdRequest(AD_UNIT_ID);

    // Set up event listener for ad events
    rewardedAd.addAdEventListener((type, error, data) => {
      if (type === AdEventType.LOADED) {
        console.log('Rewarded ad loaded');
      } else if (type === AdEventType.ERROR) {
        console.error('Rewarded ad failed to load:', error);
      } else if (type === AdEventType.PAID_EVENT) {
        // Handle paid event with revenue data
        handleAdRevenue(data);
      }
    });

    // Load the ad
    rewardedAd.load();
  };

  const handleAdRevenue = (data) => {
    const { value, currencyCode } = data;

    // Validate revenue and currency
    if (!value || value <= 0) {
      console.error('Invalid ad revenue value:', value);
      return;
    }

    if (!currencyCode || currencyCode.trim() === '') {
      console.error('Invalid currency code:', currencyCode);
      return;
    }

    // Convert revenue based on platform
    let revenue;
    if (Platform.OS === 'android') {
      // Android reports in micros - convert to dollars
      revenue = value / 1_000_000.0;
    } else {
      // iOS reports in dollars directly
      revenue = value;
    }

    const adRevenueData = new SingularAdData(
      'AdMob',
      currencyCode,
      revenue
    );

    // Send to Singular
    Singular.adRevenue(adRevenueData);

    console.log('Ad Revenue reported to Singular:', adRevenueData);
  };

  return null;
}

Notas de implementación:

• Detección de plataforma: Usa Platform.OS para determinar la lógica de conversión (Android divide entre 1.000.000, iOS usa el valor directamente)
• Validación de ingresos: Asegúrate de que el ingreso sea mayor que 0 antes de enviarlo
• Validación de moneda: Verifica que el código de moneda no esté vacío
• Registro de errores: Registra los datos inválidos para depuración sin enviarlos a Singular

Integración con AppLovin MAX

Implementa el tracking de ingresos publicitarios de AppLovin MAX usando la Impression-Level User Revenue API para reportar ingresos en tiempo real en todos los formatos de anuncio.

Requisitos previos

• Integra el SDK de React Native de AppLovin MAX. Consulta la Guía de inicio
• Habilita la Impression-Level User Revenue API en tu panel de AppLovin

Descripción general de la implementación

Configura listeners de ingresos publicitarios para cada formato de anuncio (Interstitial, Rewarded, Banner, MRec, App Open) para capturar los eventos de ingresos. Extrae el ingreso de adInfo.revenue y envíalo a Singular con la moneda específica de la plataforma (normalmente USD).

Tracking de ingresos de AppLovin MAX

Configura listeners globales de ingresos para todos los formatos de anuncio de AppLovin MAX.

// TurboModule direct API (React Native 0.76+ New Architecture)
import NativeSingular from 'singular-react-native/js/NativeSingular';
import {
  InterstitialAd,
  RewardedAd,
  BannerAd,
  MRecAd,
  AppOpenAd
} from 'react-native-applovin-max';

// Currency constant - AppLovin typically reports in USD
const CURRENCY = 'USD';

// Generic handler for ad revenue
const handleAdRevenue = (adInfo) => {
  if (!adInfo) {
    console.error('AdInfo is null or undefined');
    return;
  }

  const revenue = adInfo.revenue;

  // Validate revenue
  if (!revenue || revenue <= 0) {
    console.error('Invalid revenue value:', revenue);
    return;
  }

  const adRevenueData = {
    ad_platform: 'AppLovin',
    ad_currency: CURRENCY,
    ad_revenue: revenue
  };

  // Send to Singular
  NativeSingular.adRevenue(adRevenueData);

  console.log('AppLovin ad revenue reported:', adRevenueData);
};

// Set up listeners for each ad type
export const setupAppLovinRevenueTracking = () => {
  InterstitialAd.addAdRevenuePaidListener(handleAdRevenue);
  RewardedAd.addAdRevenuePaidListener(handleAdRevenue);
  BannerAd.addAdRevenuePaidListener(handleAdRevenue);
  MRecAd.addAdRevenuePaidListener(handleAdRevenue);
  AppOpenAd.addAdRevenuePaidListener(handleAdRevenue);

  console.log('AppLovin MAX revenue tracking initialized');
};

import { Singular, SingularAdData } from 'singular-react-native';
import {
  InterstitialAd,
  RewardedAd,
  BannerAd,
  MRecAd,
  AppOpenAd
} from 'react-native-applovin-max';

// Currency constant - AppLovin typically reports in USD
const CURRENCY = 'USD';

// Generic handler for ad revenue
const handleAdRevenue = (adInfo) => {
  if (!adInfo) {
    console.error('AdInfo is null or undefined');
    return;
  }

  const revenue = adInfo.revenue;

  // Validate revenue
  if (!revenue || revenue <= 0) {
    console.error('Invalid revenue value:', revenue);
    return;
  }

  const adRevenueData = new SingularAdData(
    'AppLovin',
    CURRENCY,
    revenue
  );

  // Send to Singular
  Singular.adRevenue(adRevenueData);

  console.log('AppLovin ad revenue reported:', adRevenueData);
};

// Set up listeners for each ad type
export const setupAppLovinRevenueTracking = () => {
  InterstitialAd.addAdRevenuePaidListener(handleAdRevenue);
  RewardedAd.addAdRevenuePaidListener(handleAdRevenue);
  BannerAd.addAdRevenuePaidListener(handleAdRevenue);
  MRecAd.addAdRevenuePaidListener(handleAdRevenue);
  AppOpenAd.addAdRevenuePaidListener(handleAdRevenue);

  console.log('AppLovin MAX revenue tracking initialized');
};

Notas de implementación:

• Todos los formatos de anuncio: Registra listeners para todos los tipos de anuncio que use tu app (Interstitial, Rewarded, Banner, MRec, App Open)
• Moneda: AppLovin normalmente reporta los ingresos en USD; verifícalo en tu panel
• Handler compartido: Usa una única función handler de ingresos para todos los formatos de anuncio para garantizar una validación consistente

Integración con Unity LevelPlay (IronSource)

Implementa el tracking de ingresos publicitarios de IronSource usando la Impression Level Revenue (ILR) SDK API para obtener datos a nivel de impresión de IronSource Ads y de las redes mediadas.

Requisitos previos

• Integra el SDK de React Native de IronSource. Consulta la Guía de inicio
• Habilita el flag ARM SDK Postbacks en tu panel de IronSource
• Consulta la documentación de Medición de ingresos publicitarios de IronSource .

Descripción general de la implementación

Suscríbete al emisor de eventos onImpressionDataSuccess para recibir los datos de impresión. Extrae el ingreso de impressionData.revenue y envíalo a Singular con la moneda USD.

Tracking de ingresos de IronSource

Configura el listener de eventos para los callbacks de datos de impresión de IronSource.

// TurboModule direct API (React Native 0.76+ New Architecture)
import { NativeModules, NativeEventEmitter } from 'react-native';
import NativeSingular from 'singular-react-native/js/NativeSingular';

const { IronSourceModule } = NativeModules;
const ironSourceEventEmitter = new NativeEventEmitter(IronSourceModule);

const AD_PLATFORM = 'IronSource';
const CURRENCY = 'USD'; // IronSource typically reports in USD

export const setupIronSourceRevenueTracking = () => {
  ironSourceEventEmitter.addListener('onImpressionDataSuccess', (impressionData) => {
    // Validate impression data
    if (!impressionData) {
      console.error('No impression data available');
      return;
    }

    const revenue = impressionData.revenue;

    // Validate revenue value
    if (!revenue || revenue <= 0) {
      console.error('Invalid revenue value:', revenue);
      return;
    }

    const adRevenueData = {
      ad_platform: AD_PLATFORM,
      ad_currency: CURRENCY,
      ad_revenue: revenue
    };

    // Send to Singular
    NativeSingular.adRevenue(adRevenueData);

    console.log('IronSource ad revenue reported:', adRevenueData);
  });

  console.log('IronSource revenue tracking initialized');
};

import { NativeModules, NativeEventEmitter } from 'react-native';
import { Singular, SingularAdData } from 'singular-react-native';

const { IronSourceModule } = NativeModules;
const ironSourceEventEmitter = new NativeEventEmitter(IronSourceModule);

const AD_PLATFORM = 'IronSource';
const CURRENCY = 'USD'; // IronSource typically reports in USD

export const setupIronSourceRevenueTracking = () => {
  ironSourceEventEmitter.addListener('onImpressionDataSuccess', (impressionData) => {
    // Validate impression data
    if (!impressionData) {
      console.error('No impression data available');
      return;
    }

    const revenue = impressionData.revenue;

    // Validate revenue value
    if (!revenue || revenue <= 0) {
      console.error('Invalid revenue value:', revenue);
      return;
    }

    const adRevenueData = new SingularAdData(
      AD_PLATFORM,
      CURRENCY,
      revenue
    );

    // Send to Singular
    Singular.adRevenue(adRevenueData);

    console.log('IronSource ad revenue reported:', adRevenueData);
  });

  console.log('IronSource revenue tracking initialized');
};

Notas de implementación:

• Emisor de eventos nativo: IronSource usa el sistema de eventos nativos de React Native para los callbacks de impresión
• Postbacks ARM: Verifica que el flag ARM SDK Postbacks esté habilitado en el panel de IronSource
• Suscripción a eventos: Configura el listener antes de inicializar el SDK de IronSource

Integración con TradPlus

Implementa el tracking de ingresos publicitarios de TradPlus usando listeners globales de impresión para capturar datos de eCPM de las impresiones de anuncios.

Requisitos previos

• Integra el SDK de React Native de TradPlus en tu app
• Configura las unidades de anuncio de TradPlus en tu panel

Descripción general de la implementación

Suscríbete al evento onImpressionSuccess para recibir los datos de impresión de anuncios. Extrae el valor de eCPM de tpAdInfo.ecpm, conviértelo de milésimas a dólares (divide entre 1000) y envíalo a Singular.

Tracking de ingresos de TradPlus

Configura el listener de eventos para los callbacks de impresión exitosa de TradPlus.

// TurboModule direct API (React Native 0.76+ New Architecture)
import { NativeModules, NativeEventEmitter } from 'react-native';
import NativeSingular from 'singular-react-native/js/NativeSingular';

const { TradPlusModule } = NativeModules;
const tradPlusEventEmitter = new NativeEventEmitter(TradPlusModule);

const AD_PLATFORM = 'TradPlus';
const CURRENCY = 'USD'; // TradPlus typically reports in USD

export const setupTradPlusRevenueTracking = () => {
  tradPlusEventEmitter.addListener('onImpressionSuccess', (tpAdInfo) => {
    // Validate ad info
    if (!tpAdInfo) {
      console.error('AdInfo is null');
      return;
    }

    // eCPM is reported in milli-units - convert to dollars
    if (!tpAdInfo.ecpm || typeof tpAdInfo.ecpm !== 'number') {
      console.error('Invalid eCPM value:', tpAdInfo.ecpm);
      return;
    }

    const revenue = tpAdInfo.ecpm / 1000.0;

    // Validate revenue after conversion
    if (revenue <= 0) {
      console.error('Revenue out of expected range:', revenue);
      return;
    }

    const adRevenueData = {
      ad_platform: AD_PLATFORM,
      ad_currency: CURRENCY,
      ad_revenue: revenue
    };

    // Send to Singular
    NativeSingular.adRevenue(adRevenueData);

    console.log('TradPlus ad revenue reported:', adRevenueData);
  });

  console.log('TradPlus revenue tracking initialized');
};

import { NativeModules, NativeEventEmitter } from 'react-native';
import { Singular, SingularAdData } from 'singular-react-native';

const { TradPlusModule } = NativeModules;
const tradPlusEventEmitter = new NativeEventEmitter(TradPlusModule);

const AD_PLATFORM = 'TradPlus';
const CURRENCY = 'USD'; // TradPlus typically reports in USD

export const setupTradPlusRevenueTracking = () => {
  tradPlusEventEmitter.addListener('onImpressionSuccess', (tpAdInfo) => {
    // Validate ad info
    if (!tpAdInfo) {
      console.error('AdInfo is null');
      return;
    }

    // eCPM is reported in milli-units - convert to dollars
    if (!tpAdInfo.ecpm || typeof tpAdInfo.ecpm !== 'number') {
      console.error('Invalid eCPM value:', tpAdInfo.ecpm);
      return;
    }

    const revenue = tpAdInfo.ecpm / 1000.0;

    // Validate revenue after conversion
    if (revenue <= 0) {
      console.error('Revenue out of expected range:', revenue);
      return;
    }

    const adRevenueData = new SingularAdData(
      AD_PLATFORM,
      CURRENCY,
      revenue
    );

    // Send to Singular
    Singular.adRevenue(adRevenueData);

    console.log('TradPlus ad revenue reported:', adRevenueData);
  });

  console.log('TradPlus revenue tracking initialized');
};

Notas de implementación:

• Formato del eCPM: TradPlus reporta el eCPM en milésimas; divide siempre entre 1000 antes de enviarlo a Singular
• Verificación de tipos: Comprueba que el eCPM sea un número antes de convertirlo
• Validación posterior a la conversión: Valida que el ingreso sea mayor que 0 después de la división

Integración genérica

Implementa el tracking de ingresos publicitarios para plataformas de mediación personalizadas o integraciones directas usando el método genérico adRevenue() .

Cuándo usar la integración genérica

• Plataformas de mediación personalizadas no cubiertas por las integraciones estándar
• Integraciones directas con redes publicitarias sin mediación
• Cálculos de ingresos publicitarios del lado del servidor reenviados a la app
• Pruebas del tracking de ingresos publicitarios con datos simulados

Ejemplo de implementación genérica

Crea una función reutilizable que reporte ingresos publicitarios desde cualquier fuente con la validación adecuada.

// TurboModule direct API (React Native 0.76+ New Architecture)
import NativeSingular from 'singular-react-native/js/NativeSingular';

/**
 * Report ad revenue to Singular with validation
 * 
 * @param {string} adPlatform - Name of the ad platform or mediation provider
 * @param {string} currency - ISO 4217 three-letter currency code (e.g., 'USD', 'EUR')
 * @param {number} revenue - Revenue amount in the specified currency
 */
export const reportAdRevenue = (adPlatform, currency, revenue) => {
  // Validate platform
  if (!adPlatform || adPlatform.trim() === '') {
    console.error('Invalid ad platform:', adPlatform);
    return;
  }

  // Validate currency code
  if (!currency || currency.trim() === '' || currency.length !== 3) {
    console.error('Invalid currency code:', currency);
    return;
  }

  // Validate revenue
  if (typeof revenue !== 'number' || revenue <= 0 || !isFinite(revenue)) {
    console.error('Invalid revenue value:', revenue);
    return;
  }

  const adRevenueData = {
    ad_platform: adPlatform.trim(),
    ad_currency: currency.toUpperCase().trim(),
    ad_revenue: revenue
  };

  // Send to Singular
  NativeSingular.adRevenue(adRevenueData);

  console.log('Ad Revenue reported to Singular:', adRevenueData);
};

// Example usage
export const trackCustomAdRevenue = () => {
  // Example: Custom mediation platform
  reportAdRevenue('CustomPlatform', 'USD', 0.05);

  // Example: Direct network integration
  reportAdRevenue('FacebookAudienceNetwork', 'EUR', 0.03);
};

import { Singular, SingularAdData } from 'singular-react-native';

/**
 * Report ad revenue to Singular with validation
 * 
 * @param {string} adPlatform - Name of the ad platform or mediation provider
 * @param {string} currency - ISO 4217 three-letter currency code (e.g., 'USD', 'EUR')
 * @param {number} revenue - Revenue amount in the specified currency
 */
export const reportAdRevenue = (adPlatform, currency, revenue) => {
  // Validate platform
  if (!adPlatform || adPlatform.trim() === '') {
    console.error('Invalid ad platform:', adPlatform);
    return;
  }

  // Validate currency code
  if (!currency || currency.trim() === '' || currency.length !== 3) {
    console.error('Invalid currency code:', currency);
    return;
  }

  // Validate revenue
  if (typeof revenue !== 'number' || revenue <= 0 || !isFinite(revenue)) {
    console.error('Invalid revenue value:', revenue);
    return;
  }

  const adRevenueData = new SingularAdData(
    adPlatform.trim(),
    currency.toUpperCase().trim(),
    revenue
  );

  // Send to Singular
  Singular.adRevenue(adRevenueData);

  console.log('Ad Revenue reported to Singular:', adRevenueData);
};

// Example usage
export const trackCustomAdRevenue = () => {
  // Example: Custom mediation platform
  reportAdRevenue('CustomPlatform', 'USD', 0.05);

  // Example: Direct network integration
  reportAdRevenue('FacebookAudienceNetwork', 'EUR', 0.03);
};

Funciones de validación:

• Validación de plataforma: Garantiza que el nombre de la plataforma no esté vacío y no tenga espacios sobrantes
• Validación de moneda: Verifica el formato del código ISO 4217 de tres letras y lo convierte a mayúsculas
• Validación de ingresos: Comprueba que sea un número positivo y excluye NaN e Infinity
• Seguridad de tipos: La interfaz de TypeScript garantiza la verificación de tipos en tiempo de compilación

Buenas prácticas

Validación de datos

Implementa una validación robusta para evitar que lleguen datos incorrectos a la analítica de Singular.

• Ingreso positivo: Verifica siempre que el ingreso sea mayor que cero antes de enviarlo
• Moneda válida: Usa códigos ISO 4217 y verifica que las cadenas no estén vacías
• Consistencia de plataforma: Usa nombres de plataforma consistentes en toda tu app (por ejemplo, siempre "AdMob", no "Admob" ni "ADMOB")
• Verificación de tipos: Comprueba que los tipos de datos coincidan con los valores esperados (número para el ingreso, cadena para la moneda y la plataforma)
• Comprobación de nulos: Maneja adecuadamente los valores null, undefined y vacíos

Manejo de monedas

Garantiza un reporte de moneda preciso para apps multirregión y redes publicitarias diversas.

• Verifica la moneda de la plataforma: Consulta la documentación de tu plataforma de mediación para conocer la moneda predeterminada (la mayoría usa USD)
• Formato consistente: Usa siempre códigos ISO 4217 de tres letras en mayúsculas
• Sin conversión: Reporta el ingreso en la moneda proporcionada por la red publicitaria; no conviertas monedas
• Moneda por red: Distintas redes publicitarias pueden reportar en monedas distintas; verifica cada una por separado

Consideraciones específicas de plataforma

Maneja las diferencias de plataforma en los formatos y unidades de reporte de ingresos.

• AdMob Android: Ingresos reportados en micros; divide entre 1.000.000 para convertirlos a dólares
• AdMob iOS: Ingresos reportados en dólares; usa el valor directamente sin conversión
• TradPlus: eCPM reportado en milésimas; divide entre 1.000 para convertirlo a dólares
• AppLovin: Ingresos reportados en dólares; usa el valor directamente
• IronSource: Ingresos reportados en dólares; usa el valor directamente

Manejo de errores y registro

Implementa un registro completo para depurar y monitorear el tracking de ingresos publicitarios.

• Fallas de validación: Registra mensajes de error detallados cuando falle la validación, incluyendo los valores reales recibidos
• Registro de éxitos: Registra los reportes de ingresos exitosos en desarrollo con la plataforma, la moneda y el monto
• Monitoreo en producción: Usa servicios de tracking de errores (Sentry, Bugsnag) para monitorear las fallas de validación en producción
• Anomalías de ingresos: Configura alertas para valores de ingresos inusualmente altos o bajos que puedan indicar problemas de integración
• Cobertura de plataformas: Monitorea qué plataformas publicitarias están reportando ingresos para asegurarte de que todas estén integradas correctamente

Estrategia de pruebas

Verifica la implementación del tracking de ingresos publicitarios antes de desplegar a producción.

1. Anuncios de prueba: Usa unidades de anuncio de prueba de tu plataforma de mediación durante el desarrollo
2. Valida los eventos: Consulta el panel de Singular para ver los eventos de ingresos publicitarios después de las impresiones de prueba
3. Verifica la moneda: Confirma que los códigos de moneda aparezcan correctamente en los informes de Singular
4. Precisión de plataforma: Asegúrate de que los nombres de plataforma sean consistentes y reconocibles en los informes
5. Montos de ingresos: Verifica que los montos de ingresos coincidan con los rangos esperados para las unidades de anuncio de prueba
6. Multiplataforma: Prueba en iOS y Android para verificar la lógica de conversión específica de cada plataforma

Optimización del rendimiento

Minimiza el impacto del tracking de ingresos publicitarios en el rendimiento de tu app.

• Procesamiento asíncrono: Los callbacks de ingresos se ejecutan de forma asíncrona, sin bloquear el hilo principal
• Validación mínima: Mantén la lógica de validación simple y rápida (verificaciones de tipo y de rango)
• Consideración de lotes: Para apps de alto volumen, considera el procesamiento por lotes si tu backend de analítica lo admite
• Manejo de errores: Usa bloques try-catch para evitar que los errores del tracking de ingresos hagan fallar tu app

Verificación y resolución de problemas

Verificar la implementación

Confirma que los datos de ingresos publicitarios lleguen correctamente a Singular.

1. Habilita los anuncios de prueba: Configura el modo de prueba en tu plataforma de mediación
2. Genera impresiones: Muestra anuncios de prueba y dispara eventos pagados
3. Revisa los logs: Verifica que los logs del tracking de ingresos aparezcan en la consola con los valores correctos
4. Verificación en el panel: Consulta el panel de Singular para ver los eventos de ingresos publicitarios (puede tardar entre 15 y 30 minutos)
5. Detalles del evento: Verifica la moneda, la plataforma y los montos de ingresos en los detalles del evento en Singular

Problemas frecuentes

• No hay eventos de ingresos: Verifica que los handlers de eventos pagados estén registrados antes de cargar los anuncios y que el SDK de mediación se inicialice correctamente
• Ingresos en cero: Revisa la lógica de conversión específica de la plataforma (micros a dólares para AdMob en Android, milésimas a dólares para TradPlus)
• Moneda incorrecta: Verifica que el código de moneda coincida con lo que reporta tu plataforma de mediación; consulta la documentación de la plataforma
• Nombre de plataforma no coincidente: Usa nombres de plataforma consistentes que coincidan con las plataformas reconocidas por Singular
• Eventos faltantes: Asegúrate de que el SDK de Singular se inicialice antes de que ocurran los eventos de ingresos publicitarios
• Eventos duplicados: Verifica que los handlers de eventos pagados se registren solo una vez, no en cada carga de anuncio