Comment taguer facilement des événements web avec GTM et GA4 grâce à l’IA

Mesurer des événements sur un site web paraît facile.

Mais ensuite tu ouvres chacun de tes templates WordPress et tu commences à penser aux clics, boutons, modules, transactions, formulaires, menus, CTAs, cartes, bannières, sidebars…

Et tu remets ça à un autre jour.

Parce qu’une chose est de penser “je veux mesurer ce qui se passe sur mon site” et une autre, très différente, est de bien taguer un vrai site web.

Un site avec différents templates.

Avec des modules répétés dans plusieurs sections.

Avec des cartes et des onglets qui se ressemblent mais qui changent sur un détail.

Avec des boutons visuellement identiques mais qui remplissent des fonctions complètement différentes.

Et là, comme dans beaucoup d’autres domaines, l’IA peut beaucoup t’aider.

Non pas parce qu’elle va décider ta stratégie de mesure à ta place — ça reste ton affaire, même si elle peut aussi te proposer des pistes — mais parce qu’elle peut exécuter presque tout le travail: 

• Réviser les templates.
• Détecter les modules et composants similaires.
• Proposer une structure réutilisable.
• Définir une nomenclature si la tienne n’est pas claire.
• Préparer un conteneur GTM.
• Et même toucher au code de ton site pour, par exemple, ajouter des attributs “data-” qui facilitent la mesure. 

Je viens de faire tout ça sur mon site, donc je t’explique le processus en prenant mon cas réel comme exemple.

J’ai préparé la mesure des clics dans les modules éditoriaux de mon site (articles mis en avant, recommandés, nouveautés, etc. sur chaque page), mais le système sert pour n’importe quel événement.

Cela dit, on a ici deux voies : la manuelle et l’automatisée avec l’IA.

On va commencer par la plus simple pour que tu voies à quel point c’est rapide, puis après, si tu veux, tu regardes tout ce que tu t’es épargné en le laissant à l’IA.

Voie 1 : tutoriel pas à pas pour tracker les événements de ton site rapidement avec l’IA

On commence par la version rapide et courte.

Étape 1 : demande à l’IA de t’aider à concevoir la structure

Si tu as de l’expérience en analytics, tu connais déjà ça. Mais si tu n’en as pas ou si tu ne connais pas GA4, l’IA peut t’être très utile.

Pour cela, il te suffit d’aller dans ton outil préféré (ChatGPT, Claude ou Gemini) et de faire deux choses dans un prompt :

1. Ajoute-lui des captures d’écran complètes (de haut en bas) de chaque section du site (accueil, catégories, checkout, etc.)
2. Explique-lui ce que tu veux.

C’est-à-dire : 

<em>“Je veux mesurer les clics dans les modules principaux de mon site. Avant de toucher au code, aide-moi à définir une nomenclature d’événement et des paramètres pour qu’elle soit réutilisable dans GTM et GA4.</em>
Je ne veux pas un événement par module. Je veux un événement unique avec des paramètres.

Les templates que j’ai sont :

- home

- catégorie

- sous-catégorie

- tag

- post

Propose :

1. nom de l’événement

2. paramètres minimaux

3. valeurs autorisées

4. exemples réels de dataLayer

5. dimensions que je devrais créer dans GA4”

Cela oblige l’IA à penser en structure avant de penser au code.

Et c’est exactement ce qui t’intéresse, parce qu’elle te proposera un plan qui, généralement, aura pas mal de sens. Parce que si tu commences à taguer un site sans nomenclature, tu finiras avec une analytics Frankenstein.

Fais des allers-retours avec l’IA jusqu’à ce que la structure soit claire pour toi et que tu comprennes pourquoi faire comme ça.

Étape 2 : passe-lui ton conteneur GTM

Et laisse-la faire presque tout le travail :

1. Exporte le conteneur GTM du projet et balance-le à l’IA.
2. Demande-lui d’exécuter les changements pertinents sur la base de la stratégie définie au point précédent.
3. Une fois qu’elle l’a prêt, tu le télécharges.
4. Tu l’importes dans GTM. L’IA te dira si tu dois le fusionner avec celui qui est déjà en ligne ou le remplacer.

Ici il est possible qu’on ait terminé, ou pas, selon la manière dont l’IA pense — ou dont on lui a dit — d’exécuter le plan de taggage.

Étape 3 (optionnelle) : passe le code de tes templates à l’IA

Si, pour le taggage, il faut ajouter des attributs data (je t’explique en quoi ils consistent dans la partie du taggage manuel) tu peux passer à l’IA les vrais templates de ton site. Et c’est là que tu gagnes vraiment du temps.

Dans WordPress, il peut s’agir de fichiers du thème actif comme :

• front-page.php
• category.php
• tag.php
• single.php
• functions.php

Ou ceux qu’utilise ton thème.

Téléverse-les et donne-lui une instruction concrète :

<em>“Je te passe les templates actuels de mon site.</em>
Je veux que tu ajoutes des attributs data-* aux liens des modules principaux pour mesurer l’événement editorial_module_click.

Ne change pas le design.

Ne change pas les classes CSS.

Ne change pas la logique des queries.

Ne change pas les textes.

Ajoute seulement des attributs d’analytics.

Utilise ces paramètres :

- data-analytics-event

- data-page-type

- data-module-type

- data-module-area

Renvoie-moi les fichiers complets corrigés et vérifie les erreurs de syntaxe PHP.”

Attention à ça : ne laisse pas l’IA “améliorer” ton template.

L’IA a tendance à toucher plus que nécessaire si tu ne la limites pas. Dis-lui clairement qu’elle ajoute uniquement des attributs d’analytics. Rien de plus.

Une fois les fichiers téléchargés et envoyés sur le site, on passerait alors à tout tester avant de publier les changements et de créer les dimensions personnalisées nécessaires dans GA4. 

Ci-dessous, je t’explique tout, mais avant je veux que tu voies tout le travail manuel que nous nous sommes épargné en suivant ce processus.

Voie 2 : tutoriel pas à pas pour tracker manuellement les événements de ton site

On passe à la voie longue, pour que tu comprennes ce que l’IA a réellement fait.

Étape 1 : décide quel événement tu veux créer

D’abord : ne crée pas vingt événements si tu peux en créer un seul, réutilisable et bien pensé.

Dans mon cas, je voulais mesurer les clics dans les modules éditoriaux du site, j’ai donc créé un événement unique :

editorial_module_click

Mais le même processus sert pour d’autres événements :

• cta_click
• resource_download
• pricing_click
• affiliate_click
• lead_magnet_click
• video_module_click
• product_card_click
• internal_navigation_click

La clé est de se demander si l’événement peut être réutilisable maintenant ou à l’avenir. Par exemple, si tu veux mesurer des CTAs, ne crée pas ça :

• click_boton_home
• click_boton_sidebar
• click_boton_footer
• click_boton_categoria
• click_boton_post

Crée plutôt cta_click et différencie chaque clic avec des paramètres. C’est plus propre et plus scalable.

Étape 2 : définis les paramètres minimaux

Il n’est jamais nécessaire de tout mesurer, mais seulement ce qui compte. Ce que tu vas réellement exploiter et qui te permettra de prendre des décisions.

Dans mon cas, pour les clics dans les modules éditoriaux, j’ai utilisé ces paramètres :

• page_type
• module_type
• module_area
• link_url
• link_text

Traduit :

Paramètre	Ce qu’il indique
page_type	Type de page où se produit le clic (home, catégorie, sous-catégorie, tag ou article). Chacune a une structure différente.
module_type	Type de module cliqué : nouveautés, section de recommandations, section des derniers articles… Chaque template possède pas mal de sections.
module_area	Contenu, sidebar, footer…
link_url	URL du lien. Je l’ai ajoutée parce que j’avais déjà créé la variable ; sinon, je ne l’aurais pas fait, car je sais que je vais peu la consulter.
link_text	Et celle-ci encore moins

Exemple :

• page_type  = category
• module_type  = latest
• module_area  = main
• link_url = https://yagogonzalez.com/ocio/
• link_text = Comment télécharger de longues playlists YouTube...

Avec ça, je peux déjà comparer :

• Quelles pages et quels types de pages génèrent le plus de clics.
• Quelles zones de la page génèrent le plus de clics.
• Quels modules génèrent le plus de clics.

Plus que suffisant pour commencer.

Étape 3 : crée une nomenclature fermée

C’est important : ne laisse pas chaque événement recevoir un nom inventé à la volée. Définis des valeurs fermées.

Par exemple, pour page_type peuvent être :

• home
• category
• subcategory
• tag
• post
• page
• landing
• product
• checkout

Utilise uniquement ceux dont tu as besoin. Dans mon cas :

• home
• category
• subcategory
• tag
• post

Pour module_area:

• main
• sidebar
• bottom
• footer
• post_footer

Et pour module_type, définis une liste selon ton site.

Dans mon cas, cette liste était assez longue, car j’ai pas mal de modules différents. Certains étaient :

• home_hero
• home_hero_side
• featured
• latest
• sidebar_popular
• sidebar_more
• bottom_cta_newsletter
• home_section_tecnologia
• home_section_ocio
• home_section_negocio

Si ton site est un site de services, tu pourrais avoir :

• hero_cta
• services_grid
• case_studies
• testimonials
• pricing_table
• contact_cta
• lead_magnet

Ou, si c’est un ecommerce :

• product_card
• category_grid
• promo_banner
• recommended_products
• cart_cta
• checkout_step
• wishlist_button

La logique est la même, seul le contexte change, mais la méthode reste la même.

Étape 4 (optionnelle) : utilise des attributs data dans le HTML

Dans mon cas, cela a été une partie importante du système.

J’aurais pu essayer de faire en sorte que GTM récupère le module cliqué à partir d’une classe CSS bizarre ou du texte du bouton, mais sur des projets moyens c’est fragile : aujourd’hui ça marche, mais dans 3 mois tu changes le design et ça ne marche plus, parce que tu ne te souviens plus de ce qui dépendait de quoi.

La solution que j’ai adoptée consiste à ajouter des attributs data directement dans les liens ou les boutons que tu veux mesurer.

Exemple :

<a
href="https://tudominio.com/articulo/"

  data-analytics-event="editorial_module_click"

  data-page-type="home"

  data-module-type="home_hero"

  data-module-area="main"

>

  Título del artículo

</a>

Avec ça, le lien lui-même porte déjà l’information que tu veux envoyer. GTM n’a rien à deviner, il doit seulement lire les attributs.

Cela sert pour presque n’importe quel événement :

<em><a</em>
href="/contacto/"

  data-analytics-event="cta_click"

  data-page-type="landing"

  data-module-type="hero_cta"

  data-module-area="main"

>

  Demander un devis

</a>

Ou pour un ecommerce :

<em><a</em>
href="/producto/zapatilla-x/"

  data-analytics-event="product_card_click"

  data-page-type="category"

  data-module-type="product_grid"

  data-module-area="main"

>

  Basket X

</a>

Oui, tu ajoutes plus de code, mais c’est une solution simple, compréhensible et scalable.

Étape 5 : crée un listener dans GTM

Maintenant, tu as besoin que Google Tag Manager écoute les clics sur les liens avec ton attribut.

Crée une balise HTML personnalisée.

Par exemple :

<em><script></em>
(function() {

  document.addEventListener('click', function(event) {

    var link = event.target.closest('a[data-analytics-event]');

    if (!link) {

      return;

    }

    window.dataLayer = window.dataLayer || [];

    window.dataLayer.push({

      event: link.getAttribute('data-analytics-event') || '',

      page_type: link.getAttribute('data-page-type') || '',

      module_type: link.getAttribute('data-module-type') || '',

      module_area: link.getAttribute('data-module-area') || '',

      link_url: link.href || '',

      link_text: (link.innerText || link.textContent || '').trim()

    });

  });

})();

</script>

Ce listener fait quelque chose de très simple :

1. Détecte les clics.
2. Vérifie si le lien possède data-analytics-event.
3. Lit les attributs.
4. Fait un dataLayer.push().
5. GTM utilise cet événement pour envoyer les données à GA4.

Il n’y a pas de mystère, il suffit de l’écrire correctement. Et pour ça aussi, tu peux utiliser l’IA.

Étape 6 : crée les variables dans GTM

Dans GTM, crée des variables de couche de données pour lire les paramètres.

Par exemple :

Variable GTM	Variable de couche de données
DL – page_type	page_type
DL – module_type	module_type
DL – module_area	module_area
DL – link_url	link_url
DL – link_text	link_text

Elles sont toutes du type Variable de couche de données.

N’improvise pas les noms. Si, dans le listener, tu envoies module_type, dans GTM la variable doit lire module_type. Pas module-type. Pas moduleType. Pas tipo_modulo.

Mieux vaut identique. Exactement identique.

Étape 7 : crée le déclencheur

Crée un déclencheur d’événement personnalisé.

Si ton événement s’appelle :

editorial_module_click

Le déclencheur doit écouter :

editorial_module_click

Si ton événement s’appelle :

cta_click

Le déclencheur doit écouter :

cta_click

Cela paraît évident, mais beaucoup d’erreurs GTM sont simplement des noms qui ne correspondent pas.

Dans mon cas, le déclencheur était :

• CE – Editorial Module Click
• Type : événement personnalisé
• Nom de l’événement : editorial_module_click

Étape 8 : crée la balise GA4

Crée une balise d’événement GA4.

Nom de l’événement :

editorial_module_click

Ou l’événement que tu as décidé.

Ajoute les paramètres :

Paramètre GA4	Valeur GTM
page_type	{{DL – page_type}}
module_type	{{DL – module_type}}
module_area	{{DL – module_area}}
link_url	{{DL – link_url}}
link_text	{{DL – link_text}}

Et utilise comme déclencheur l’événement personnalisé que tu viens de créer.

Avec ça, chaque fois que quelqu’un clique sur un lien tagué, GTM enverra l’événement à GA4.

Tests et étapes suivantes

Peu importe la voie que tu as suivie, elles convergent ici. Une fois tout implémenté, ce que tu dois faire, c’est t’assurer que tout fonctionne comme il faut.

En plus, il faudra toucher un petit truc de plus dans GA4.

Étape 1 : teste avant de publier

Ne publie pas à l’aveugle :

1. Ouvre l’aperçu de GTM.
2. Clique sur plusieurs modules du site.
3. Vérifie que l’événement apparaît editorial_module_click (ou l’événement que tu as créé).
4. Ensuite, entre dans la balise GA4 et vérifie que les paramètres ont une valeur (page_type, module_type…)

Si tu vois des valeurs vides, vérifie :

• Que le HTML possède les attributs data.
• Que le listener se charge.
• Que l’attribut de l’événement a le bon nom.
• Que les variables GTM lisent le même nom que celui envoyé par le dataLayer.
• Que le déclencheur écoute le bon événement.

Ne continue pas tant que ça ne fonctionne pas. Ici l’aperçu de GTM est ton ami. Utilise-le.

Étape 2 : vérifie DebugView

Quand tu publies, vérifie la DebugView de GA4.

Tu devrais voir ton événement arriver, mais attention : DebugView prend parfois du temps, ne se rafraîchit pas bien ou te montre une autre session.

C’est pourquoi, si dans l’extension Tag Assistant tu vois le hit envoyé correctement, l’événement sort bien.

DebugView est utile, mais ne deviens pas fou si ça prend un peu de temps ou si ça n’apparaît pas.

Dans mon cas, dans Tag Assistant, je voyais l’événement envoyé comme hit à GA4, même si DebugView ne l’affichait pas dans la timeline.

Ça peut arriver.

Étape 3 : crée des dimensions personnalisées dans GA4

Pour terminer, dans GA4, va dans :

Administrer > Affichage des données > Définitions personnalisées

Et crée uniquement les dimensions que tu vas vraiment utiliser. C’est-à-dire les paramètres des événements que tu vas analyser.

Dans mon cas :

Nom	Portée	Paramètre
page_type	Événement	page_type
module_type	Événement	module_type
module_area	Événement	module_area

J’avais déjà enregistré link_url et link_text comme dimensions personnalisées de taggages précédents.

Étape 4 : (optionnel) documente la nomenclature

Si le projet est conséquent, il est indispensable de créer un tableau de taggage des événements semblable à celui-ci :

Événement	Paramètre	Valeurs possibles	À quoi ça sert
editorial_module_click	page_type	home, category, subcategory, tag	Type de template
editorial_module_click	module_type	featured, latest, sidebar_popular	Type de module
editorial_module_click	module_area	main, sidebar, bottom	Zone visuelle

Ainsi, quand dans deux mois tu devras ajouter un autre module, tu ne réinventeras rien ; tu suivras simplement le système sans devoir tout repenser.

Et voilà, on a terminé.

Si tu as suivi la voie manuelle, félicitations. Ça t’aura coûté un peu de temps.

Si tu as suivi celle de l’IA, tu te demandes probablement si tu as vraiment terminé. Et oui, la réponse est oui. Un peu surprenant, non ?

Erreurs typiques

Allez, récapitulons toutes celles mentionnées ici et que nous avons tous subies un jour.

Créer trop d’événements

Mauvais :

• home_button_click
• sidebar_button_click
• footer_button_click
• category_button_click

Mieux cta_click   avec des paramètres.

Dépendre de classes CSS

Mauvais :

Si l’utilisateur clique sur .boton-verde-grande…

Demain, tu changes le design et adieu la mesure.

Mieux vaut ajouter des attributs data : data-analytics-event="cta_click"

Ne pas tester dans GTM

Publier sans tester, c’est jouer à la roulette. Utilise toujours Aperçu.

Enregistrer trop de dimensions dans GA4

Ne transforme pas chaque paramètre en dimension personnalisée.

Commence uniquement par celles que tu vas utiliser pour analyser. Le reste peut attendre et, si tu vois que tu en as vraiment besoin, tu l’ajoutes ensuite.

Changer de noms au milieu du processus

Si tu utilises module_type utilise-le toujours de la même manière.

Ne change pas pour :

• module-type
• moduleType
• tipo_modulo

Ni au milieu du processus, ni à l’avenir. Ça paraît idiot, mais ça compliquera ton analytics quand tu compareras des périodes avec les deux événements..

Résumé rapide et conclusions

Récapitulons le processus manuel général, qui est celui-ci :

1. Définis ce que tu veux savoir.
2. Crée un événement réutilisable.
3. Définis peu de paramètres.
4. Ajoute des attributs data-* aux liens importants.
5. Utilise l’IA pour réviser et modifier les templates.
6. Crée un listener dans GTM.
7. Crée des variables de couche de données.
8. Crée un déclencheur d’événement personnalisé.
9. Crée une balise GA4.
10. Teste dans Tag Assistant.
11. Publie.
12. Enregistre dans GA4 uniquement les dimensions nécessaires.

Et, comme tu as pu le voir, c’est très facilement réductible si tu demandes de l’aide à ton ami ChatGPT.

Ce qui prendrait des heures à faire manuellement, je l’ai fait en un peu plus de 30 minutes pour que ce soit opérationnel.  

Ça ressemble à de la magie quand tu l’essaies. Vraiment.

Et je te laisse avec deux recommandations pour finir :

Mesurer des événements, ce n’est pas avoir beaucoup de données ou toutes les données, mais obtenir de l’information pour décider. Et pour cela, il ne t’en faut que quelques-unes.

L’IA ne remplace pas ton critère de mesure — celui qui te dit quelles données mesurer — mais elle te épargne une énorme quantité de travail mécanique et, surtout, t’aide à maintenir la cohérence. 

Et ça, sur les grands projets, c’est de l’or pur. Ne le gâche pas.