Atribución de ingresos por publicidad

Rastrea los ingresos por publicidad de las plataformas de mediación y atribúyelos a las campañas de marketing que adquirieron a tus usuarios, ofreciendo visibilidad completa del ROI a través de los costos de campaña, las compras dentro de la app y la monetización publicitaria.

Descripción general

Qué es la atribución de ingresos por publicidad

La atribución de ingresos por publicidad conecta los ingresos por publicidad de aplicaciones móviles con las campañas de adquisición de usuarios que generaron las instalaciones, permitiéndote medir la rentabilidad real de la campaña, incluyendo la monetización publicitaria.

Beneficios clave:

• Vista unificada del ROI: Visualiza los costos de campaña, los ingresos in-app y los ingresos por publicidad en un solo dashboard
• Optimización de campañas: Envía los datos de ingresos por publicidad de vuelta a las redes publicitarias para mejorar la puja y el targeting
• Medición de LTV: Calcula el valor total del ciclo de vida del usuario, incluyendo la monetización publicitaria

Fuentes de datos: Los datos de ingresos por publicidad generalmente provienen de tu plataforma de mediación (por ejemplo, AdMob, AppLovin MAX, IronSource) a nivel de usuario o a nivel de impresión. Singular admite varios métodos de integración para recibir estos datos.

Requisitos de implementación

Pautas críticas

Pasos de configuración

Sigue estos pasos para implementar la atribución de ingresos por publicidad:

1. Actualizar el SDK: Asegúrate de estar usando la versión más reciente del SDK de Singular
2. Elegir integración: Selecciona la integración de la plataforma de mediación que coincida con tu configuración
3. Implementar callbacks: Agrega listeners de eventos paid específicos de la plataforma para capturar los datos de ingresos
4. Validar los datos: Prueba el reporte de ingresos y verifica que los datos aparezcan en el dashboard de Singular

Integraciones de plataformas

Integración con AdMob

Rastrea los ingresos por publicidad de Google AdMob usando el listener de eventos paid para reportar ingresos a nivel de impresión.

Requisitos:

• Habilita el tracking de eventos paid en tu cuenta de AdMob (consulta el soporte de AdMob )
• Implementa el SDK de Google Mobile Ads para iOS (consulta la Guía de inicio )

Implementación

Establece un handler de eventos paid al cargar los anuncios para capturar los datos de ingresos y enviarlos a Singular.

import Singular
import GoogleMobileAds

private let adUnitID = "AD_UNIT_ID"
var rewardedAd: GADRewardedAd?

func loadRewardedAd() {
    let request = GADRequest()

    GADRewardedAd.load(withAdUnitID: adUnitID, request: request) { [weak self] ad, error in
        guard let self = self else { return }

        if let error = error {
            print("Rewarded ad failed to load: \(error.localizedDescription)")
            return
        }

        self.rewardedAd = ad

        // Set paid event handler for revenue tracking
        self.rewardedAd?.paidEventHandler = { adValue in
            // Extract revenue and currency from AdValue
            let revenue = adValue.value.doubleValue
            let currency = adValue.currencyCode

            // Validate revenue and currency before sending
            guard revenue > 0, let currency = currency, !currency.isEmpty else {
                print("Invalid ad revenue data: revenue = \(revenue), currency = \(String(describing: currency))")
                return
            }

            // Create ad revenue data object
            let data = SingularAdData(
                adPlatform: "AdMob",
                currency: currency,
                revenue: revenue
            )

            // Send to Singular
            Singular.adRevenue(data)
            print("Ad revenue sent: \(revenue) \(currency)")
        }
    }
}

#import <Singular/Singular.h>
#import <GoogleMobileAds/GoogleMobileAds.h>

static NSString *const adUnitID = @"AD_UNIT_ID";

@interface AdManager ()
@property(nonatomic, strong) GADRewardedAd *rewardedAd;
@end

@implementation AdManager

- (void)loadRewardedAd {
    GADRequest *request = [[GADRequest alloc] init];

    [GADRewardedAd loadWithAdUnitID:adUnitID
                            request:request
                  completionHandler:^(GADRewardedAd *ad, NSError *error) {
        if (error) {
            NSLog(@"Rewarded ad failed to load: %@", error.localizedDescription);
            return;
        }

        self.rewardedAd = ad;

        // Set paid event handler for revenue tracking
        self.rewardedAd.paidEventHandler = ^(GADAdValue *adValue) {
            // Extract revenue and currency from AdValue
            double revenue = adValue.value.doubleValue;
            NSString *currency = adValue.currencyCode;

            // Validate revenue and currency before sending
            if (revenue > 0 && currency.length > 0) {
                // Create ad revenue data object
                SingularAdData *data = [[SingularAdData alloc]
                    initWithAdPlatform:@"AdMob"
                    currency:currency
                    revenue:revenue];

                // Send to Singular
                [Singular adRevenue:data];
                NSLog(@"Ad revenue sent: %f %@", revenue, currency);
            } else {
                NSLog(@"Invalid ad revenue data: revenue = %f, currency = %@",
                    revenue, currency);
            }
        };
    }];
}

@end

Integración con AppLovin MAX

Comparte los ingresos por publicidad a nivel de impresión usando la Impression-Level User Revenue API de AppLovin.

Requisitos:

• Implementa el SDK de AppLovin MAX (consulta la Guía de la Impression-Level Revenue API )
• Suscríbete al tópico max_revenue_events a través de AppLovin Communicator

Implementación

Maneja los mensajes de ingresos a través del callback de AppLovin Communicator.

import Singular
import AppLovinSDK

func didReceive(_ message: ALCMessage) {
    // Check for revenue events topic
    if message.topic == "max_revenue_events" {
        // Extract and validate revenue value
        guard let revenueValue = message.data["revenue"] as? Double,
              revenueValue > 0 else {
            print("Failed to parse valid revenue value or revenue is not greater than 0")
            return
        }

        // Create ad revenue data object
        let data = SingularAdData(
            adPlatform: "AppLovin",
            currency: "USD",  // AppLovin typically reports in USD
            revenue: revenueValue
        )

        // Send to Singular
        Singular.adRevenue(data)
        print("Ad revenue sent: \(revenueValue) USD")
    }
}

#import <Singular/Singular.h>
#import <AppLovinSDK/AppLovinSDK.h>

- (void)didReceive:(ALCMessage *)message {
    // Check for revenue events topic
    if ([@"max_revenue_events" isEqualToString:message.topic]) {
        NSDictionary *data = message.data;

        // Extract and validate revenue value
        NSNumber *revenueNumber = data[@"revenue"];
        double revenueValue = [revenueNumber doubleValue];

        if (revenueValue > 0) {
            // Create ad revenue data object
            SingularAdData *adData = [[SingularAdData alloc]
                initWithAdPlatform:@"AppLovin"
                currency:@"USD"
                revenue:revenueValue];

            // Send to Singular
            [Singular adRevenue:adData];
            NSLog(@"Ad revenue sent: %f USD", revenueValue);
        } else {
            NSLog(@"Failed to parse valid revenue value or revenue is not greater than 0");
        }
    }
}

Integración con Unity LevelPlay (IronSource)

Rastrea los ingresos a nivel de impresión de ironSource y las redes mediadas usando el SDK de IronSource.

Requisitos:

• Implementa el SDK de ironSource (consulta la Guía de inicio )
• Habilita el flag ARM SDK Postbacks en tu dashboard de IronSource
• Configura el impression data listener para recibir los callbacks de ingresos

Implementación

Implementa el callback impression data success para capturar y enviar los ingresos.

import Singular
import IronSource

func impressionDataDidSucceed(_ impressionData: ISImpressionData?) {
    // Validate impression data
    guard let impressionData = impressionData else {
        print("No impression data available")
        return
    }

    // Extract and validate revenue
    let revenue = impressionData.revenue
    guard revenue > 0 else {
        print("Invalid revenue value: \(revenue)")
        return
    }

    // Create ad revenue data object
    let data = SingularAdData(
        adPlatform: "IronSource",
        currency: "USD",  // IronSource typically reports in USD
        revenue: revenue
    )

    // Send to Singular
    Singular.adRevenue(data)
    print("Ad revenue sent: \(revenue) USD")
}

#import <Singular/Singular.h>
#import <IronSource/IronSource.h>

- (void)impressionDataDidSucceed:(ISImpressionData *)impressionData {
    // Validate impression data
    if (!impressionData) {
        NSLog(@"No impression data available");
        return;
    }

    // Extract and validate revenue
    double revenue = impressionData.revenue;
    if (revenue <= 0) {
        NSLog(@"Invalid revenue value: %f", revenue);
        return;
    }

    // Create ad revenue data object
    SingularAdData *data = [[SingularAdData alloc]
        initWithAdPlatform:@"IronSource"
        currency:@"USD"
        revenue:revenue];

    // Send to Singular
    [Singular adRevenue:data];
    NSLog(@"Ad revenue sent: %f USD", revenue);
}

Integración con TradPlus

Captura los ingresos por publicidad de la mediación de TradPlus usando el impression delegate.

Requisitos:

• Configura el impression delegate vía TradPlus.sharedInstance().impressionDelegate
• Maneja el callback tradPlusAdImpression para recibir los datos de ingresos
• Convierte el eCPM de miliunidades a la moneda estándar (divide entre 1000)

Implementación

Registra un impression delegate para rastrear todas las impresiones de anuncios y los ingresos.

import Singular
import TradPlusSDK

// Set up the delegate
TradPlus.sharedInstance().impressionDelegate = self

// Delegate method for handling ad impressions
func tradPlusAdImpression(_ adInfo: [String: Any]) {
    let currency = "USD"

    // Extract and validate eCPM value
    guard let ecpmValue = adInfo["ecpm"] as? NSNumber else {
        print("No eCPM data available in adInfo")
        return
    }

    // Convert eCPM from milli-units to dollars
    let revenue = ecpmValue.doubleValue / 1000.0

    // Validate revenue
    guard revenue > 0 else {
        print("Ad Revenue value out of expected range: \(revenue)")
        return
    }

    // Create ad revenue data object
    let data = SingularAdData(
        adPlatform: "TradPlus",
        currency: currency,
        revenue: revenue
    )

    // Send to Singular
    Singular.adRevenue(data)
    print("Ad revenue sent: \(revenue) \(currency)")
}

#import <Singular/Singular.h>
#import <TradPlusSDK/TradPlusSDK.h>

// Set up the delegate
TradPlus.sharedInstance.impressionDelegate = self;

// Delegate method for handling ad impressions
- (void)tradPlusAdImpression:(NSDictionary<NSString *, id> *)adInfo {
    NSString *currency = @"USD";

    // Extract and validate eCPM value
    NSNumber *ecpmValue = adInfo[@"ecpm"];
    if (!ecpmValue) {
        NSLog(@"No eCPM data available in adInfo");
        return;
    }

    // Convert eCPM from milli-units to dollars
    double revenue = [ecpmValue doubleValue] / 1000.0;

    // Validate revenue
    if (revenue <= 0) {
        NSLog(@"Ad Revenue value out of expected range: %f", revenue);
        return;
    }

    // Create ad revenue data object
    SingularAdData *data = [[SingularAdData alloc]
        initWithAdPlatform:@"TradPlus"
        currency:currency
        revenue:revenue];

    // Send to Singular
    [Singular adRevenue:data];
    NSLog(@"Ad revenue sent: %f %@", revenue, currency);
}

Integración genérica (otras plataformas)

Integra cualquier plataforma de mediación usando la interfaz genérica SingularAdData .

Requisitos:

• Acceso a los datos de ingresos a nivel de impresión de tu plataforma de mediación
• Monto de ingresos en unidades de moneda estándar
• Código de moneda ISO 4217 (por ejemplo, USD, EUR, INR)

Implementación

Crea un objeto SingularAdData con el nombre de la plataforma, la moneda y los ingresos, luego llama a Singular.adRevenue() .

import Singular

func reportAdRevenue(adPlatform: String, currency: String, revenue: Double) {
    // Validate revenue
    guard revenue > 0 else {
        print("Invalid revenue value: \(revenue)")
        return
    }

    // Validate currency
    guard !currency.isEmpty else {
        print("Invalid currency: \(currency)")
        return
    }

    // Create ad revenue data object
    let data = SingularAdData(
        adPlatform: adPlatform,
        currency: currency,
        revenue: revenue
    )

    // Send to Singular
    Singular.adRevenue(data)
    print("Revenue sent: \(revenue) \(currency) from \(adPlatform)")
}

// Example usage
reportAdRevenue(adPlatform: "MyMediationPlatform", currency: "USD", revenue: 0.05)

#import <Singular/Singular.h>

- (void)reportAdRevenueWithPlatform:(NSString *)adPlatform
                           currency:(NSString *)currency
                            revenue:(double)revenue {
    // Validate revenue
    if (revenue <= 0) {
        NSLog(@"Invalid revenue value: %f", revenue);
        return;
    }

    // Validate currency
    if (!currency || currency.length == 0) {
        NSLog(@"Invalid currency: %@", currency);
        return;
    }

    // Create ad revenue data object
    SingularAdData *data = [[SingularAdData alloc]
        initWithAdPlatform:adPlatform
        currency:currency
        revenue:revenue];

    // Send to Singular
    [Singular adRevenue:data];
    NSLog(@"Revenue sent: %f %@ from %@", revenue, currency, adPlatform);
}

// Example usage
[self reportAdRevenueWithPlatform:@"MyMediationPlatform"
                         currency:@"USD"
                          revenue:0.05];

Enriquecer los datos del anuncio con atributos adicionales

SingularAdData expone métodos setter para los metadatos a nivel de impresión. Úsalos para enriquecer el evento con detalles de placement, ad unit, agrupación de mediación y precisión cuando tu plataforma de mediación los proporcione.

Ejemplo en Swift:

let data = SingularAdData(adPlatform: "AdMob",
                          withCurrency: "USD",
                          withRevenue: NSNumber(value: 0.05))
data.setAdUnitId("ca-app-pub-123456789/1234567890")
data.setAdType("Rewarded")
data.setAdPlacementName("level_complete")
data.setImpressionId("imp_abc123")
data.setPrecision("publisher_provided")

Singular.adRevenue(data)

Ejemplo en Objective-C:

SingularAdData *data = [[SingularAdData alloc]
    initWithAdPlatform:@"AdMob"
          withCurrency:@"USD"
           withRevenue:@(0.05)];
[data setAdUnitId:@"ca-app-pub-123456789/1234567890"];
[data setAdType:@"Rewarded"];
[data setAdPlacementName:@"level_complete"];
[data setImpressionId:@"imp_abc123"];
[data setPrecision:@"publisher_provided"];

[Singular adRevenue:data];

Pruebas y validación

Verificar el reporte de ingresos

Prueba tu implementación de ingresos por publicidad para asegurarte de que los datos fluyan correctamente hacia Singular.

1. Revisar los logs: Verifica que los logs del callback de ingresos aparezcan con los valores y la moneda correctos
2. Anuncios de prueba: Carga y muestra anuncios de prueba para disparar los eventos de ingresos
3. Verificación en el dashboard: Confirma que los ingresos aparezcan en el dashboard de Singular dentro de 24 horas
4. Precisión de los datos: Valida que los montos de ingresos coincidan con los reportes de tu plataforma de mediación