Atribuição de receita de anúncios

Rastreie a receita de anúncios das plataformas de mediação e atribua-a às campanhas de marketing que adquiriram seus usuários, oferecendo visibilidade completa do ROI através dos custos de campanha, compras no app e monetização por publicidade.

Visão geral

O que é a atribuição de receita de anúncios

A atribuição de receita de anúncios conecta a receita de anúncios de aplicativos móveis às campanhas de aquisição de usuários que geraram as instalações do app, permitindo que você meça a verdadeira rentabilidade da campanha, incluindo a monetização por publicidade.

Principais benefícios:

• Visão unificada de ROI: Veja os custos de campanha, a receita in-app e a receita de anúncios em um único dashboard
• Otimização de campanha: Envie os dados de receita de anúncios de volta para as redes de anúncios para melhorar o lance e a segmentação
• Medição de LTV: Calcule o valor completo do ciclo de vida do usuário incluindo a monetização por publicidade

Fontes de dados: Os dados de receita de anúncios normalmente vêm da sua plataforma de mediação (por exemplo, AdMob, AppLovin MAX, IronSource) em nível de usuário ou em nível de impressão. A Singular oferece suporte a vários métodos de integração para receber esses dados.

Requisitos de implementação

Diretrizes críticas

Etapas de configuração

Siga estas etapas para implementar a atribuição de receita de anúncios:

1. Atualizar o SDK: Certifique-se de estar usando a versão mais recente do SDK da Singular
2. Escolher a integração: Selecione a integração da plataforma de mediação abaixo que corresponda à sua configuração
3. Implementar callbacks: Adicione listeners de eventos paid específicos da plataforma para capturar os dados de receita
4. Validar os dados: Teste o relatório de receita e verifique que os dados apareçam no dashboard da Singular

Integrações de plataformas

Integração com AdMob

Rastreie a receita de anúncios do Google AdMob usando o listener de eventos paid para o relatório de receita em nível de impressão.

Requisitos:

• Habilite o rastreamento de eventos paid na sua conta do AdMob (consulte o suporte do AdMob )
• Implemente o SDK do Google Mobile Ads para iOS (consulte o Guia de introdução )

Implementação

Defina um handler de eventos paid ao carregar os anúncios para capturar os dados de receita e enviá-los para 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

Integração com AppLovin MAX

Compartilhe a receita de anúncios em nível de impressão usando a Impression-Level User Revenue API da AppLovin.

Requisitos:

• Implemente o SDK AppLovin MAX (consulte o Guia da Impression-Level Revenue API )
• Assine o tópico max_revenue_events via AppLovin Communicator

Implementação

Trate as mensagens de receita por meio do callback do 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");
        }
    }
}

Integração com Unity LevelPlay (IronSource)

Rastreie a receita em nível de impressão do ironSource e das redes mediadas usando o SDK do IronSource.

Requisitos:

• Implemente o SDK do ironSource (consulte o Guia de introdução )
• Habilite a flag ARM SDK Postbacks no seu dashboard do IronSource
• Defina o impression data listener para receber os callbacks de receita

Implementação

Implemente o callback impression data success para capturar e enviar a receita.

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);
}

Integração com TradPlus

Capture a receita de anúncios da mediação TradPlus usando o impression delegate.

Requisitos:

• Defina o impression delegate via TradPlus.sharedInstance().impressionDelegate
• Trate o callback tradPlusAdImpression para receber os dados de receita
• Converta o eCPM de miliunidades para a moeda padrão (divida por 1000)

Implementação

Registre um impression delegate para rastrear todas as impressões de anúncios e a receita.

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);
}

Integração genérica (outras plataformas)

Integre qualquer plataforma de mediação usando a interface genérica SingularAdData .

Requisitos:

• Acesso aos dados de receita em nível de impressão da sua plataforma de mediação
• Valor da receita em unidades padrão de moeda
• Código de moeda ISO 4217 (por exemplo, USD, EUR, INR)

Implementação

Crie um objeto SingularAdData com o nome da plataforma, moeda e receita, depois chame 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 os dados do anúncio com atributos adicionais

SingularAdData expõe métodos setter para metadados em nível de impressão. Use-os para enriquecer o evento com detalhes de placement, ad unit, agrupamento de mediação e precisão quando sua plataforma de mediação fornecê-los.

Exemplo em 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)

Exemplo em 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];

Testes e validação

Verificar o relatório de receita

Teste sua implementação de receita de anúncios para garantir que os dados fluam corretamente para a Singular.

1. Verificar logs: Verifique se os logs do callback de receita aparecem com os valores e a moeda corretos
2. Anúncios de teste: Carregue e exiba anúncios de teste para disparar os eventos de receita
3. Verificação no dashboard: Confirme que a receita aparece no dashboard da Singular em até 24 horas
4. Precisão dos dados: Valide que os valores de receita correspondam aos relatórios da sua plataforma de mediação