C’est un Poste d’invité – le premier depuis longtemps ! L’avant-propos et le résumé sont écrits par moi, Simo, et le reste est par mon estimé auteur invité.
Quelle chance j’ai eu d’avoir été contacté par Arben Kqiku, Digital Marketing & Data Manager de comtogether. Arben est l’un de nos nombreux étudiants Simmer, et il a parcouru le cours Interroger les données GA4 dans Google BigQuery, en apprenant beaucoup en cours de route.
Il voulait partager avec moi cette merveilleuse étude de cas qu’il a écrite en utilisant les leçons apprises pendant ce cours et sa connaissance préalable des outils et des langages comme R, Google Sheets et Google Data Studio.
Dans cet article, Arben aborde la question séculaire de savoir comment mesurer un l’efficacité du blog. Les données sont basées sur un ensemble de données BigQuery généré à partir de ce blog, qui est disponible pour tous ceux qui suivent le cours BigQuery à Simmer.
Une analyse web du blog de Simo Ahava
Récemment, j’ai terminé le cours Query GA4 Data in Google BigQuery, produit par Simo Ahava et enseigné par Johan van de Werken. Comme son nom l’indique, vous apprendrez à interroger les données de Google Analytics 4 à l’aide de Google BigQuery, dans ce cas spécifiquement les données de blog GA4 de Simo Ahava.
Je voulais tester mes connaissances nouvellement acquises et c’est pourquoi j’ai écrit cet article.
Comment mesurer l’efficacité d’un blog ?
Un blog est composé d’articles, il faut donc logiquement comparer ces articles pour comprendre lesquels sont les plus performants. Cependant, quels KPI devons-nous utiliser ?
Nous pourrions utiliser pages vues – plus un article génère de pages vues, mieux c’est. Cela a certainement du sens puisque les pages vues peuvent être interprétées comme un indicateur d’intérêt. Cependant, cette métrique présente certaines limites. Par exemple, les gens pourraient visiter un article et le quitter tout de suite sans le lire. Nous avons donc besoin d’une métrique qui indique si quelqu’un a lu un article ou non.
Nous pourrions utiliser Google Analytics 4 faire défiler événement à cet effet. GA4 enregistre un événement de défilement chaque fois qu’un utilisateur fait défiler 90% de la longueur totale d’une page. Vous pouvez demander à GA4 de collecter automatiquement cet événement et d’autres à partir de l’interface GA4.
Cependant, cette métrique a aussi ses limites. À savoir, la longueur entre les articles varie considérablement. Une page avec seulement 300 mots générera plus d’événements de défilement qu’une page avec 8 000 mots, simplement parce qu’il est plus facile d’atteindre la fin de celle-ci. Par conséquent, nous devons trouver un moyen d’intégrer la longueur d’un article dans l’équation.
Une formule pour mesurer l’attractivité d’un article
Tout d’abord, nous pourrions utiliser faire défiler les événements et pages vues pour calculer le taux de conversion du défilement en utilisant la formule suivante :
parchemins / pages vues
Cependant, nous pourrions avoir 2 pages avec le même taux de conversion de défilement, une page avec 10 vues et l’autre avec 1 000 vues. Évidemment, une page avec 1 000 vues a plus de valeur, nous devons donc affiner notre approche.
Comme mentionné précédemment, un parchemin est plus précieux sur une page de 8 000 mots que sur une page de 300 mots. Ainsi, on pourrait utiliser une formule qui pondère le nombre de scrolls par le nombre de mots présents dans un article :
parchemins * nombre_de_mots
De cette façon, nous donnons plus de poids aux articles plus longs.
Maintenant que la partie abstraite de l’article est terminée, passons à la partie juteuse, le code.
Score de performance de chaque article avec défilements et nombre de mots
Dans BigQuery, il est assez facile d’extraire des défilements par page.
select (select value.string_value from unnest(event_params) where key = 'page_location') as page_location, countif(event_name = 'scroll') as scrolls from `dataset.table.events_*` where _table_suffix between '20220601' and '20220831' group by page_location order by page_views descRegardons de plus près.
Tout d’abord, avec le code suivant, nous devons extraire le page_location paramètre d’événement. Pour ce faire, nous devons d’abord démêler les paramètres de l’événement, puis sélectionnez le page_location paramètre.
(select value.string_value from unnest(event_params) where key = 'page_location') as page_locationLes événements de défilement sont plus faciles à extraire : nous devons simplement dire à BigQuery de compter un événement chaque fois qu’il rencontre un événement de défilement lors de l’analyse de la table source.
countif(event_name = 'scroll') as scrollsEnfin, nous devons par groupe page_locationcar nous souhaitons utiliser les scrolls par page dans notre formule.
group by page_locationExtraction du nombre de mots
Pour extraire le nombre de mots par page, des outils supplémentaires sont nécessaires. Pour cela, j’ai utilisé R et Google Sheets.
La première chose que j’ai faite a été d’extraire les pages qui avaient au moins 100 pages vues entre le 1er juin et le 31 août, et j’ai collé les résultats dans cette feuille Google.
Ensuite, j’ai utilisé R pour calculer le nombre de mots de chaque page.
Cependant, j’ai rencontré un obstacle lors de la récupération des pages HTML. A savoir, il y avait un parcelle d’informations qui ne correspondaient pas à de vrais mots, tels que des extraits de code JavaScript et le style CSS. C’est pourquoi j’ai comparé chaque mot à un dictionnaire anglais et n’ai compté que vrais mots anglais.
Voici les étapes concrètes que j’ai prises en R :
- Charger les packages
- Récupérer toutes les URL de page de la feuille de calcul Google liée ci-dessus
- Récupérer un dictionnaire anglais depuis GitHub
- Pour chaque page :
4.1. Récupérer tous les mots
4.2. Nettoyer les mots
4.3. Rejoignez le dictionnaire anglais
4.4. Voir s’il y a une correspondance dans le dictionnaire. S’il y en a, comptez-le comme 1 (TRUE)
4.5. Additionne tous les mots qui ont une correspondance dans le dictionnaire - Afficher le résultat dans la même feuille Google
Voici à quoi ressemble la sortie.
Et voici le code R que j’ai utilisé.
# Packages library(tidyverse) library(googlesheets4) library(rvest) # Retrieve data from Google sheet sheet_URL = 'https://docs.google.com/spreadsheets/d/1tkOnw41zj7lQLonV-bEjJFszY5jSlMylmn9ntQO2qcA/edit#gid=0' sheet_id = gs4_get(sheet_URL) page_data = range_read(sheet_id) # Retrieve English dictionary dict = read.table(file = url("https://github.com/dwyl/english-words/raw/master/words_alpha.txt"), col.names = "words") %>% as_tibble() %>% mutate(condition = TRUE) # Read data from web pages and count words per page words_per_page = page_data %>% mutate(words = map(Page, ~return_words(web_page = .x))) %>% mutate(words = words %>% unlist()) # Output data to Google sheets sheet_write(words_per_page, sheet = 'output', ss = sheet_id) # Functions return_words = function(web_page){ words = web_page %>% read_html() %>% html_text() %>% # clean words for table tolower() %>% str_remove_all(pattern = '"') %>% str_remove_all(pattern = ",|:|\\.|\\\n") %>% strsplit(' ') %>% as_tibble('words') %>% set_names("words") %>% # join with English dictionary left_join(dict) %>% # keep only words from the english dictionary filter(condition == TRUE) %>% pull(condition) %>% sum() return(words) }Ensuite, dans Google Sheets, j’ai créé un case...when pour chaque page afin de créer une colonne pour le nombre de mots dans BigQuery.
Plus tard, j’ai copié tous ces case...when instructions et les a collées dans BigQuery. Pour éviter d’afficher une requête avec 358 case...when déclarations, je n’en afficherai qu’une poignée ici.
with prep as ( select (select value.string_value from unnest(event_params) where key = 'page_location') as page_location, countif(event_name = 'scroll') as scrolls from `simoahava-com.analytics_206575074.events_*` where _table_suffix between '20220601' and '20220831' group by page_location order by page_views desc), prep_words as ( select *, case when page_location = 'https://www.simoahava.com/analytics/google-analytics-4-ecommerce-guide-google-tag-manager/' then 5865 when page_location = 'https://www.simoahava.com/' then 521 when page_location = 'https://www.simoahava.com/analytics/one-tag-rule-them-all-introducing-google-tag/' then 1365 else null end as words_per_article from prep) select *, scrolls * words_per_article as performance_score from prep_words order by performance_score descChargez tout dans Google Data Studio
Avec Google Data Studio, j’ai créé ce graphique à barres horizontales qui affiche le score de performance par page.
On voit bien que l’article Google Analytics 4 : Ecommerce Guide For Google Tag Manager domine les résultats.
Note de performance par page et source/support
En plus de savoir quels articles ont le meilleur score de performance, il serait intéressant de voir comment ils se comparent lorsqu’ils sont segmentés par source / support. Il se peut que certaines combinaisons source/support puissent amener des utilisateurs plus intéressés.
with prep as ( select concat(traffic_source.source, " / ", traffic_source.medium) as source_medium, (select value.string_value from unnest(event_params) where key = 'page_location') as page_location, countif(event_name = 'scroll') as scrolls from `simoahava-com.analytics_206575074.events_*` where _table_suffix between '20220601' and '20220831' group by source_medium, page_location order by scrolls desc), prep_words as ( select *, case when page_location = 'https://www.simoahava.com/analytics/google-analytics-4-ecommerce-guide-google-tag-manager/' then 5865 when page_location = 'https://www.simoahava.com/' then 521 when page_location = 'https://www.simoahava.com/analytics/one-tag-rule-them-all-introducing-google-tag/' then 1365 else null end as words_per_article from prep) select source_medium, page_location, sum(page_views) as page_views, sum(scrolls) as scrolls, sum(words_per_article) as words_per_article, sum(scrolls * sum(words_per_article) as performance_score from prep_words group by source_medium, page_location having words_per_article is not null and scrolls > 100 order by page_views descRemarque de Simo: cette requête utilise le
traffic_source.*dimensions pour source / support. Ce sont en fait les première acquisition les détails de la campagne plutôt que les métadonnées de la campagne à l’échelle de la session dont cette requête bénéficierait davantage. Malheureusement, au moment de la rédaction de cet article, les données de portée de session comme celle-ci ne sont pas disponibles dans l’exportation BigQuery, donc en utilisanttraffic_source.*est un proxy assez décent.
Lorsque vous divisez les données entre deux dimensions, il est parfois utile de les visualiser avec une carte thermique.
Dans ce cas, nous pouvons voir que le source / support avec le score de performance le plus élevé est google / organic.
Je n’ai sélectionné que des combinaisons avec au moins 100 parchemins. C’est pourquoi le côté droit de la carte thermique est pratiquement vide.
Cependant, il est intéressant de noter que le quatrième article de la liste, One Tag To Rule Them All: Introducing The New Google Tag, a également un score de performance pour d’autres sources.
Cela nous indique que l’article en question a une pénétration plus large en termes de canaux d’acquisition.
Attribuer un score de performance à chaque utilisateur
Pour associer un score de performance à chaque utilisateur, nous utiliserons le champ GA4 user_pseudo_idqui stocke le identifiant client que GA4 attribue à chaque instance de navigateur. Bien qu’il ne reflète pas nécessairement le nombre réel de personnes qui visitent le site, c’est encore une fois un proxy assez décent pour nous obtenir des résultats utiles.
La première chose à faire est de créer la requête qui aligne le user_pseudo_id ensemble avec page_locationle nombre d’événements de défilement et le nombre de mots pour chaque page.
with prep as ( select user_pseudo_id, (select value.int_value from unnest(event_params) where key = 'ga_session_id') as session_id, (select value.string_value from unnest(event_params) where key = 'page_location') as page_location, countif(event_name = 'scroll') as scrolls, from `simoahava-com.analytics_206575074.events_*` where _table_suffix between '20220601' and '20220831' group by user_pseudo_id, session_id, page_location order by scrolls desc) select user_pseudo_id, session_id, page_location, case when page_location = 'https://www.simoahava.com/analytics/google-analytics-4-ecommerce-guide-google-tag-manager/' then 5865 when page_location = 'https://www.simoahava.com/' then 521 when page_location = 'https://www.simoahava.com/analytics/one-tag-rule-them-all-introducing-google-tag/' then 1365 else null end as words_per_page, scrolls from prepVoici à quoi ressemblent les résultats de la requête.
Maintenant, je peux créer une requête pour analyser le tableau des résultats ci-dessus et obtenir le score de performance par utilisateur.
with prep as ( select user_pseudo_id, sum(words_per_page) as words_per_page, sum(scrolls) as scrolls from `dataset.result_table` group by user_pseudo_id having words_per_page is not null) select user_pseudo_id, scrolls, words_per_page, scrolls * words_per_page as performance_score from prep order by performance_score descVoici le résultat.
Au total, nous avons pu attribuer une note de performance à 164 306 utilisateurs. Nous pourrions utiliser ces informations pour créer des audiences de remarketing en important les données dans GA4. Alternativement, nous pourrions ajouter ces informations à notre CRM et les utiliser comme système de notation des prospects pour alimenter nos campagnes par e-mail.
Résumé (par Simo)
Merci Arben!
L’efficacité du contenu est brutalement difficile à mesurer. J’ai essayé, et essayé, et essayé de visiter ce sujet encore et encore dans l’histoire de ce blog, et je n’ai jamais vraiment compris quelle formule fonctionnerait le mieux.
Je ne dis pas qu’Arben a résolu le puzzle, mais il soulève un point important concernant l’exploration plus profonde que ce que nous offrent les mesures par défaut.
L’engagement est finalement quelque chose d’assez éphémère pour résister à l’idée d’être catalogué dans une formule universelle. J’ai toujours détesté que les plateformes d’analyse essaient d’insérer un sens dans les mesures cliniques en les nommant quelque chose comme « Taux d’engagement » ou « Taux de rebond ». Ce ne sont que des mesures. Qu’ils décrivent l’engagement est une discussion complètement différente.
J’espère que vous avez été inspiré par l’exploration par Arben des différents outils disponibles dans l’arsenal de l’analyste. Vous pouvez aller loin avec Google BigQuery, mais utiliser R et Google Sheets pour créer l’ensemble de données de base peut s’avérer extrêmement précieux à long terme.
Veuillez consulter le profil d’Arben sur LinkedIn, connectez-vous avec lui et partagez vos réflexions sur son travail avec lui !
