1. Introduction
Un peu de contexte pour commencer
Si vous êtes développeur d'applications iOS, vous avez certainement entendu parler des mises à jour de confidentialité d'iOS 14.5 et versions ultérieures. Pour mesurer les actions de conversion importantes après l'installation, Apple fournit l'API SKAdNetwork, qui vous permet de mesurer l'efficacité de vos campagnes publicitaires tout en respectant la confidentialité des utilisateurs. En fonction des besoins de votre entreprise, vous pouvez trouver la meilleure façon d'utiliser SKAdNetwork pour obtenir des insights pertinents sur vos campagnes. Dans cet atelier de programmation, nous allons examiner un exemple de méthodologie permettant d'exploiter vos données GA4F dans BigQuery pour regrouper les revenus après l'installation de l'application dans des buckets, que vous pourrez ensuite utiliser pour configurer votre partenaire d'attribution d'application. Bien que cet atelier de programmation utilise une approche basée sur les revenus, vous pouvez également utiliser des approches basées sur les événements ou les entonnoirs pour la mesure SKAN. Pour obtenir des instructions plus détaillées, consultez cet article du Centre d'aide. Il ne s'agit que d'un exemple, et non d'une recommandation officielle de Google. Vous pouvez concevoir votre propre schéma en fonction des besoins spécifiques de votre entreprise.
Points abordés
- Explorer les données GA4F dans BigQuery
- Trouver les données sur les revenus pour les utilisateurs ayant effectué une conversion dans un délai de 0 à 2 jours
- Regrouper les données sur les revenus dans des buckets
- Comprendre la répartition des utilisateurs dans chaque bucket
- Implémenter les buckets dans Appsflyer SKAN Conversion Studio
Conditions préalables
- SDK GA4F dans votre application iOS, et tous les événements de revenus intégrés (in_app_purchase ou revenus financés par la publicité)
- Exportation de Firebase vers BigQuery activée
- App Attribution Partner, qui enregistre également tous les événements de revenus
2. Accéder à BigQuery Export
Accéder à l'ensemble de données Google Cloud
Accédez à l'ensemble de données dans GA4F en accédant à Paramètres du projet > Intégrations > BigQuery. Vous devez d'abord activer le bouton bascule. Une fois activé, il faut environ 48 heures pour que l'ensemble de données soit disponible. Vous pouvez cliquer sur le lien ci-dessous pour accéder à BigQuery.
Exécuter des requêtes
Maintenant que vous êtes dans BigQuery, vous devriez voir les tables quotidiennes générées. Dans l'exemple de capture d'écran ci-dessous, nous voyons 64 tables quotidiennes. L'exportation est donc en cours depuis 64 jours. Si vous y accédez pour la première fois, vous ne verrez peut-être qu'un seul tableau quotidien pour les données de la veille. Le schéma de la table s'affiche sur la droite. Pour en savoir plus sur les champs, cliquez ici.
Pour commencer à écrire votre requête, vous pouvez cliquer sur Requête > Dans un nouvel onglet.
Vous pouvez ensuite essayer d'exécuter l'exemple de requête dans le nouvel onglet.
3. Analyser les données sur les revenus
Récupérer les données d'installation
Pour commencer à créer les buckets de revenus, nous devons d'abord examiner les données des utilisateurs qui ont installé l'application au cours des dernières 24 à 72 heures. SKAdNetwork 4.0 vous permet d'afficher les données de 0 à 2 jours, tandis que SKAdNetwork 3.5 autorise 24 heures par défaut. (Selon les fonctionnalités de votre partenaire d'attribution d'applications, vous pourrez peut-être modifier cette période d'activité pour qu'elle ne dépasse pas 72 heures.) Lorsque les utilisateurs installent l'application et l'ouvrent pour la première fois, l'événement first_open est déclenché par le SDK et enregistré dans BigQuery.
L'identifiant que vous pouvez utiliser pour BigQuery est user_pseudo_id (également appelé ID d'instance d'application). Vous pouvez donc utiliser la requête ci-dessous pour trouver ces utilisateurs.
SELECT
user_pseudo_id,
event_name,
event_date,
event_timestamp
FROM `project_name.dataset_name.events_2023*`
WHERE
event_name = 'first_open'
AND platform = 'IOS'
Quelques points à noter concernant cette requête
- Veuillez remplacer le nom de la table par celui de votre table exportée Analytics. Vous pouvez utiliser des caractères génériques pour interroger plusieurs tables quotidiennes. Par exemple, 2023* interrogera toutes les données de 2023.
- Si vous avez beaucoup d'utilisateurs, vous pouvez également n'interroger que les 30 derniers jours pour un traitement plus rapide.
- Nous filtrons sur la plate-forme "IOS". Si votre projet Firebase contient plusieurs applications iOS, vous pouvez également ajouter un filtre pour app_info.firebase_app_id afin d'obtenir les données de l'application spécifique.
Récupérer les données sur les revenus
Examinons maintenant une requête permettant de trouver les revenus générés par vos utilisateurs. Dans ce cas, nous supposons que vos événements de revenus sont in_app_purchase et ad_impression. Les revenus générés par les achats via l'application sont disponibles dans event_value_usd, tandis que pour ad_impression, les revenus sont disponibles dans le paramètre "value", dans les paramètres d'événement. Si vous ne connaissez pas les paramètres d'événement dans BigQuery, nous vous recommandons de consulter la définition ici. Vous pouvez également essayer cet exemple de requête dans notre documentation de référence officielle, qui explique également comment extraire la valeur de event_params.
SELECT
user_pseudo_id,
event_name,
EXTRACT(date FROM Parse_datetime('%Y%m%d', event_date)) AS event_date,
(
SELECT COALESCE(value.int_value, value.float_value, value.double_value, NULL)
FROM UNNEST(event_params)
WHERE
KEY = 'value'
AND event_name = 'ad_impression'
) AS ad_funded_revenue,
(
SELECT value.string_value
FROM UNNEST(event_params)
WHERE
KEY = 'currency'
AND event_name = 'ad_impression'
) AS ad_revenue_currency,
(
CASE
WHEN event_name = 'in_app_purchase' THEN event_value_in_usd
ELSE 0
END) AS iap_revenue_usd,
FROM `project_name.dataset_name.events_2023*`
WHERE
platform = 'IOS'
AND event_name IN (
'in_app_purchase',
'ad_impression')
Comprenons ce que fait la requête ici. Voici les éléments que vous remarquerez :
- Dans la clause WHERE, nous filtrons les événements de revenus, car ce sont les seuls qui nous intéressent. Comme la dernière fois, nous recherchons les données iOS.
- Dans la clause SELECT, nous récupérons la valeur et la devise de l'événement de revenus publicitaires (ad_impression), ainsi que event_value_in_usd lorsque l'événement est in_app_purchase.
- Si vous envoyez plusieurs devises, vous devez d'abord choisir une seule devise pour cette analyse. Pour cet exemple, nous supposerons que la devise des revenus financés par la publicité est également l'USD.
Le résultat ressemblera à ce qui suit (la colonne user_pseudo_id est masquée ici).
Combiner ces données
Jusqu'à présent, nous avons exécuté deux requêtes : l'une pour trouver les données des utilisateurs qui ont installé et ouvert l'application, et l'autre pour trouver les revenus générés par ces utilisateurs. Rappelons-nous les limites de SKAdNetwork dont nous avons parlé. La période d'attribution ne peut être disponible que dans les deux jours suivant l'installation. Nous devrons donc vérifier les codes temporels des événements d'installation et de revenus, et ne prendre en compte les informations que si elles se produisent dans ce délai. Essayons maintenant de combiner ces informations dans une requête qui fournit le revenu total pour chaque post deux jours après l'installation de l'application.
#creating the install table
WITH
install_table AS (
SELECT
user_pseudo_id,
event_name,
event_date,
event_timestamp
FROM `project_name.dataset_name.events_2023*`
WHERE
event_name = 'first_open'
AND platform = 'IOS'
),
#creating the revenue table
revenue_table AS (
SELECT
user_pseudo_id,
event_name,
event_timestamp,
EXTRACT(date FROM Parse_datetime('%Y%m%d', event_date)) AS event_date,
(
SELECT COALESCE(value.int_value, value.float_value, value.double_value, NULL)
FROM UNNEST(event_params)
WHERE
KEY = 'value'
AND event_name = 'ad_impression'
) AS ad_funded_revenue,
(
SELECT value.string_value
FROM UNNEST(event_params)
WHERE
KEY = 'currency'
AND event_name = 'ad_impression'
) AS ad_revenue_currency,
(
CASE
WHEN event_name = 'in_app_purchase' THEN event_value_in_usd
ELSE 0
END) AS iap_revenue_usd,
FROM `project_name.dataset_name.events_2023*`
WHERE
platform = 'IOS'
AND event_name IN (
'in_app_purchase',
'ad_impression')
)
SELECT
it.user_pseudo_id AS user_pseudo_id,
#combine ad revenue and IAP revenue, assuming both are in same currency
sum(ifnull(rt.iap_revenue_usd,0) + ifnull(rt.ad_funded_revenue,0)) AS total_revenue,
FROM install_table it
INNER JOIN revenue_table rt
ON it.user_pseudo_id = rt.user_pseudo_id
WHERE
rt.event_timestamp >= it.event_timestamp
AND rt.event_timestamp
<= it.event_timestamp + 86400000000 * 2 #added 86400 000 millisecond as 24 hours, taking for 2 days later
GROUP BY 1
La requête tente simplement de joindre les données d'installation et les données sur les revenus sur le champ "user_pseudo_id", puis nous devons nous assurer que le code temporel se trouve dans une période de deux jours. Si vous utilisez SKAdNetwork 3.5, la valeur par défaut est de 24 heures. Vous pouvez donc également modifier la condition pour n'inclure que les données d'un jour.
Regrouper les revenus dans des catégories
Après la requête précédente, vous devriez avoir l'user_pseudo_id et le revenu total.
Nous devons maintenant combiner ces valeurs dans des buckets que nous pouvons utiliser pour nos plages de valeurs de conversion. Pour ce faire, nous utiliserons la fonction approx_quantiles dans BigQuery, qui crée automatiquement ces plages pour vous. Pour les besoins de cet exemple, supposons que nous voulons créer cinq plages. Nous pouvons donc simplement utiliser SELECT approx_quantiles(total_revenue, 5) AS buckets.
Nous allons maintenant l'intégrer à notre requête globale.
#creating the install table
WITH
install_table AS (
SELECT
user_pseudo_id,
event_name,
event_date,
event_timestamp
FROM `project_name.dataset_name.events_2023*`
WHERE
event_name = 'first_open'
AND platform = 'IOS'
),
#creating the revenue table
revenue_table AS (
SELECT
user_pseudo_id,
event_name,
event_timestamp,
EXTRACT(date FROM Parse_datetime('%Y%m%d', event_date)) AS event_date,
(
SELECT COALESCE(value.int_value, value.float_value, value.double_value, NULL)
FROM UNNEST(event_params)
WHERE
KEY = 'value'
AND event_name = 'ad_impression'
) AS ad_funded_revenue,
(
SELECT value.string_value
FROM UNNEST(event_params)
WHERE
KEY = 'currency'
AND event_name = 'ad_impression'
) AS ad_revenue_currency,
(
CASE
WHEN event_name = 'in_app_purchase' THEN event_value_in_usd
ELSE 0
END) AS iap_revenue_usd,
FROM `project_name.dataset_name.events_2023*`
WHERE
platform = 'IOS'
AND event_name IN (
'in_app_purchase',
'ad_impression')
),
total_revenue_table AS (
SELECT
it.user_pseudo_id AS user_pseudo_id,
#combine ad revenue and IAP revenue, assuming both are in same currency
sum(ifnull(rt.iap_revenue_usd,0) + ifnull(rt.ad_funded_revenue,0)) AS total_revenue,
FROM install_table it
INNER JOIN revenue_table rt
ON it.user_pseudo_id = rt.user_pseudo_id
WHERE
rt.event_timestamp >= it.event_timestamp
AND rt.event_timestamp
<= it.event_timestamp + 86400000000 * 2 #added 86400 000 millisecond as 24 hours
GROUP BY 1
)
SELECT approx_quantiles(total_revenue, 5) AS buckets FROM total_revenue_table
Cette requête divise les revenus en cinq groupes et BigQuery tente de maintenir une distribution cohérente des centiles.
Analysez la répartition des utilisateurs avec ces groupes
Cette étape est facultative. Elle vous permet de comprendre la répartition de vos utilisateurs dans chaque bucket. Dans notre exemple, les plages de buckets renvoyées dans la requête précédente sont
- 0,1
- 0,5
- 2
- 2.5
- 5 [la dernière valeur ne doit pas être utilisée dans la configuration de la plage]
Pour les plages finales, nous ignorons le dernier bucket 5, car il s'agit généralement de la valeur maximale.Nous pouvons donc considérer que la dernière plage est de 2, 5. En effet, les fournisseurs d'attribution d'applications ont tendance à calculer le ROAS à l'aide de la moyenne de la plage. L'élément aberrant doit donc être exclu pour un calcul plus uniforme.
Nous allons maintenant essayer de déterminer le nombre d'utilisateurs pour chaque date dans toutes les plages, afin de comprendre le volume quotidien d'utilisateurs dans chaque bucket. Pour ce faire, nous pouvons utiliser cet exemple de requête, dans lequel vous pouvez remplacer les valeurs de bucket par vos données réelles. La requête ressemblerait à ceci :
#creating the install table
WITH
install_table AS (
SELECT
user_pseudo_id,
event_name,
event_date,
event_timestamp
FROM `project_name.dataset_name.events_2023*`
WHERE
event_name = 'first_open'
AND platform = 'IOS'
),
#creating the revenue table
revenue_table AS (
SELECT
user_pseudo_id,
event_name,
event_timestamp,
EXTRACT(date FROM Parse_datetime('%Y%m%d', event_date)) AS event_date,
(
SELECT COALESCE(value.int_value, value.float_value, value.double_value, NULL)
FROM UNNEST(event_params)
WHERE
KEY = 'value'
AND event_name = 'ad_impression'
) AS ad_funded_revenue,
(
SELECT value.string_value
FROM UNNEST(event_params)
WHERE
KEY = 'currency'
AND event_name = 'ad_impression'
) AS ad_revenue_currency,
(
CASE
WHEN event_name = 'in_app_purchase' THEN event_value_in_usd
ELSE 0
END) AS iap_revenue_usd,
FROM `project_name.dataset_name.events_2023*`
WHERE
platform = 'IOS'
AND event_name IN (
'in_app_purchase',
'ad_impression')
),
total_revenue_table AS (
SELECT
it.user_pseudo_id AS user_pseudo_id,
rt.event_date,
#combine ad revenue and IAP revenue, assuming both are in same currency
sum(ifnull(rt.iap_revenue_usd,0) + ifnull(rt.ad_funded_revenue,0)) AS total_revenue,
FROM install_table it
INNER JOIN revenue_table rt
ON it.user_pseudo_id = rt.user_pseudo_id
WHERE
rt.event_timestamp >= it.event_timestamp
AND rt.event_timestamp
<= it.event_timestamp + 86400000000 * 2 #added 86400 000 millisecond as 24 hours
GROUP BY 1, 2
)
SELECT
event_date,
sum(CASE WHEN total_revenue BETWEEN 0 AND 0.1 THEN 1 ELSE 0 END) AS Bucket1,
sum(CASE WHEN total_revenue BETWEEN 0.1 AND 0.5 THEN 1 ELSE 0 END) AS Bucket2,
sum(CASE WHEN total_revenue BETWEEN 0.5 AND 2 THEN 1 ELSE 0 END) AS Bucket3,
sum(CASE WHEN total_revenue BETWEEN 2 AND 2.5 THEN 1 ELSE 0 END) AS Bucket4,
sum(CASE WHEN total_revenue > 2.5 THEN 1 ELSE 0 END) AS Bucket5
FROM total_revenue_table
GROUP BY 1 ORDER BY 1 DESC
Il doit renvoyer les utilisateurs de chaque tranche de revenus pour chaque jour, comme ci-dessous. Si vous constatez des nombres très faibles dans un bucket ou une répartition généralement inégale, vous pouvez ajuster le nombre de buckets et relancer la requête.
Quelques mots sur SKAdNetwork 4.0
SKAdNetwork 4.0 propose plusieurs périodes de suivi des conversions : jusqu'à deux jours, de trois à sept jours et de huit à 35 jours. Dans l'approche ci-dessus, vous pouvez facilement modifier la fenêtre pour analyser les données de ces scénarios supplémentaires. Des valeurs approximatives FAIBLE, MOYENNE et ÉLEVÉE sont également disponibles. Encore une fois, si vous souhaitez utiliser cette approche, vous pouvez considérer qu'il y a trois buckets. Ainsi, en définissant le nombre de buckets sur trois, vous pouvez obtenir les seuils pour BAS, MOYEN et ÉLEVÉ.
4. Déploiement avec votre fournisseur d'attribution
Ces consignes peuvent changer en fonction de la plate-forme concernée. Pour obtenir les informations les plus récentes à ce sujet, veuillez contacter les représentants de la plate-forme. Pour cet exemple, nous allons voir comment déployer actuellement cette fonctionnalité sur AppsFlyer.
Dans la requête que nous avons exécutée précédemment, les plages finales que nous avons reçues en sortie étaient les suivantes :
- Plage 1 : de 0 à 0,1
- Plage 2 : de 0,1 à 0,5
- Plage 3 : de 0,5 à 2
- Plage 4 : de 2 à 2,5
N'oubliez pas que nous avons décidé d'ignorer la dernière tranche de revenus, car elle sera une valeur aberrante et faussera les calculs de moyenne pour votre fournisseur d'attribution d'applications.
AppsFlyer propose SKAN Conversion Studio, qui permet de saisir facilement ces informations directement dans l'UI. Vous pouvez utiliser directement la version 4.0 ou le mode "Personnalisé" si vous utilisez la version 3.5, puis ajouter la mesure "Revenu". Il vous suffit ensuite d'ajouter les plages de revenus que vous avez calculées lors de l'analyse précédente.
Bonnes pratiques et enseignements sur Google Ads
Nous aimerions vous faire quelques recommandations si vous diffusez des campagnes sur Google Ads et que vous mesurez leur impact à l'aide d'un schéma de valeur de conversion SKAdNetwork.
- Assurez-vous que la période de suivi des conversions que vous utilisez dans Google Ads correspond à la période d'activité que vous avez spécifiée sur votre plate-forme d'attribution d'applications. Pour SKAdNetwork 3.5, ce délai est généralement de un à trois jours. Vous pouvez donc l'ajuster en conséquence dans Google Ads en suivant les étapes décrites ici.
- Si vous utilisez Appsflyer, le compteur d'événements par défaut est actuellement défini sur 1, ce qui signifie qu'il ne tient pas compte des événements multiples par utilisateur. Si vous utilisez un modèle basé sur les événements pour la mesure SKAN et que vous le comparez à des campagnes au CPA cible dans Google Ads, vous pouvez le personnaliser en suivant ces instructions d'AppsFlyer.
5. Félicitations
Félicitations, vous avez correctement configuré votre schéma de valeurs de conversion SKAdNetwork. Une fois que vous aurez configuré le schéma, vous pourrez surveiller les données de votre rapport SKAdNetwork Google Ads pour vérifier les valeurs de conversion de vos campagnes Google Ads.
Ce que vous avez appris
- Explorer les données brutes détaillées de GA4F dans BigQuery
- Approche analytique pour calculer les groupes de revenus de votre entreprise
- Déployer le schéma avec AppsFlyer