Auditer le dataLayer e-commerce : protocole et script

Auditer le dataLayer e-commerce pas à pas : rejouer l'achat, exporter les pushes et les contrôler contre le schéma GA4 avec un script Python testé.

Par Ron Kopelman Publié le 21 novembre 2026 ⏱ 1 h Niveau : Intermédiaire
Outils Google Analytics 4 Google Tag Manager
Dans ce tutoriel
  1. Ce que l’audit du dataLayer contrôle
  2. Le protocole, étape par étape
  3. Le script de contrôle
  4. Limites du protocole

Un dataLayer e-commerce est juste s’il envoie, à chaque étape de l’achat, les bons champs avec les bons types. Pour le vérifier, on rejoue une commande test, on exporte les pushes et on les contrôle un par un contre le schéma GA4 : c’est le protocole de ce tutoriel, avec un script qui signale les anomalies. Il vient en complément de l’audit de tracking, qui couvre tout le dispositif, alors que ce protocole ne regarde que la couche de données.

Avant de commencer

⏱ 1 h Niveau : Intermédiaire
  • Une commande de test sur la boutique, ou une commande réelle annulée
  • Chrome et sa console des outils de développement (touche F12)
  • Python 3 sur le poste : le script n'utilise que la bibliothèque standard
  • Le plan de marquage e-commerce de la boutique, ou à défaut le schéma des événements GA4

Ce que l’audit du dataLayer contrôle

Trois documents se recoupent sans se remplacer. Le plan de marquage fixe le contrat : quel événement, quels paramètres, à quel moment. Le contrôle du conteneur GTM vérifie les balises et les déclencheurs, à partir de l’export du conteneur. Le présent audit vérifie ce que le site envoie réellement, push par push, sur un parcours réel.

Un push peut être conforme au plan et faux à l’exécution : un prix écrit en texte, une devise absente, une commande poussée une seconde fois au rechargement de la page de confirmation. GA4 n’affiche généralement aucun message d’erreur dans ces cas, d’où l’intérêt de chercher l’anomalie directement dans les pushes.

Le protocole en quatre temps

Du parcours de test à la recette après correction.

Outils cités Google Analytics 4 Google Tag Manager Shopify WooCommerce PrestaShop

Le protocole, étape par étape

  1. Préparer une navigation propre5 min

    Ouvrez une fenêtre de navigation privée, acceptez le consentement, puis ouvrez la console sur la fiche d’un produit. Tapez window.dataLayer : le tableau doit exister avant le premier clic.

    Résultat attendu : un tableau contenant les pushes déjà envoyés au chargement, dont des pushes de configuration sans ecommerce.

  2. Rejouer le parcours dans l'ordre10 min

    Faites l’achat test dans cet ordre : fiche produit, ajout au panier, panier, étape de commande, confirmation. Puis rechargez la page de confirmation. Ne filtrez pas la console : on veut la séquence complète, rechargement compris.

    Résultat attendu : au moins un push e-commerce par étape, et aucun nouveau purchase au rechargement.

  3. Exporter les pushes5 min

    Dans la console, collez le code ci-dessous. Il copie dans le presse-papiers un tableau JSON qui ne garde que event et ecommerce, et convertit les pushes envoyés par gtag().

    copy(JSON.stringify((window.dataLayer || []).reduce((out, p) => {
      if (!p || typeof p !== 'object') return out;
      if (Object.prototype.toString.call(p) === '[object Arguments]') {
        if (p[0] === 'event') out.push({ event: p[1], ecommerce: p[2] || null });
        return out;
      }
      const r = {};
      if ('event' in p) r.event = p.event;
      if ('ecommerce' in p) r.ecommerce = p.ecommerce;
      if (Object.keys(r).length) out.push(r);
      return out;
    }, [])));

    Collez le contenu dans un fichier export-pushes.json, dans un dossier qui ne contient que le script.

    Résultat attendu : un fichier JSON lisible, qui commence par les pushes de configuration et se termine par le dernier push du parcours.

  4. Contrôler chaque push contre le schéma10 min

    Le script applique les règles ci-dessous. La page Google des événements e-commerce ne classe pas chaque paramètre en requis ou recommandé : elle montre les paramètres présents dans les exemples de chaque événement. Le script suit donc ces exemples, et signale ce qui relève d’une convention.

    RègleCe que dit la sourceCode du script
    Nom d’événementLes onze événements e-commerce GA4 ont un nom fixeevent_inconnu
    Identifiant d’articleChaque article doit avoir item_id ou item_name ; Google recommande les deuxitem_sans_identifiant, item_un_seul_identifiant
    Référence de commandetransaction_id est requis pour purchase et refundtid_absent, tid_doublon
    MontantGoogle indique value comme la somme de price x quantity des articles ; taxes et frais de port sont envoyés à partvalue_ecart
    DeviseLes exemples utilisent USD ; la page ne cite pas la norme ISO 4217currency_absente, currency_format
    Quantitéquantity vaut 1 par défautquantity_invalide
    Taille du tableauMaximum 200 articles par itemsitems_trop_long
    RéinitialisationLa version GTM du guide e-commerce de Google pousse { ecommerce: null } avant chaque événement, avec le commentaire « Clear the previous ecommerce object »reset_absent

    Le contrôle tid_doublon ne vient pas de Google : c’est un contrôle propre au protocole, qui repère une commande poussée deux fois.

    Résultat attendu : chaque règle a une correspondance dans le tableau de la section suivante.

  5. Lancer le script2 min

    Depuis le dossier du script :

    python audit_datalayer.py export-pushes.json

    Sortie obtenue sur l’export synthétique fourni plus bas (exemple fictif, pas un site réel), exécution du 21 novembre 2026 avec Python 3.14.3 :

    Pushes lus : 13 (e-commerce : 6, reset ecommerce: null : 6, hors e-commerce ignorés : 1)
    
    [ligne 5] add_to_cart | value | value_texte | Élevée
        constat : valeur reçue : '49.90'
        impact  : Totaux et règles de valeur de conversion faux sans erreur visible
        correction : Pousser value en nombre, pas en chaîne
    [ligne 7] begin_checkout | currency | currency_absente | Élevée
        constat : clé absente
        impact  : Montant non converti ou ignoré selon la configuration
        correction : Pousser currency à côté de value sur chaque événement
    [ligne 9] purchase | value | value_ecart | Élevée
        constat : value = 159.7, somme(price x quantity) = 149.7
        impact  : Revenus GA4 différents de la somme des articles (frais de port, remise ou erreur ?)
        correction : Recalculer value à partir des lignes, ou documenter la convention appliquée
    [ligne 11] purchase | transaction_id | tid_doublon | Critique
        constat : déjà vu à la ligne 9 : 'CMD-10452'
        impact  : Une commande envoyée deux fois compte deux fois
        correction : Un seul purchase par référence : garde-fou côté code et contrôle du rechargement
    
    Anomalies : 4 (Élevée 3, Critique 1)

    Le numéro de ligne est le rang du push dans le fichier exporté, pas une ligne de code du site. Le script se termine avec le code 1 dès qu’une anomalie est critique ou élevée, ce qui permet de l’enchaîner dans une recette.

    Résultat attendu : une liste d’anomalies, chacune avec son code, sa gravité, son impact et sa correction.

  6. Traduire les anomalies en corrections15 min

    Chaque anomalie de l’exemple correspond à un défaut à corriger côté développement, ou à une convention à documenter.

    LigneAnomalieImpactCorrection
    5add_to_cart : value envoyé en texte, "49.90" (value_texte)Totaux et règles de valeur faux, sans erreur visiblePousser le nombre 49.9
    7begin_checkout sans currency (currency_absente)Montant non converti ou ignoré selon la configurationPousser currency à côté de value
    9purchase : value de 159,7 pour des articles de 149,7 (value_ecart) ; 10 de frais de port ajoutésRevenus GA4 gonflés par rapport aux articlesDécider de la convention, puis aligner value sur elle
    11purchase CMD-10452 envoyé deux fois (tid_doublon)Une commande compte deux foisUn seul push par référence : garde-fou côté code

    Un value_ecart n’est pas toujours une erreur. Une remise, un remboursement partiel ou des frais de port inclus peuvent expliquer l’écart. Dans ce cas, documentez la convention et vérifiez-la sur trois commandes du back-office, comme le fait le plan de marquage e-commerce.

  7. Corriger et refaire la recette30 min

    Corrigez les anomalies critiques et élevées, puis refaites le parcours complet dans une navigation privée, avec un nouvel export. La recette est validée quand le script ne signale plus aucune anomalie critique ou élevée, et que les mêmes événements apparaissent dans le mode Preview de GTM et dans DebugView de GA4. Pour l’outillage, voir le guide dataLayer GTM avec exemples par CMS.

Le script de contrôle

Le script lit un export JSON, applique les règles du tableau ci-dessus et affiche chaque anomalie. Il n’appelle aucun service et ne modifie aucun fichier.

#!/usr/bin/env python3
"""Contrôle d'un export JSON des pushes dataLayer e-commerce (lecture seule).

Usage : python audit_datalayer.py export-pushes.json

Le fichier est une liste JSON de pushes, dans l'ordre d'envoi. Les pushes
non e-commerce (sans clé `ecommerce`) sont ignorés. Le script n'utilise que la
bibliothèque standard et n'appelle aucun service.
"""
import json
import re
import sys
from collections import Counter

# Événements du schéma e-commerce GA4 (page Google « Événements e-commerce »).
ECOM_EVENTS = {
    "view_item_list", "select_item", "view_item", "add_to_cart",
    "remove_from_cart", "view_cart", "begin_checkout", "add_shipping_info",
    "add_payment_info", "purchase", "refund",
}
# Événements dont les exemples Google portent un `value`.
VALUE_EVENTS = {
    "view_item", "add_to_cart", "remove_from_cart", "view_cart",
    "begin_checkout", "add_shipping_info", "add_payment_info",
    "purchase", "refund",
}
# Événements qui portent un transaction_id (Google : « Required for purchases and refunds »).
TID_EVENTS = {"purchase", "refund"}

TOLERANCE = 0.005  # demi-centime : écart d'arrondi toléré entre value et la somme
MAX_ITEMS = 200     # limite indiquée par Google pour le tableau items

# code -> (gravité, impact, correction)
RULES = {
    "ecommerce_non_objet": ("Élevée", "Push e-commerce illisible par GTM ou GA4",
                            "Pousser un objet ecommerce, pas une chaîne ni un tableau"),
    "event_inconnu": ("Moyenne", "Événement sans correspondance dans le schéma GA4 e-commerce",
                      "Renommer selon le schéma GA4 ou documenter l'écart"),
    "reset_absent": ("Moyenne", "Données du push précédent susceptibles de rester dans ecommerce (étape montrée par le guide e-commerce GTM de Google)",
                     "Pousser dataLayer.push({ ecommerce: null }) avant chaque push e-commerce"),
    "items_absent": ("Élevée", "Aucun détail produit : rapports produits vides",
                     "Pousser un tableau items non vide"),
    "items_trop_long": ("Moyenne", "Au-delà de 200 articles, GA4 ne garde pas la liste complète (limite Google)",
                        "Découper ou limiter le tableau items"),
    "item_sans_identifiant": ("Élevée", "Ligne (not set) dans les rapports produits",
                              "Pousser item_id ou item_name, idéalement les deux"),
    "item_un_seul_identifiant": ("Faible", "Rapprochement produit plus fragile",
                                 "Pousser item_id et item_name (Google recommande les deux)"),
    "price_texte": ("Élevée", "Somme et valeurs faussées sans erreur visible",
                    "Pousser price en nombre (49.9), pas en chaîne (\"49.90\")"),
    "price_absent": ("Moyenne", "Contrôle de cohérence de value impossible",
                     "Pousser price sur chaque article"),
    "quantity_invalide": ("Moyenne", "Total du panier faux",
                          "Pousser quantity en entier supérieur ou égal à 1"),
    "value_absente": ("Élevée", "Revenu absent des rapports et des conversions",
                      "Pousser value sur l'événement"),
    "value_texte": ("Élevée", "Totaux et règles de valeur de conversion faux sans erreur visible",
                    "Pousser value en nombre, pas en chaîne"),
    "value_ecart": ("Élevée", "Revenus GA4 différents de la somme des articles (frais de port, remise ou erreur ?)",
                    "Recalculer value à partir des lignes, ou documenter la convention appliquée"),
    "currency_absente": ("Élevée", "Montant non converti ou ignoré selon la configuration",
                         "Pousser currency à côté de value sur chaque événement"),
    "currency_format": ("Moyenne", "Devise non reconnue",
                        "Code ISO 4217 en trois lettres majuscules, par exemple EUR"),
    "tid_absent": ("Critique", "Commande impossible à dédupliquer ou à rapprocher du back-office",
                   "Pousser la référence de commande dans transaction_id"),
    "tid_doublon": ("Critique", "Une commande envoyée deux fois compte deux fois",
                    "Un seul purchase par référence : garde-fou côté code et contrôle du rechargement"),
}


def is_number(x):
    return isinstance(x, (int, float)) and not isinstance(x, bool)


def audit(pushes):
    findings = []
    stats = Counter()
    seen_tid = {}
    prev = None

    def add(line, event, field, code, detail):
        gravite, impact, correction = RULES[code]
        findings.append({
            "ligne": line, "event": event or "-", "champ": field, "code": code,
            "gravite": gravite, "detail": detail, "impact": impact, "correction": correction,
        })

    for i, push in enumerate(pushes, start=1):
        if not isinstance(push, dict) or "ecommerce" not in push:
            stats["hors_ecommerce"] += 1
            prev = push
            continue

        ec = push["ecommerce"]
        if ec is None:
            stats["reset"] += 1
            prev = push
            continue

        event = push.get("event")
        stats["push_ecommerce"] += 1

        # Réinitialisation : le push précédent doit être { ecommerce: null }.
        if not (isinstance(prev, dict) and "ecommerce" in prev and prev["ecommerce"] is None):
            add(i, event, "ecommerce", "reset_absent", "pas de push ecommerce: null juste avant")
        prev = push

        if not isinstance(ec, dict):
            add(i, event, "ecommerce", "ecommerce_non_objet", f"type reçu : {type(ec).__name__}")
            continue

        if event not in ECOM_EVENTS:
            add(i, event, "event", "event_inconnu", f"nom reçu : {event!r}")

        # Devise.
        cur = ec.get("currency")
        if cur is None:
            add(i, event, "currency", "currency_absente", "clé absente")
        elif not (isinstance(cur, str) and re.fullmatch(r"[A-Z]{3}", cur)):
            add(i, event, "currency", "currency_format", f"valeur reçue : {cur!r}")

        # Articles.
        items = ec.get("items")
        total = 0.0
        total_fiable = True
        if not isinstance(items, list) or not items:
            add(i, event, "items", "items_absent", "tableau absent ou vide")
            total_fiable = False
        else:
            if len(items) > MAX_ITEMS:
                add(i, event, "items", "items_trop_long", f"{len(items)} articles")
            for n, it in enumerate(items, start=1):
                if not isinstance(it, dict):
                    add(i, event, f"items[{n}]", "item_sans_identifiant", "article non objet")
                    total_fiable = False
                    continue
                item_id, item_name = it.get("item_id"), it.get("item_name")
                if not item_id and not item_name:
                    add(i, event, f"items[{n}]", "item_sans_identifiant", "ni item_id ni item_name")
                elif not (item_id and item_name):
                    add(i, event, f"items[{n}]", "item_un_seul_identifiant",
                        "item_id" if item_id else "item_name")
                price = it.get("price")
                if price is None:
                    add(i, event, f"items[{n}].price", "price_absent", "clé absente")
                    total_fiable = False
                elif not is_number(price):
                    add(i, event, f"items[{n}].price", "price_texte", f"valeur reçue : {price!r}")
                    total_fiable = False
                qty = it.get("quantity", 1)  # Google : quantity vaut 1 par défaut
                if not (is_number(qty) and qty >= 1 and float(qty).is_integer()):
                    add(i, event, f"items[{n}].quantity", "quantity_invalide", f"valeur reçue : {qty!r}")
                    total_fiable = False
                elif is_number(price):
                    total += price * qty

        # Montant.
        if event in VALUE_EVENTS:
            val = ec.get("value")
            if val is None:
                add(i, event, "value", "value_absente", "clé absente")
            elif not is_number(val):
                add(i, event, "value", "value_texte", f"valeur reçue : {val!r}")
            elif total_fiable and abs(round(total, 2) - val) > TOLERANCE:
                add(i, event, "value", "value_ecart",
                    f"value = {val}, somme(price x quantity) = {round(total, 2)}")

        # Identifiant de commande.
        if event in TID_EVENTS:
            tid = ec.get("transaction_id")
            if not tid:
                add(i, event, "transaction_id", "tid_absent", "clé absente ou vide")
            elif event == "purchase":
                if tid in seen_tid:
                    add(i, event, "transaction_id", "tid_doublon",
                        f"déjà vu à la ligne {seen_tid[tid]} : {tid!r}")
                else:
                    seen_tid[tid] = i

    return findings, stats


def main():
    sys.stdout.reconfigure(encoding="utf-8")
    if len(sys.argv) != 2:
        print("Usage : python audit_datalayer.py export-pushes.json")
        return 2
    with open(sys.argv[1], encoding="utf-8") as f:
        pushes = json.load(f)
    if not isinstance(pushes, list):
        print("Le fichier doit contenir une liste JSON de pushes.")
        return 2

    findings, stats = audit(pushes)

    print(f"Pushes lus : {len(pushes)} "
          f"(e-commerce : {stats['push_ecommerce']}, reset ecommerce: null : {stats['reset']}, "
          f"hors e-commerce ignorés : {stats['hors_ecommerce']})")
    print()
    for f in findings:
        print(f"[ligne {f['ligne']}] {f['event']} | {f['champ']} | {f['code']} | {f['gravite']}")
        print(f"    constat : {f['detail']}")
        print(f"    impact  : {f['impact']}")
        print(f"    correction : {f['correction']}")
    graves = Counter(f["gravite"] for f in findings)
    print()
    print(f"Anomalies : {len(findings)} ({', '.join(f'{k} {v}' for k, v in graves.items()) or 'aucune'})")
    return 1 if any(f["gravite"] in ("Critique", "Élevée") for f in findings) else 0


if __name__ == "__main__":
    sys.exit(main())

Testé avec Python 3.14.3 sur un export synthétique de 13 pushes, dont 6 e-commerce, qui contient quatre anomalies volontaires. Le script a trouvé exactement ces quatre anomalies, sans faux positif sur les pushes corrects, et il a signalé l’absence de ecommerce: null quand je l’ai retiré d’un export de test. Le même export sert de référence pour vérifier une modification du script.

Export synthétique utilisé pour ce test (fictif) :

[
  {
    "gtm.start": 1700000000000,
    "event": "gtm.js"
  },
  {
    "ecommerce": null
  },
  {
    "event": "view_item",
    "ecommerce": {
      "currency": "EUR",
      "value": 49.9,
      "items": [
        {
          "item_id": "SKU-1",
          "item_name": "T-shirt bleu",
          "price": 49.9,
          "quantity": 1
        }
      ]
    }
  },
  {
    "ecommerce": null
  },
  {
    "event": "add_to_cart",
    "ecommerce": {
      "currency": "EUR",
      "value": "49.90",
      "items": [
        {
          "item_id": "SKU-1",
          "item_name": "T-shirt bleu",
          "price": 49.9,
          "quantity": 1
        }
      ]
    }
  },
  {
    "ecommerce": null
  },
  {
    "event": "begin_checkout",
    "ecommerce": {
      "value": 99.8,
      "items": [
        {
          "item_id": "SKU-1",
          "item_name": "T-shirt bleu",
          "price": 49.9,
          "quantity": 2
        }
      ]
    }
  },
  {
    "ecommerce": null
  },
  {
    "event": "purchase",
    "ecommerce": {
      "transaction_id": "CMD-10452",
      "currency": "EUR",
      "value": 159.7,
      "shipping": 10,
      "items": [
        {
          "item_id": "SKU-1",
          "item_name": "T-shirt bleu",
          "price": 49.9,
          "quantity": 1
        },
        {
          "item_id": "SKU-2",
          "item_name": "Sweat gris",
          "price": 49.9,
          "quantity": 2
        }
      ]
    }
  },
  {
    "ecommerce": null
  },
  {
    "event": "purchase",
    "ecommerce": {
      "transaction_id": "CMD-10452",
      "currency": "EUR",
      "value": 149.7,
      "shipping": 10,
      "items": [
        {
          "item_id": "SKU-1",
          "item_name": "T-shirt bleu",
          "price": 49.9,
          "quantity": 1
        },
        {
          "item_id": "SKU-2",
          "item_name": "Sweat gris",
          "price": 49.9,
          "quantity": 2
        }
      ]
    }
  },
  {
    "ecommerce": null
  },
  {
    "event": "view_cart",
    "ecommerce": {
      "currency": "EUR",
      "value": 49.9,
      "items": [
        {
          "item_id": "SKU-1",
          "item_name": "T-shirt bleu",
          "price": 49.9,
          "quantity": 1
        }
      ]
    }
  }
]

Limites du protocole

  • Le script ne voit que les pushes exportés : il ne sait pas si un push part au bon moment, ni s’il part avant le consentement.
  • Il ne vérifie pas que la devise existe au sens ISO 4217, seulement son format à trois lettres majuscules.
  • Il ne connaît pas la convention de montant de la boutique : c’est à vous de la documenter, puis de la comparer au back-office.
  • Il ne couvre pas le serveur. Sur un sGTM, les événements arrivent autrement et il faut auditer la chaîne de transformation.
  • Un export est une photo : refaites-le après chaque modification du thème ou du module.

Sources

Ron Kopelman

Vous préférez que je le fasse ?

Je mets en place ce tutoriel sur votre site, avec recette et documentation. Cadrage gratuit de 30 minutes.