Documento

Atribución de ingresos publicitarios

Realice un seguimiento de los ingresos publicitarios de las plataformas de mediación y atribúyalos a las campañas de marketing que adquirieron a sus usuarios, proporcionando una visibilidad completa del ROI a través de los costes de campaña, las compras dentro de la aplicación y la monetización de la publicidad.

Visión general

Qué es la atribución de ingresos publicitarios

Ad Revenue Attribution conecta los ingresos publicitarios de las aplicaciones móviles con las campañas de adquisición de usuarios que impulsaron las instalaciones de la aplicación, lo que le permite medir la verdadera rentabilidad de la campaña, incluida la monetización de la publicidad.

Ventajas clave:

Vista unificada del ROI: Vea los costes de campaña, los ingresos dentro de la aplicación y los ingresos publicitarios en un único panel de control.
Optimización de campañas: Envíe los datos de ingresos publicitarios a las redes publicitarias para mejorar las pujas y la segmentación.
Medición LTV: Calcule el valor total de la vida útil del usuario, incluida la monetización de la publicidad.

Fuentes de datos: Los datos de ingresos publicitarios normalmente provienen de su plataforma de mediación (por ejemplo, AdMob, AppLovin MAX, IronSource), ya sea a nivel de usuario o a nivel de impresión. Singular soporta múltiples métodos de integración para recibir estos datos.

Más información: Consulte las preguntas frecuentes sobre la atribución de ingresos publicitariospara obtener información detallada sobre la configuración, la generación de informes y la resolución de problemas.

Requisitos de implementación

Directrices críticas

La precisión de los datos es fundamental:

Códigos de moneda: Utilice códigos de moneda ISO 4217 de tres letras (por ejemplo, USD, EUR, INR). Muchas plataformas de mediación informan en USD; verifique la divisa de su plataforma antes de la implementación.
Validar antes de enviar: Valide siempre los datos de ingresos y divisas antes de llamar a Singular.adRevenue(). Los datos incorrectos no pueden corregirse después del envío.
Diferencias entre plataformas: Algunos SDK informan de los ingresos en micros (dividir por 1.000.000), mientras que otros informan en unidades monetarias estándar. Consulte la documentación de su plataforma.

Pasos de configuración

Siga estos pasos para implementar la atribución de ingresos publicitarios:

Actualice el SDK: Asegúrese de que está utilizando la última versión de Singular SDK.
Elija Integración: Seleccione la integración de la plataforma de mediación que coincida con su configuración.
Implemente retrollamadas: Añada escuchadores de eventos de pago específicos de la plataforma para capturar datos de ingresos
Validar datos: Pruebe los informes de ingresos y verifique que los datos aparecen en el panel de Singular

Integraciones de plataformas

Integración con AdMob

Realice un seguimiento de los ingresos publicitarios de Google AdMob utilizando la escucha de eventos de pago para obtener informes de ingresos a nivel de impresión.

Requisitos:

Habilite el seguimiento de eventos de pago en su cuenta de AdMob (consulte Asistencia de AdMob).
Implemente Google Mobile Ads SDK para Android (consulte la Guía de introducción).

Informes de ingresos por plataforma: AdMob informa de los ingresos de forma diferente según la plataforma. Android devuelve los ingresos en micros (por ejemplo, 0,005 $ = 5.000). Divida adValue.valueMicros entre 1.000.000 para convertirlo a unidades monetarias estándar antes de enviarlo a Singular.

Implementación

Establezca un receptor de eventos de pago al cargar anuncios para capturar los datos de ingresos y enviarlos a Singular.

import com.singular.sdk.Singular
import com.singular.sdk.SingularAdData
import com.google.android.gms.ads.AdRequest
import com.google.android.gms.ads.rewarded.RewardedAd
import com.google.android.gms.ads.rewarded.RewardedAdLoadCallback

private const val AD_UNIT_ID = "YOUR_AD_UNIT_ID"

class AdManager(private val context: Context) {
    private var rewardedAd: RewardedAd? = null

    fun loadRewardedAd() {
        val adRequest = AdRequest.Builder().build()
        
        RewardedAd.load(context, AD_UNIT_ID, adRequest, 
            object : RewardedAdLoadCallback() {
                override fun onAdLoaded(ad: RewardedAd) {
                    rewardedAd = ad
                    
                    // Set full screen content callback
                    rewardedAd?.fullScreenContentCallback = 
                        object : FullScreenContentCallback() {
                            override fun onAdShowedFullScreenContent() {
                                Log.d("AdManager", "Rewarded ad displayed")
                            }
                            
                            override fun onAdDismissedFullScreenContent() {
                                Log.d("AdManager", "Rewarded ad dismissed")
                            }
                        }
                    
                    // Set paid event listener for revenue tracking
                    rewardedAd?.setOnPaidEventListener { adValue ->
                        // Convert revenue from micros to standard units
                        val revenue = adValue.valueMicros / 1_000_000.0
                        val currency = adValue.currencyCode
                        
                        // Validate revenue data before sending
                        if (revenue > 0 && !currency.isNullOrEmpty()) {
                            val data = SingularAdData(
                                "AdMob",
                                currency,
                                revenue
                            )
                            
                            Singular.adRevenue(data)
                            Log.d("AdManager", "Ad revenue sent: $revenue $currency")
                        } else {
                            Log.w("AdManager", "Invalid revenue: $revenue $currency")
                        }
                    }
                }
                
                override fun onAdFailedToLoad(error: LoadAdError) {
                    Log.e("AdManager", "Ad failed to load: ${error.message}")
                }
            })
    }
}

import com.singular.sdk.Singular;
import com.singular.sdk.SingularAdData;
import com.google.android.gms.ads.AdRequest;
import com.google.android.gms.ads.rewarded.RewardedAd;
import com.google.android.gms.ads.rewarded.RewardedAdLoadCallback;

private static final String AD_UNIT_ID = "YOUR_AD_UNIT_ID";

public class AdManager {
    private RewardedAd rewardedAd;
    private Context context;
    
    public AdManager(Context context) {
        this.context = context;
    }
    
    public void loadRewardedAd() {
        AdRequest adRequest = new AdRequest.Builder().build();
        
        RewardedAd.load(context, AD_UNIT_ID, adRequest, 
            new RewardedAdLoadCallback() {
                @Override
                public void onAdLoaded(RewardedAd ad) {
                    rewardedAd = ad;
                    
                    // Set full screen content callback
                    rewardedAd.setFullScreenContentCallback(
                        new FullScreenContentCallback() {
                            @Override
                            public void onAdShowedFullScreenContent() {
                                Log.d("AdManager", "Rewarded ad displayed");
                            }
                            
                            @Override
                            public void onAdDismissedFullScreenContent() {
                                Log.d("AdManager", "Rewarded ad dismissed");
                            }
                        });
                    
                    // Set paid event listener for revenue tracking
                    rewardedAd.setOnPaidEventListener(new OnPaidEventListener() {
                        @Override
                        public void onPaidEvent(AdValue adValue) {
                            // Convert revenue from micros to standard units
                            double revenue = adValue.getValueMicros() / 1_000_000.0;
                            String currency = adValue.getCurrencyCode();
                            
                            // Validate revenue data before sending
                            if (revenue > 0 && currency != null && !currency.isEmpty()) {
                                SingularAdData data = new SingularAdData(
                                    "AdMob",
                                    currency,
                                    revenue
                                );
                                
                                Singular.adRevenue(data);
                                Log.d("AdManager", "Ad revenue sent: " + revenue + " " + currency);
                            } else {
                                Log.w("AdManager", "Invalid revenue: " + revenue + " " + currency);
                            }
                        }
                    });
                }
                
                @Override
                public void onAdFailedToLoad(LoadAdError error) {
                    Log.e("AdManager", "Ad failed to load: " + error.getMessage());
                }
            });
    }
}

Integración con AppLovin MAX

Comparta los ingresos publicitarios a nivel de impresión utilizando la API de ingresos de usuario a nivel de impresión de AppLovin.

Requisitos:

Implemente el SDK de AppLovin MAX (consulte la guía de la API de ingresos a nivel de impresiones).
Suscríbase al tema max_revenue_events a través de AppLovin Communicator

Implementación

Gestione los mensajes de ingresos a través de la devolución de llamada de AppLovin Communicator.

import com.singular.sdk.Singular
import com.singular.sdk.SingularAdData
import com.applovin.communicator.AppLovinCommunicatorMessage

override fun onMessageReceived(message: AppLovinCommunicatorMessage) {
    // Check for revenue events topic
    if (message.topic == "max_revenue_events") {
        val adData: Bundle? = message.messageData
        
        // Extract and validate revenue value
        val revenueValue = adData?.getDouble("revenue", 0.0) ?: 0.0
        
        if (revenueValue > 0) {
            val data = SingularAdData(
                "AppLovin",
                "USD",  // AppLovin typically reports in USD
                revenueValue
            )
            
            Singular.adRevenue(data)
            Log.d("AppLovin", "Ad revenue sent: $revenueValue USD")
        } else {
            Log.w("AppLovin", "Invalid revenue value: $revenueValue")
        }
    }
}

import com.singular.sdk.Singular;
import com.singular.sdk.SingularAdData;
import com.applovin.communicator.AppLovinCommunicatorMessage;

@Override
public void onMessageReceived(AppLovinCommunicatorMessage message) {
    // Check for revenue events topic
    if ("max_revenue_events".equals(message.getTopic())) {
        Bundle adData = message.getMessageData();
        
        // Extract and validate revenue value
        double revenueValue = (adData != null) ? 
            adData.getDouble("revenue", 0.0) : 0.0;
        
        if (revenueValue > 0) {
            SingularAdData data = new SingularAdData(
                "AppLovin",
                "USD",  // AppLovin typically reports in USD
                revenueValue
            );
            
            Singular.adRevenue(data);
            Log.d("AppLovin", "Ad revenue sent: " + revenueValue + " USD");
        } else {
            Log.w("AppLovin", "Invalid revenue value: " + revenueValue);
        }
    }
}

Integración de Unity LevelPlay (IronSource)

Realice un seguimiento de los ingresos a nivel de impresión desde IronSource y redes mediadas utilizando el SDK de IronSource.

Requisitos:

Implementar ironSource SDK (consulte la Guía de introducción)
Habilite la bandera ARM SDK Postbacks en su panel IronSource
Configure la escucha de datos de impresión para recibir devoluciones de llamada de ingresos

Más información: Consulte la documentación sobre ingresos publicitarios deIronSource para obtener información detallada sobre la configuración.

Implementación

Implemente la devolución de llamada de éxito de datos de impresión para capturar y enviar ingresos.

import com.singular.sdk.Singular
import com.singular.sdk.SingularAdData
import com.ironsource.mediationsdk.impressionData.ImpressionData

fun onImpressionDataSuccess(impressionData: ImpressionData?) {
    // Validate impression data
    if (impressionData == null) {
        Log.d("IronSource", "No impression data available")
        return
    }
    
    // Extract and validate revenue
    val revenue = impressionData.revenue?.toDouble() ?: 0.0
    if (revenue <= 0) {
        Log.w("IronSource", "Invalid revenue: $revenue")
        return
    }
    
    // Create and send ad revenue data
    val data = SingularAdData(
        "IronSource",
        "USD",  // IronSource typically reports in USD
        revenue
    )
    
    Singular.adRevenue(data)
    Log.d("IronSource", "Ad revenue sent: $revenue USD")
}

import com.singular.sdk.Singular;
import com.singular.sdk.SingularAdData;
import com.ironsource.mediationsdk.impressionData.ImpressionData;

public void onImpressionDataSuccess(ImpressionData impressionData) {
    // Validate impression data
    if (impressionData == null) {
        Log.d("IronSource", "No impression data available");
        return;
    }
    
    // Extract and validate revenue
    double revenue = (impressionData.getRevenue() != null) ?
        impressionData.getRevenue().doubleValue() : 0.0;
        
    if (revenue <= 0) {
        Log.w("IronSource", "Invalid revenue: " + revenue);
        return;
    }
    
    // Create and send ad revenue data
    SingularAdData data = new SingularAdData(
        "IronSource",
        "USD",  // IronSource typically reports in USD
        revenue
    );
    
    Singular.adRevenue(data);
    Log.d("IronSource", "Ad revenue sent: " + revenue + " USD");
}

Integración con TradPlus

Capture los ingresos publicitarios de la mediación TradPlus utilizando la escucha de impresiones global.

Requisitos:

Configurar la escucha global de impresiones a través de TradPlusSdk.setGlobalImpressionListener()
Manejar onImpressionSuccess callback para recibir datos de ingresos
Convertir eCPM de mili-unidades a moneda estándar (dividir por 1000)

Implementación

Registre un receptor de impresiones global para realizar un seguimiento de todas las impresiones de anuncios y los ingresos.

import com.singular.sdk.Singular
import com.singular.sdk.SingularAdData
import com.tradplus.ads.mgr.GlobalImpressionManager
import com.tradplus.ads.base.bean.TPAdInfo

// Set global impression listener
TradPlusSdk.setGlobalImpressionListener(
    object : GlobalImpressionManager.GlobalImpressionListener {
        override fun onImpressionSuccess(tpAdInfo: TPAdInfo?) {
            // Validate ad info
            if (tpAdInfo == null) {
                Log.w("TradPlus", "AdInfo is null")
                return
            }
            
            // Convert eCPM from milli-units to dollars
            val revenue = tpAdInfo.ecpm.toDouble() / 1000.0
            
            // Validate revenue
            if (revenue <= 0) {
                Log.w("TradPlus", "Invalid revenue: $revenue")
                return
            }
            
            // Create and send ad revenue data
            val data = SingularAdData(
                "TradPlus",
                "USD",
                revenue
            )
            
            Singular.adRevenue(data)
            Log.d("TradPlus", "Ad revenue sent: $revenue USD")
        }
    }
)

import com.singular.sdk.Singular;
import com.singular.sdk.SingularAdData;
import com.tradplus.ads.mgr.GlobalImpressionManager;
import com.tradplus.ads.base.bean.TPAdInfo;

// Set global impression listener
TradPlusSdk.setGlobalImpressionListener(
    new GlobalImpressionManager.GlobalImpressionListener() {
        @Override
        public void onImpressionSuccess(TPAdInfo tpAdInfo) {
            // Validate ad info
            if (tpAdInfo == null) {
                Log.w("TradPlus", "AdInfo is null");
                return;
            }
            
            // Validate eCPM is not null
            if (tpAdInfo.getEcpm() == null) {
                Log.w("TradPlus", "eCPM is null");
                return;
            }
            
            // Convert eCPM from milli-units to dollars
            double revenue = tpAdInfo.getEcpm().doubleValue() / 1000.0;
            
            // Validate revenue
            if (revenue <= 0) {
                Log.w("TradPlus", "Invalid revenue: " + revenue);
                return;
            }
            
            // Create and send ad revenue data
            SingularAdData data = new SingularAdData(
                "TradPlus",
                "USD",
                revenue
            );
            
            Singular.adRevenue(data);
            Log.d("TradPlus", "Ad revenue sent: " + revenue + " USD");
        }
    }
);

Integración genérica (otras plataformas)

Integre cualquier plataforma de mediación utilizando la interfaz genérica SingularAdData.

Requisitos:

Acceso a los datos de ingresos a nivel de impresión de su plataforma de mediación
Importe de los ingresos en unidades monetarias estándar (no micros)
Código de moneda ISO 4217 (por ejemplo, USD, EUR, INR)

Precisión de los datos: Valide los datos de ingresos y divisas antes de enviarlos a Singular. Los datos incorrectos no pueden corregirse después del envío.

Implementación

Cree un objeto SingularAdData con el nombre de la plataforma, la divisa y los ingresos y, a continuación, llame a Singular.adRevenue().

import com.singular.sdk.Singular
import com.singular.sdk.SingularAdData

fun reportAdRevenue(adPlatform: String, currency: String, revenue: Double) {
    // Validate revenue
    if (revenue <= 0) {
        Log.w("AdRevenue", "Invalid revenue: $revenue")
        return
    }
    
    // Validate currency
    if (currency.isEmpty()) {
        Log.w("AdRevenue", "Invalid currency: $currency")
        return
    }
    
    // Create ad revenue data object
    val data = SingularAdData(
        adPlatform,
        currency,
        revenue
    )
    
    // Send to Singular
    Singular.adRevenue(data)
    Log.d("AdRevenue", "Revenue sent: $revenue $currency from $adPlatform")
}

// Example usage
reportAdRevenue("MyMediationPlatform", "USD", 0.05)

import com.singular.sdk.Singular;
import com.singular.sdk.SingularAdData;

public void reportAdRevenue(String adPlatform, String currency, double revenue) {
    // Validate revenue
    if (revenue <= 0) {
        Log.w("AdRevenue", "Invalid revenue: " + revenue);
        return;
    }
    
    // Validate currency
    if (currency == null || currency.isEmpty()) {
        Log.w("AdRevenue", "Invalid currency: " + currency);
        return;
    }
    
    // Create ad revenue data object
    SingularAdData data = new SingularAdData(
        adPlatform,
        currency,
        revenue
    );
    
    // Send to Singular
    Singular.adRevenue(data);
    Log.d("AdRevenue", "Revenue sent: " + revenue + " " + currency + 
        " from " + adPlatform);
}

// Example usage
reportAdRevenue("MyMediationPlatform", "USD", 0.05);

Pruebas y validación

Verificación de los informes de ingresos

Pruebe su implementación de ingresos publicitarios para asegurarse de que los datos fluyen correctamente a Singular.

Compruebe los registros: Compruebe que los registros de devolución de llamada de ingresos aparecen con los valores y la moneda correctos.
Pruebe los anuncios: Cargue y muestre anuncios de prueba para activar eventos de ingresos
Verificación del panel de control: Confirme que los ingresos aparecen en el panel de Singular en un plazo de 24 horas
Precisión de datos: Valide que las cantidades de ingresos coincidan con los informes de su plataforma de mediación

Resolución de problemas: Si los ingresos no aparecen en Singular, compruebe que

La atribución de ingresos publicitarios está activada en su cuenta de Singular.
Los valores de ingresos son superiores a 0
Los códigos de moneda son códigos ISO 4217 válidos
El nombre de la plataforma coincide con el formato esperado de Singular

SDK de Android - Seguimiento de los ingresos publicitarios

Atribución de ingresos publicitarios

Visión general

Qué es la atribución de ingresos publicitarios

Requisitos de implementación

Directrices críticas

Pasos de configuración

Integraciones de plataformas

Integración con AdMob

Implementación

Integración con AppLovin MAX

Implementación

Integración de Unity LevelPlay (IronSource)

Implementación

Integración con TradPlus

Implementación

Integración genérica (otras plataformas)

Implementación

Pruebas y validación

Verificación de los informes de ingresos