GA4 e-commerce 2026 : implémenter le suivi des achats (recommended events + dataLayer)

Universal Analytics est définitivement éteint. GA4 est aujourd'hui la seule option pour mesurer les performances e-commerce dans Google Analytics. Pourtant, la migration du modèle de données n'est pas triviale : là où UA reposait sur des hits pageview et transaction, GA4 repose entièrement sur des événements structurés avec un objet items standardisé. Cet article détaille l'implémentation technique complète du suivi e-commerce GA4 : liste des recommended events officiels, structure de l'objet items, exemples de dataLayer push prêts à l'emploi, implémentation via GTM ou gtag.js, pièges courants et procédure de validation.

Sources : documentation GA4 Measure ecommerce, GA4 recommended events reference, aide Google Analytics Set up ecommerce, GTM dataLayer documentation.

1. GA4 vs Universal Analytics : un modèle de données différent

Dans Universal Analytics, le suivi e-commerce reposait sur deux mécanismes distincts : l'e-commerce standard et l'e-commerce amélioré (Enhanced Ecommerce). Les données transitaient via des hits de type pageview ou event augmentés de propriétés spécifiques.

GA4 rompt avec ce modèle. Tout est un événement. Le suivi e-commerce repose sur des recommended events : des noms d'événements standardisés que Google reconnaît et traite de manière spéciale dans l'interface GA4, les rapports e-commerce et les intégrations publicitaires (Google Ads, Merchant Center). Si vous utilisez des noms d'événements arbitraires, vous perdez les rapports e-commerce natifs et la compatibilité avec les conversions Google Ads.

Autre différence structurelle : les produits ne sont plus des champs séparés. Ils passent tous dans un tableau items dont la structure est définie et documentée par Google. Ce tableau peut contenir jusqu'à 200 éléments par événement.

2. Les recommended events e-commerce GA4 : liste officielle

La documentation officielle GA4 définit les événements recommandés couvrant le parcours d'achat complet, de la découverte à l'achat. Voici la liste dans l'ordre du funnel :

• view_item_list : un utilisateur voit une liste de produits (page catégorie, résultats de recherche, carrousel).
• select_item : un utilisateur clique sur un produit depuis une liste.
• view_item : un utilisateur consulte la page détail d'un produit.
• add_to_cart : un produit est ajouté au panier.
• remove_from_cart : un produit est retiré du panier.
• view_cart : un utilisateur consulte son panier.
• begin_checkout : un utilisateur initie le processus de commande.
• add_shipping_info : un utilisateur sélectionne ou confirme son mode de livraison.
• add_payment_info : un utilisateur renseigne ou sélectionne son mode de paiement.
• purchase : une transaction est complétée.
• refund : un remboursement total ou partiel est effectué.
• view_promotion : une bannière promotionnelle est vue.
• select_promotion : une bannière promotionnelle est cliquée.

Tous ces noms d'événements sont en snake_case et doivent être utilisés à l'identique. Une majuscule, un underscore manquant ou un nom légèrement différent ( AddToCart au lieu de add_to_cart ) rompt la reconnaissance GA4.

3. L'objet items : paramètres standards

Chaque événement e-commerce GA4 accepte un tableau items . Chaque élément du tableau représente un produit. Voici les paramètres standards documentés par Google :

• item_id : identifiant unique du produit (SKU, ID base de données). Requis si item_name absent.
• item_name : nom du produit. Requis si item_id absent.
• price : prix unitaire du produit (nombre décimal).
• quantity : quantité commandée ou affichée.
• item_brand : marque du produit.
• item_category : catégorie principale. GA4 supporte jusqu'à 5 niveaux hiérarchiques : item_category , item_category2 , item_category3 , item_category4 , item_category5 .
• item_variant : variante du produit (couleur, taille...).
• affiliation : magasin ou filiale associée à l'article.
• coupon : code de réduction appliqué au niveau produit.
• discount : montant de remise appliqué à l'article.
• index : position de l'article dans la liste.
• item_list_id : identifiant de la liste depuis laquelle le produit a été sélectionné.
• item_list_name : nom de la liste ("Produits similaires", "Meilleures ventes"...).
• location_id : identifiant de lieu associé (code postal, ID Google Places).

GA4 autorise jusqu'à 27 paramètres personnalisés supplémentaires par objet item. Le tableau items peut contenir jusqu'à 200 éléments par événement.

4. Exemple dataLayer : view_item

L'événement view_item doit être poussé lorsqu'un utilisateur arrive sur une page produit. Le push doit inclure currency , value (prix du produit affiché) et le tableau items .

// Page produit : push dataLayer view_item
window.dataLayer = window.dataLayer || [];
window.dataLayer.push({ ecommerce: null }); // Effacer les données précédentes

window.dataLayer.push({
  event: 'view_item',
  ecommerce: {
    currency: 'EUR',
    value: 59.90,
    items: [
      {
        item_id: 'SKU_12345',
        item_name: 'T-shirt coton bio marine',
        item_brand: 'MaMarque',
        item_category: 'Vêtements',
        item_category2: 'T-shirts',
        item_variant: 'Marine / L',
        price: 59.90,
        quantity: 1,
        index: 0
      }
    ]
  }
});

Note importante : il faut toujours pousser { ecommerce: null } avant chaque push e-commerce pour effacer les données du précédent événement. Sans ce reset, GTM peut lire des données obsolètes de l'événement précédent. C'est documenté dans la documentation Google.

5. Exemples dataLayer : add_to_cart et begin_checkout

L'événement add_to_cart se déclenche au clic sur le bouton "Ajouter au panier". begin_checkout se déclenche lorsque l'utilisateur clique sur "Commander" ou arrive sur la première étape de checkout.

// Clic "Ajouter au panier"
window.dataLayer = window.dataLayer || [];
window.dataLayer.push({ ecommerce: null });

window.dataLayer.push({
  event: 'add_to_cart',
  ecommerce: {
    currency: 'EUR',
    value: 59.90,
    items: [
      {
        item_id: 'SKU_12345',
        item_name: 'T-shirt coton bio marine',
        item_brand: 'MaMarque',
        item_category: 'Vêtements',
        item_category2: 'T-shirts',
        item_variant: 'Marine / L',
        price: 59.90,
        quantity: 1
      }
    ]
  }
});

// Début du checkout (plusieurs produits dans le panier)
window.dataLayer = window.dataLayer || [];
window.dataLayer.push({ ecommerce: null });

window.dataLayer.push({
  event: 'begin_checkout',
  ecommerce: {
    currency: 'EUR',
    value: 119.80,
    coupon: 'PROMO10',
    items: [
      {
        item_id: 'SKU_12345',
        item_name: 'T-shirt coton bio marine',
        item_brand: 'MaMarque',
        item_category: 'Vêtements',
        item_variant: 'Marine / L',
        price: 59.90,
        quantity: 2
      }
    ]
  }
});

Pour add_shipping_info et add_payment_info , la structure est identique avec en supplément le paramètre shipping_tier (ex: 'Colissimo' ) ou payment_type (ex: 'Carte bancaire' ) au niveau de l'objet ecommerce .

6. Exemple dataLayer : purchase

Le push purchase est le plus critique. Il conditionne le reporting de revenus dans GA4 et les conversions Google Ads. Les paramètres transaction_id , currency et value sont obligatoires. transaction_id doit être unique par commande.

// Confirmation de commande : push purchase
window.dataLayer = window.dataLayer || [];
window.dataLayer.push({ ecommerce: null });

window.dataLayer.push({
  event: 'purchase',
  ecommerce: {
    transaction_id: 'ORDER-98765',   // ID unique de commande
    value: 113.81,                   // Revenu total (après remise, hors ou TTC selon config)
    tax: 18.97,                      // Montant TVA
    shipping: 4.90,                  // Frais de livraison
    currency: 'EUR',
    coupon: 'PROMO10',
    items: [
      {
        item_id: 'SKU_12345',
        item_name: 'T-shirt coton bio marine',
        item_brand: 'MaMarque',
        item_category: 'Vêtements',
        item_category2: 'T-shirts',
        item_variant: 'Marine / L',
        price: 53.91,                // Prix après remise coupon
        quantity: 2,
        coupon: 'PROMO10',
        discount: 5.99
      }
    ]
  }
});

Points clés sur purchase selon la doc officielle.

• Le paramètre value doit correspondre au revenu que vous souhaitez tracer (hors taxes ou TTC selon votre convention interne, mais restez cohérent).
• Le transaction_id doit être strictement unique. GA4 déduplique les événements purchase ayant le même transaction_id dans une fenêtre de temps limitée.
• Le code currency doit être au format ISO 4217 ("EUR", "USD", "GBP"...).

7. Implémentation via GTM

Google Tag Manager est la méthode recommandée pour implémenter les événements GA4 e-commerce. Elle sépare le code de tracking de la logique applicative et permet des modifications sans déploiement.

La documentation GTM dataLayer décrit le fonctionnement du dataLayer. Voici la configuration dans GTM pour un événement e-commerce :

Étape 1 : créer les variables dataLayer

Dans GTM, créez des variables de type "Variable de couche de données" pour chaque paramètre à capturer :

• Variable : DLV - ecommerce.currency , nom de la variable dataLayer : ecommerce.currency
• Variable : DLV - ecommerce.value , nom : ecommerce.value
• Variable : DLV - ecommerce.transaction_id , nom : ecommerce.transaction_id
• Variable : DLV - ecommerce.items , nom : ecommerce.items

Étape 2 : créer les déclencheurs custom event

Pour chaque événement GA4, créez un déclencheur de type "Événement personnalisé" avec le nom exact de l'événement :

• Déclencheur CE - view_item : nom de l'événement = view_item
• Déclencheur CE - add_to_cart : nom de l'événement = add_to_cart
• Déclencheur CE - begin_checkout : nom = begin_checkout
• Déclencheur CE - purchase : nom = purchase

Étape 3 : créer les tags GA4 Event

Pour chaque événement, créez un tag de type "Événement Google Analytics : GA4". Configuration :

• Tag de configuration : sélectionnez votre tag GA4 Configuration (ou entrez votre Measurement ID directement).
• Nom de l'événement : utilisez une variable ou saisissez le nom exact ( purchase , add_to_cart ...).
• Paramètres de l'événement : ajoutez currency , value , transaction_id (pour purchase), items en pointant sur les variables DLV créées.

Pour le tableau items , sélectionnez "Envoyer les données e-commerce" et utilisez la source "Couche de données" afin que GTM lise automatiquement ecommerce.items depuis le dataLayer. C'est la méthode officielle décrite dans la documentation Google Analytics.

8. Implémentation via gtag.js direct

Si vous n'utilisez pas GTM, vous pouvez pousser les événements directement avec la bibliothèque gtag.js. La syntaxe est légèrement différente du push dataLayer, mais les paramètres sont identiques.

// Avec gtag.js : view_item
gtag('event', 'view_item', {
  currency: 'EUR',
  value: 59.90,
  items: [
    {
      item_id: 'SKU_12345',
      item_name: 'T-shirt coton bio marine',
      item_brand: 'MaMarque',
      item_category: 'Vêtements',
      item_variant: 'Marine / L',
      price: 59.90,
      quantity: 1
    }
  ]
});

// Avec gtag.js : purchase
gtag('event', 'purchase', {
  transaction_id: 'ORDER-98765',
  value: 113.81,
  tax: 18.97,
  shipping: 4.90,
  currency: 'EUR',
  items: [
    {
      item_id: 'SKU_12345',
      item_name: 'T-shirt coton bio marine',
      item_brand: 'MaMarque',
      item_category: 'Vêtements',
      item_variant: 'Marine / L',
      price: 53.91,
      quantity: 2,
      discount: 5.99
    }
  ]
});

La bibliothèque gtag.js est chargée via le snippet Google Analytics standard. Assurez-vous que l'appel gtag('event', ...) s'exécute après le chargement complet de gtag.js.

9. Pièges fréquents à éviter

L'expérience terrain sur des implémentations e-commerce GA4 révèle plusieurs erreurs récurrentes :

Doublons sur l'événement purchase

C'est l'erreur la plus coûteuse. Elle survient quand la page de confirmation est accessible plusieurs fois (rechargement, retour navigateur, lien de confirmation par email). Protections possibles : stocker le transaction_id en cookie ou localStorage et ne pusher qu'une seule fois, ou utiliser la déduplication native GA4 (qui ne couvre qu'une fenêtre limitée). Pour un e-commerce en production, la protection côté serveur est la plus fiable.

transaction_id manquant ou non unique

GA4 rejette silencieusement les événements purchase sans transaction_id . Utilisez toujours l'ID de commande réel de votre système, pas un timestamp généré côté client.

currency incohérente ou absente

Le paramètre currency est obligatoire pour purchase . GA4 ignore les revenus sans currency définie. Utilisez le code ISO 4217 exact ("EUR" et non "euro" ou "€").

Tableau items vide

Un événement purchase avec items: [] est valide côté GA4 mais perd toute valeur analytique pour le reporting par produit. Vérifiez que votre code back-end alimente bien le tableau avant le push.

Timing dans les SPA et Next.js

Dans une application Next.js ou tout framework SPA, les navigations côté client ne rechargent pas la page. Il faut pousser les événements GA4 manuellement à chaque changement de route pertinent. Pour view_item par exemple, le push doit être déclenché dans le useEffect qui s'exécute quand l'URL du produit change, pas au montage initial de l'app.

Oubli du reset ecommerce

Ne pas pusher { ecommerce: null } avant chaque événement peut provoquer une contamination des données : GTM lit les items du dernier événement au lieu de l'événement courant.

10. Validation : DebugView, GTM Preview, Tag Assistant

Une implémentation GA4 e-commerce doit être validée avec plusieurs outils avant mise en production.

GA4 DebugView

Activez le mode debug en ajoutant ?gtm_debug=x dans l'URL (si GTM) ou en activant l'extension Tag Assistant. Dans l'interface GA4, allez dans Admin puis DebugView. Vous voyez les événements en temps réel avec tous leurs paramètres. Vérifiez que currency , value , transaction_id et items sont bien présents et correctement valorisés.

GTM Preview mode

Via le bouton "Aperçu" dans GTM, l'outil GTM Preview montre chaque push dataLayer, les tags déclenchés et les variables résolues. C'est l'outil de débogage principal pour vérifier que le tag GA4 Event se déclenche bien et que les paramètres items ne sont pas vides ou mal mappés.

Extension Google Tag Assistant

L'extension Tag Assistant (Chrome) permet de voir les hits GA4 envoyés en temps réel. Elle affiche la requête réseau complète vers google-analytics.com/g/collect , ce qui permet de vérifier les paramètres encodés dans la requête.

Validation en production

Après déploiement, comparez les revenus GA4 avec les revenus de votre plateforme e-commerce sur une période courte. Un écart systématique de plusieurs points indique généralement des doublons, un timing de push incorrect (déclenché avant la confirmation réelle) ou une currency mal configurée.

11. Server-side tagging et Enhanced Conversions

L'implémentation dataLayer côté client que nous venons de décrire est la base. Pour aller plus loin en termes de fiabilité et de précision, deux approches complémentaires méritent attention.

Le server-side tagging GTM permet de traiter les événements GA4 côté serveur plutôt que dans le navigateur. Les avantages sont multiples : contournement partiel des ad-blockers, meilleure durée de vie des cookies first-party, contrôle sur les données envoyées à GA4. L'événement purchase en particulier gagne en fiabilité quand il est envoyé depuis un serveur qui a accès à la confirmation de paiement réelle.

Les Enhanced Conversions Google Ads permettent d'enrichir les conversions Google Ads avec des données first-party hachées (email, téléphone, adresse). Elles se configurent en parallèle du suivi GA4 et améliorent la qualité du signal de conversion pour les campagnes Shopping et Performance Max.

Ces deux approches partagent la même fondation technique : un dataLayer propre avec des événements correctement structurés. Investir dans une implémentation GA4 rigoureuse maintenant facilite le déploiement de ces couches avancées ensuite.

Une donnée fiable est aussi le socle du pilotage de l'acquisition organique. Pour structurer durablement votre référencement naturel e-commerce, la mesure GA4 alimente les arbitrages de contenu et de priorisation SEO.

12. Conclusion

Le suivi e-commerce GA4 repose sur une logique simple : des événements standardisés (recommended events) avec un objet items uniformisé. L'implémentation technique demande de la rigueur sur trois points : noms d'événements exacts, paramètres items complets, et transaction_id unique pour le purchase.

Les erreurs les plus fréquentes (doublons purchase, currency absente, items vide, mauvais timing SPA) sont évitables avec une procédure de validation systématique : GTM Preview, DebugView GA4 et comparaison avec les données back-end avant toute mise en production.

Les sources utilisées dans cet article sont les références officielles Google : GA4 Measure ecommerce, GA4 recommended events reference, Set up ecommerce Google Analytics et GTM dataLayer documentation.