ga4utm

Audit UTM : règles, contrôle et nettoyage dans GA4

Auditer les UTM dans GA4 : casse, espaces, valeurs hors canaux par défaut, (not set) et doublons. Règles, script Python testé et corrections.

Un audit des UTM vérifie que chaque lien de campagne arrive dans GA4 sous une valeur que les rapports savent lire et regrouper. Il repère quatre familles d’anomalies : la casse, les espaces parasites, les valeurs qui ne tombent dans aucun groupe de canaux, et les variantes qui éclatent un même canal en plusieurs lignes. Ce guide donne les règles, un script Python que j’ai testé sur un export synthétique, et la correction à appliquer à chaque type.

Si vos chiffres d’acquisition ne collent pas avec les plateformes publicitaires, les UTM sont un des premiers endroits à regarder. Le cadrage complet d’un contrôle de tracking, UTM compris, se fait sur la page audit tracking consultant.

Ce que Google dit de la casse, et ce qu’il ne dit pas

Les deux aides officielles ne disent pas la même chose, et c’est là que les audits se trompent.

  • L’aide sur la création d’URL de campagne rappelle que Google Analytics est sensible à la casse : utm_source=google et utm_source=Google sont deux valeurs différentes (source).
  • L’aide sur les groupes de canaux par défaut indique que les définitions de canaux ne sont pas sensibles à la casse (source).

En pratique, le regroupement par canal tolère la casse, mais les rapports qui listent la source, le support ou la campagne affichent « Google » et « google » sur deux lignes. Le même lien tombe donc dans le même canal tout en fragmentant vos tableaux de comparaison. La correction se fait à la source, pas dans le rapport.

Outils Google Analytics 4 BigQuery Looker Studio

Étape 1 : exporter les valeurs à contrôler

Dans le rapport d’acquisition de trafic, ajoutez les dimensions Source de session, Support de session et Campagne de session, sur 90 jours, puis exportez en CSV avec la colonne Sessions. Les libellés changent selon la langue et la version de l’interface : le script accepte les noms français et anglais, ainsi qu’une colonne combinée « source / support ». Vérifiez tout de même le total de sessions de l’export face à celui du rapport.

Étape 2 : appliquer les règles de contrôle

AnomalieExempleCe qu’elle casseCorrection
MajusculesNewsletter, LinkedInDeux lignes pour un même canal dans les rapports brutsForcer les minuscules dans le générateur de liens
Espaces parasitesgoogle ou promo Une valeur que personne ne reconnaît au filtrageSupprimer les espaces, remplacer les espaces internes par des tirets
Variantes d’un même coupleemail, e_mail, EmailUn canal e-mail éclaté en trois lignesChoisir une valeur de référence et la documenter
(not set) sur medium ou campagnepaid_social sans campagneTrafic payant impossible à attribuer à une créationAjouter utm_campaign au lien d’annonce
UTM sur lien interneutm_source=monsite.fr sur un lien du siteUne nouvelle session attribuée à ce lien interne, qui gonfle le canalRetirer les UTM des liens internes
Medium hors groupes de canauxnewsiteTrafic classé en Non attribuéRemplacer par un medium reconnu (voir étape 3)

Une règle de plus : ne mettez jamais un UTM sur un lien qui reste dans votre domaine. Le lien interne ouvre une nouvelle session et la source d’origine est perdue. Pour le cas des sessions qui arrivent en direct après une URL taguée, l’article sur les sessions direct à retrouver dans BigQuery montre comment les isoler.

Étape 3 : vérifier le canal par défaut

Le groupe de canaux par défaut de GA4 classe chaque session selon des règles sur la source et le support. Pour les valeurs de support les plus fréquentes, la correspondance publiée par Google est la suivante (liste officielle des canaux) :

Support reconnuCanal attribué
organicRecherche naturelle
email, e-mail, e_mail, e mailE-mail
referral, app, linkSite référent
social, social-network, social-media, smRéseaux sociaux (recherche naturelle)
affiliéAffiliés
cpc, ppc, retargeting, valeurs contenant cp ou commençant par paidCanaux payants
Tout le resteNon attribué

Les règles complètes dépendent aussi de la source, et Google publie une liste de sources à part. Le script ci-dessous reprend cette correspondance en version simplifiée : il sert à repérer les écarts, pas à reproduire le classement exact de GA4.

Étape 4 : auditer l’export avec un script

Le script lit l’export, signale chaque anomalie ligne par ligne, puis écrit le détail dans un second CSV. Il ne dépend que de la bibliothèque standard Python.

Auditer les UTM en quatre temps

Le contrôle ne modifie rien dans GA4 : il liste les valeurs à corriger, et la correction se fait dans les liens que vous publiez.

"""Audit des UTM dans un export GA4 (source, support, campagne, sessions).

Entrée : CSV exporté depuis GA4 (colonnes source / medium, ou « source / medium » combinée).
Sortie : résumé des anomalies à l'écran + CSV détaillé.
"""
import argparse
import csv
import re
from collections import defaultdict

ALIAS = {
    "source": ["source", "session source", "source de session"],
    "medium": ["medium", "session medium", "support de session"],
    "combi": ["session source / medium", "source / support de session", "source / medium"],
    "campagne": ["campaign", "session campaign", "campagne de session"],
    "sessions": ["sessions"],
}

# Approximation des règles publiées par Google (groupe de canaux par défaut).
# La page officielle et sa liste de sources font foi.
SOCIAL = {"social", "social-network", "social-media", "sm", "social network", "social media"}
EMAIL = {"email", "e-mail", "e_mail", "e mail"}
REFERRAL = {"referral", "app", "link"}
NOT_SET = {"(not set)", "(none)", "(direct)", ""}


def canal(source, medium):
    s, m = source.strip().lower(), medium.strip().lower()
    if s == "(direct)" and m in {"(none)", "(not set)", ""}:
        return "Accès direct"
    if m == "organic":
        return "Recherche naturelle"
    if m in EMAIL:
        return "E-mail"
    if m in REFERRAL:
        return "Site référent"
    if m in SOCIAL:
        return "Réseaux sociaux (recherche naturelle)"
    if m.startswith("affili") or m == "affiliate":
        return "Affiliés"
    if "paid" in m or "cp" in m or "ppc" in m or "retargeting" in m:
        return "Payant (règle générique)"
    return "Non attribué"


def normalise(v):
    """Clé de regroupement : sans casse, espaces, tirets ni underscores (email = e_mail = e-mail)."""
    return re.sub(r"[\s_\-]+", "", v.strip().lower())


def colonne(entetes, cles):
    for c in entetes:
        if c.strip().lower() in cles:
            return c
    return None


def lire(chemin):
    with open(chemin, encoding="utf-8-sig", newline="") as f:
        lecteur = csv.DictReader(f)
        ent = lecteur.fieldnames or []
        col = {k: colonne(ent, v) for k, v in ALIAS.items()}
        lignes = []
        for r in lecteur:
            if col["combi"] and not (col["source"] and col["medium"]):
                s, _, m = r[col["combi"]].partition(" / ")
            else:
                s, m = r[col["source"]], r[col["medium"]]
            c = r[col["campagne"]] if col["campagne"] else ""
            n = float(str(r[col["sessions"]]).replace(" ", "").replace(",", ".") or 0) if col["sessions"] else 1
            lignes.append({"source": s, "medium": m, "campagne": c, "sessions": n})
    return lignes


TYPES = {
    "espaces": "Espaces parasites",
    "majuscules": "Majuscules (valeur non normalisée)",
    "not_set": "(not set) sur medium ou campagne",
    "interne": "UTM sur lien interne",
    "variante": "Variantes d'un même couple",
    "canal": "Medium hors groupes de canaux",
}


def auditer(lignes, domaine_interne):
    anomalies = []
    variantes = defaultdict(set)
    for l in lignes:
        variantes[(normalise(l["source"]), normalise(l["medium"]))].add((l["source"], l["medium"]))

    for l in lignes:
        s, m, c, n = l["source"], l["medium"], l["campagne"], l["sessions"]
        direct = s.strip().lower() == "(direct)"
        motifs = []
        for nom, val in (("source", s), ("medium", m), ("campagne", c)):
            if val != val.strip() or "  " in val:
                motifs.append(("espaces", f"espaces ({nom})"))
            if val != val.lower():
                motifs.append(("majuscules", f"majuscules ({nom})"))
        if not direct and (m.strip().lower() == "(not set)" or c.strip().lower() == "(not set)"):
            motifs.append(("not_set", "(not set) sur medium ou campagne"))
        if domaine_interne and domaine_interne in s.lower():
            motifs.append(("interne", "utm sur lien interne"))
        if len(variantes[(normalise(s), normalise(m))]) > 1:
            motifs.append(("variante", "variantes du même couple"))
        ch = canal(s, m)
        if ch == "Non attribué" and m.strip().lower() not in NOT_SET:
            motifs.append(("canal", "medium hors groupes de canaux"))
        for code, detail in motifs:
            anomalies.append({"type": TYPES[code], "detail": detail, "source": s, "medium": m,
                              "campagne": c, "canal": ch, "sessions": n})
    return anomalies


def main():
    p = argparse.ArgumentParser()
    p.add_argument("csv")
    p.add_argument("--domaine-interne", default="", help="ex. exemple.fr")
    p.add_argument("--sortie", default="anomalies_utm.csv")
    a = p.parse_args()
    lignes = lire(a.csv)
    anomalies = auditer(lignes, a.domaine_interne.lower())
    total = sum(l["sessions"] for l in lignes)
    par = defaultdict(lambda: [0, 0.0])
    for x in anomalies:
        par[x["type"]][0] += 1
        par[x["type"]][1] += x["sessions"]
    print(f"Lignes auditées : {len(lignes)} | sessions : {total:.0f}")
    print("Une ligne peut porter plusieurs anomalies : les totaux se recoupent.")
    print(f"{'Anomalie':<40}{'Lignes':>8}{'Sessions':>12}{'% sessions':>12}")
    for k, (nb, ss) in sorted(par.items(), key=lambda kv: -kv[1][1]):
        print(f"{k:<40}{nb:>8}{ss:>12.0f}{100 * ss / total:>11.1f}%")
    with open(a.sortie, "w", newline="", encoding="utf-8") as f:
        w = csv.DictWriter(f, fieldnames=list(anomalies[0].keys()) if anomalies else ["type"])
        w.writeheader()
        w.writerows(anomalies)
    print(f"Détail écrit dans {a.sortie}")


if __name__ == "__main__":
    main()

Le test ci-dessous utilise un export synthétique de 15 lignes. Les valeurs et les sessions sont inventées pour l’exemple ; elles ne viennent d’aucun site réel.

Session source,Session medium,Session campaign,Sessions
google,cpc,printemps-2026,1200
Google,CPC,printemps-2026,310
linkedin,social,post-ebook,240
LinkedIn,Social,post-ebook,95
newsletter,email,nov-2026,400
newsletter,Email,nov-2026,130
newsletter,e_mail,Nov-2026,40
(direct),(none),(not set),2100
facebook,paid_social,(not set),75
Meta,Paid Social,retargeting,88
exemple.fr,referral,,60
exemple.fr,referral,menu-interne,12
bing,organic,,300
partenaire-blog,newsite,promo,22
 google ,cpc,promo ,15

Commande et résultat :

python audit_utm.py export_synthetique.csv --domaine-interne exemple.fr --sortie anomalies_utm.csv
Lignes auditées : 15 | sessions : 5087
Une ligne peut porter plusieurs anomalies : les totaux se recoupent.
Anomalie                                  Lignes    Sessions  % sessions
Variantes d'un même couple                     8        2430       47.8%
Majuscules (valeur non normalisée)             8        1156       22.7%
(not set) sur medium ou campagne               1          75        1.5%
UTM sur lien interne                           2          72        1.4%
Espaces parasites                              2          30        0.6%
Medium hors groupes de canaux                  1          22        0.4%
Détail écrit dans anomalies_utm.csv

Le lecteur peut contrôler les chiffres à la main. Les 2 430 sessions de variantes couvrent la version correcte et ses variantes : c’est voulu, car le regroupement montre le couple concerné, pas seulement la faute. Le trafic (direct) avec (none) n’est pas signalé, car c’est sa forme normale. Le script ne voit que l’export : une session dont l’UTM a été perdue en route n’apparaît pas comme anomalie, elle se range en direct.

Étape 5 : nettoyer sans réécrire l’historique

La correction durable se fait dans le générateur de liens : tableur partagé, builder interne ou modèle d’annonce. Un même modèle, une casse imposée, des valeurs de référence listées. Sans ce point de contrôle, il faudra refaire l’audit à chaque campagne.

Pour les données déjà collectées, je n’ai pas trouvé de réglage GA4 qui fusionne les variantes passées. La normalisation se fait donc dans la requête ou le tableau de bord : une comparaison sur LOWER(TRIM(source)) dans BigQuery, ou un champ calculé équivalent dans Looker Studio. La requête regroupe les variantes sur tout l’historique, et les rapports GA4 gardent leurs lignes d’origine.

Limites

  • Le script approxime le classement de GA4 : il ne reproduit ni la liste de sources de recherche ni les réseaux sociaux listés par Google.
  • Un export tronqué ou échantillonné fausse les totaux ; comparez toujours le total de sessions.
  • Les visites refusées au consentement n’apparaissent pas dans l’export ; un écart avec les plateformes peut venir de là.
  • Les anomalies se recoupent : n’additionnez pas les lignes du résumé pour obtenir un total.

FAQ

Faut-il des minuscules si GA4 regroupe quand même les canaux ? Oui. Le regroupement tolère la casse, mais les rapports sources et supports, les exports et vos comparaisons ne la tolèrent pas. Une valeur en minuscules partout ne coûte rien et évite les doublons.

Peut-on corriger les valeurs déjà enregistrées dans GA4 ? Pas dans le rapport. Corrigez le générateur de liens pour le futur, et normalisez la lecture de l’historique dans la requête ou le tableau de bord.

Quelle est la différence avec le contrôle du (not set) ? Le (not set) est une absence de valeur, souvent liée à une dimension personnalisée ou au scope. Le guide pour résoudre le (not set) dans GA4 traite ces causes. L’audit UTM, lui, traite les valeurs que vous avez vous-même envoyées.

Pour aller plus loin

Sources

Ron Kopelman

Besoin d'aide sur ce sujet ?

Je peux vous accompagner sur la mise en place ou l'optimisation de votre tracking.