Tutoriel
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é.
Dans ce tutoriel
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
- 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.
Du parcours de test à la recette après correction.
Le protocole, étape par étape
-
Préparer une navigation propre
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. -
Rejouer le parcours dans l'ordre
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
purchaseau rechargement. -
Exporter les pushes
Dans la console, collez le code ci-dessous. Il copie dans le presse-papiers un tableau JSON qui ne garde que
eventetecommerce, et convertit les pushes envoyés pargtag().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.
-
Contrôler chaque push contre le schéma
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ègle Ce que dit la source Code du script Nom d’événement Les onze événements e-commerce GA4 ont un nom fixe event_inconnuIdentifiant d’article Chaque article doit avoir item_idouitem_name; Google recommande les deuxitem_sans_identifiant,item_un_seul_identifiantRéférence de commande transaction_idest requis pourpurchaseetrefundtid_absent,tid_doublonMontant Google indique valuecomme la somme depricexquantitydes articles ; taxes et frais de port sont envoyés à partvalue_ecartDevise Les exemples utilisent USD ; la page ne cite pas la norme ISO 4217 currency_absente,currency_formatQuantité quantityvaut 1 par défautquantity_invalideTaille du tableau Maximum 200 articles par itemsitems_trop_longRéinitialisation La version GTM du guide e-commerce de Google pousse { ecommerce: null }avant chaque événement, avec le commentaire « Clear the previous ecommerce object »reset_absentLe contrôle
tid_doublonne 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.
-
Lancer le script
Depuis le dossier du script :
python audit_datalayer.py export-pushes.jsonSortie 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.
-
Traduire les anomalies en corrections
Chaque anomalie de l’exemple correspond à un défaut à corriger côté développement, ou à une convention à documenter.
Ligne Anomalie Impact Correction 5 add_to_cart:valueenvoyé en texte,"49.90"(value_texte)Totaux et règles de valeur faux, sans erreur visible Pousser le nombre 49.97 begin_checkoutsanscurrency(currency_absente)Montant non converti ou ignoré selon la configuration Pousser currencyà côté devalue9 purchase:valuede 159,7 pour des articles de 149,7 (value_ecart) ; 10 de frais de port ajoutésRevenus GA4 gonflés par rapport aux articles Décider de la convention, puis aligner valuesur elle11 purchaseCMD-10452 envoyé deux fois (tid_doublon)Une commande compte deux fois Un seul push par référence : garde-fou côté code Un
value_ecartn’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. -
Corriger et refaire la recette
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
- Google, Événements e-commerce pour Google Analytics 4, version GTM, consultée le 21 novembre 2026 (
dataLayer.push({ ecommerce: null })avant chaque push). Même page, consultée le 21 novembre 2026 (paramètres présents dans les exemples,item_idouitem_name,transaction_idrequis pour purchase et refund, commentaire devalue, USD dans les exemples). - Google, Présentation de la couche de données pour Google Tag Manager, consulté le 21 novembre 2026.