Guide gratuit

Intégrer le suivi des conversions Google Ads Shopify via Customer Events – 2025

Le suivi des conversions est la pierre angulaire de toute stratégie Google Ads performante. Sur Shopify, il permet de remonter automatiquement les ventes réalisées après un clic sur une annonce, afin d’évaluer précisément le retour sur investissement publicitaire.

9 min de lecture
7 chapitres
Aucun email demandé

1. Comprendre le suivi des conversions Google Ads sur Shopify (sans GTM)

Profiter en bonus du suivi avancé des conversions (enhanced conversions)

Depuis les restrictions imposées par les navigateurs (ITP de Safari, blocages iOS 14+, fin des cookies tiers), la fiabilité du tracking standard a fortement diminué. Résultat : moins de conversions attribuées, des campagnes faussement sous-performantes… et un algorithme publicitaire qui s’optimise mal.

C’est là qu’intervient une version plus robuste du suivi : la transmission directe d’informations issues du checkout Shopify vers Google Ads, comme l’email ou le numéro de téléphone du client, de manière sécurisée et anonyme.

🔐 Ces données sont automatiquement hachées via l’algorithme SHA-256 avant d’être transmises, ce qui garantit leur protection. Google ne reçoit jamais d’email en clair.

🧾 Exemple de données transmises :

Adresse email du client (hachée)
Numéro de téléphone (haché)
Prénom / nom (hachés)
Adresse postale (hachée)

Google peut ensuite recouper ces données avec les utilisateurs connectés à leur compte Gmail ou Android, et attribuer correctement la conversion au clic publicitaire initial, même si l’achat a lieu plusieurs jours plus tard.

2. Pré-requis avant d’implémenter le suivi des conversions Google Ads sur Shopify (sans GTM)

Avant de plonger dans l’intégration du script de tracking, il est essentiel de vérifier que tous les éléments nécessaires sont bien en place. Voici la checklist technique complète.

2.1 Avoir une conversion Google Ads active

Tu dois disposer d’une conversion “Achat” (Purchase) déjà configurée dans Google Ads. Elle servira à capter les commandes Shopify déclenchées suite à un clic publicitaire.

🧭 Si tu n’en as pas encore :
Va dans Outils > Objectifs > Conversions, clique sur Nouvelle conversion, choisis Site web, puis configure un événement de type achat / transaction.

2.2 Activer le paramètre “Conversions enrichies” dans Google Ads

Va dans Objectifs > Conversions > Résumé
Clique sur la ligne correspondant à ta conversion “Achat”
Dans l’onglet Paramètres, active la section “Conversions enrichies”
Choisis la méthode “Tag Google ou Google Tag Manager”
Enregistre

💡 Même si on n’utilise pas GTM, cette option doit être cochée pour permettre l’envoi d’informations clients via le script manuel.

2.3 Avoir accès aux “Customer Events” sur Shopify

Depuis 2023, Shopify permet l’injection directe de code JavaScript via les Custom Pixels, dans :

⚠️ Cette méthode ne fonctionne que pour les boutiques utilisant le checkout Shopify natif (pas de checkout OnePage custom ni checkout.liquid).

2.4 Identifier ton ID de conversion Google Ads

Va dans Google Ads

Menu de gauche : Objectifs > Conversions
Clique sur ta ligne de conversion (par exemple “Achat site web”)
Dans Paramètres > Configuration du tag, clique sur “Utiliser la balise Google”
Tu verras :
- Ton ID de conversion (ex : AW-1234567890)
- Ton Label de conversion (ex : kLMnOpQRsTUvWXyZ)

2.5 (Optionnel) Gérer le consentement utilisateur (RGPD)

Si ton site cible l’Europe, tu dois intégrer le tracking dans une logique de consentement (bandeau cookies).

Shopify propose une gestion native du consentement via :

Customer Privacy API
CMP tiers comme Cookiebot, Axeptio ou CookieYes

Le script que tu vas insérer plus tard devra être compatible avec le Consent Mode de Google, pour respecter les préférences de l’utilisateur.

Je t’invite à lire mon guide sur la mise en place du Consent Mode via Shopify en 2025 et à revenir sur cette page par la suite pour la partie événements 🔥

3. Méthode d’intégration sans GTM – Via la balise Google `gtag.`

3.1 Installation de la balise Google sur Shopify

Tu peux l’ajouter manuellement dans Shopify via les paramètres suivants :

Ajouter la balise dans les “Customer Events” :

Va dans Paramètres > Événements client
Clique sur Ajouter un pixel personnalisé
Dans le champ “Code”, ajoute ce snippet :

// === CONFIGURATION PERSONNALISABLE ===
const CONFIG = {
  conversionId:      'AW-XXXXXXXXX',
  merchantId:        'XXXXXXXXX',
  feedCountry:       'FR',
  feedLanguage:      'fr',
  productIdFormat:   null,              // 'sku' | 'variant_id' | 'id' | null = shopify_FR_pid_vid
  prefixProductId:   'shopify_FR_',
  businessVertical:  'retail',
  sendPageView:      true,
  valueOption:       null,              // 'net' | 'no_shipping' | 'no_tax' | null = TTC
  debug:             true,
  conversions: {
  // events remarketing dynamique pures (pas de label) à indiquer
  // view_cart:        'undefined',
  // view_item:        'undefined',
  // add_to_cart:      'undefined',
  begin_checkout:   'exempleindiquerlabelici', // Conversion “début tunnel”
  add_shipping_info:'exempleindiquerlabelici', // Conversion “infos livraison”
  purchase:         'exempleindiquerlabelici' // Conversion “achat”
  }
};

// === INITIALISATION GTAG ===
(function loadGtag(){
  const s = document.createElement('script');
  s.async = true;
  s.src = 'https://www.googletagmanager.com/gtag/js?id=' + CONFIG.conversionId;
  document.head.appendChild(s);
  window.dataLayer = window.dataLayer || [];
  function gtag(){ dataLayer.push(arguments); }
  window.gtag = gtag;

  gtag('js', new Date());
  gtag('config', CONFIG.conversionId, {
    send_page_view:            CONFIG.sendPageView,
    allow_enhanced_conversions: true
  });
  if (CONFIG.debug) console.log('[GAds] gtag initialized');
})();

🔁 Si tu mets en place le Consent Mode en suivant mon guide orienté GTM et non Google Ads pur, tu as simplement à remplacer le script de GTM (fonction loadGTM) par celui-ci (fonction loadGTag)

💡 Important : l’objectif ici est que Shopify charge correctement gtag.js sur l’ensemble des pages du site dont pages de checkout et surtout sur la page de remerciement (/thank_you), là où le suivi de conversion sera déclenché.

3.2 Structure du script de suivi des conversions Google Ads (gtag.js)

L’implémentation repose sur un script JavaScript injecté dans Shopify via les Custom Pixels. Ce script fait plusieurs choses :

Charge la librairie gtag.js
Récupère les données client (email, téléphone, adresse…)
Met à disposition les données non anonymisées et anonymisées (hachage SHA-256) – à vous de voir ce que vous souhaitez envoyer à Google Ads
Déclenche un événement conversion vers Google Ads

🔐 Protection des données : hashing des champs sensibles

Les données personnelles sont aux deux formats : hachées et non hachées via un hachage SHA-256 – à vous de voir ce que vous souhaitez envoyer à Google Ads, exemple :

const hashValue = async value => {
  if (!value || !window.crypto) return null;
  const enc = new TextEncoder().encode(value);
  const hash = await crypto.subtle.digest('SHA-256', enc);
  return Array.from(new Uint8Array(hash)).map(b => b.toString(16).padStart(2,'0')).join('');
};

Pour rappel la documentation officielle de Google demande de lui fournir les données non hachées pour un bon fonctionnement du suivi avancé des conversions.

Variables à configurer dans le script

Voici les éléments que tu devras adapter manuellement à ton projet :

Variable	Explication
`CONFIG.conversionId`	Ton ID de conversion Google Ads → exemple : `"AW-1234567890"`
`CONFIG.conversions.purchase`	Label de conversion pour l’événement purchase → exemple : `"AbCdEfGhIjk"`
`CONFIG.feedCountry`	Code pays ISO lié à ton flux Merchant Center (ex : `"FR"`, `"US"`, `"DE"`)
`CONFIG.productIdFormat`	Format des ID produit (`"sku"`, `"variant_id"`, `"id"`, ou `null` pour format Shopify)
`CONFIG.user_data`	`"email"` pour un suivi minimal, `"all"` pour l’ensemble des données client
`CONFIG.valueOption`	Méthode de calcul du montant envoyé à Google (`"net"`, `"no_shipping"`, `"no_tax"`, ou `null` pour TTC)
`CONFIG.prefixProductId`	Préfixe à ajouter si `productIdFormat = null` (ex : `"shopify_FR_"`)
`CONFIG.businessVertical`	Verticale métier pour Google Ads, généralement `"retail"`
`CONFIG.sendPageView`	`true` pour envoyer un `page_view` à chaque chargement de page
`CONFIG.debug`	`true` pour activer les logs dans la console

💡 À toi de définir précisément ce que tu veux envoyer à Google Ads :

Si tu veux du remarketing basique : conversionId + view_item + add_to_cart suffisent.
Si tu veux le tracking complet avec conversions + enhanced conversions : configure bien user_data, valueOption, et les labels de chaque événement.

3.3 Adapter le script à ton catalogue Shopify et au format attendu par Google Ads

L’identification correcte des produits est cruciale pour la performance de ton suivi : Google doit pouvoir faire correspondre les produits achetés à ceux de ton flux Merchant Center. Pour cela, tu dois configurer deux variables clés dans le script :

feedCountry – Région de ton flux Google Shopping

Cette variable représente le code pays utilisé par le flux Merchant Center :

Exemple de valeur	Pays
`"FR"`	France
`"US"`	États-Unis
`"DE"`	Allemagne

Tu peux le retrouver dans Google Ads > Produits > Vue d’ensemble. Si l’item ID commence par shopify_FR_..., utilise "FR" ici.

productIdFormat – Format de l’identifiant produit

C’est la clé qui permet d’associer ce que le client achète avec ce que tu annonces sur Google Shopping. Choisis le format qui correspond à ton flux :

Valeur	Description
`"product_id"`	ID du produit Shopify
`"variant_id"`	ID de la variante (ex. taille/couleur)
`"product_sku"`	SKU si tu l’as défini dans Shopify
`null`	Format Shopify standard → `shopify_{region}_{product_id}_{variant_id}`

📌 Tu peux consulter tes Item IDs dans Merchant Center > Produits > Onglet ID de l’article.

Exemple d’adaptation dans le script

CONFIG.feedCountry = 'FR'; // ← adapte à ton pays
CONFIG.productIdFormat = null; // ← laisse null si tu utilises le format "shopify_FR_123456_987654"

Le script construira alors l’ID final comme suit :

shopify_FR_123456_987654

Ce qui matchera parfaitement avec ton flux si tu utilises l’application Shopify Google & YouTube pour alimenter Merchant Center.

🎯 Objectif final : quand une conversion est remontée, Google Ads sait exactement quels produits ont été achetés, et peut les relier à ta campagne Shopping.

3.5 Intégrer et activer le script dans Shopify (Custom Pixel)

Étape 1 – Aller dans les paramètres Shopify

Connecte-toi à ton admin Shopify
Va dans Paramètres > Événements client (Customer Events)
Clique sur l’événement personnalisé gérant le Consent Mode si tu as suivis mon guide sur le sujet. Si le Consent Mode ne t’est pas utile utilise le pixel chargeant Google Ads (fonction loadGTag ci-dessus).

Étape 2 – Configuration du Pixel

Nom du pixel : Google Ads Conversion - Purchase (ou laisser le nom si il s’agit du pixel lié au consent mode)
Type de script : JavaScript
Code du pixel : colle le script complet suivant à la suite de notre pixel de gestion du consentement (si tu l’utilises) en retirant les parties === CONFIGURATION PERSONNALISABLE === et === INITIALISATION GTAG ===

Étape 3 – Script complet tracking Google Ads des conversions Shopify


// Google Ads Tracking + Remarketing + Enhanced Conversions pour Shopify

// === CONFIGURATION PERSONNALISABLE ===
const CONFIG = {
  conversionId:      'AW-XXXXXXXXX',
  merchantId:        'XXXXXXXXX',
  feedCountry:       'FR',
  feedLanguage:      'fr',
  productIdFormat:   null,              // 'sku' | 'variant_id' | 'id' | null = shopify_FR_pid_vid
  prefixProductId:   'shopify_FR_',
  businessVertical:  'retail',
  sendPageView:      true,
  valueOption:       null,              // 'net' | 'no_shipping' | 'no_tax' | null = TTC
  debug:             true,
  conversions: {
  // events remarketing dynamique pures (pas de label) à indiquer
  // view_cart:        'undefined',
  // view_item:        'undefined',
  // add_to_cart:      'undefined',
  begin_checkout:   'exempleindiquerlabelici', // Conversion “début tunnel”
  add_shipping_info:'exempleindiquerlabelici', // Conversion “infos livraison”
  purchase:         'exempleindiquerlabelici' // Conversion “achat”
  }
};

// === INITIALISATION GTAG ===
(function loadGtag(){
  const s = document.createElement('script');
  s.async = true;
  s.src = 'https://www.googletagmanager.com/gtag/js?id=' + CONFIG.conversionId;
  document.head.appendChild(s);
  window.dataLayer = window.dataLayer || [];
  function gtag(){ dataLayer.push(arguments); }
  window.gtag = gtag;

  gtag('js', new Date());
  gtag('config', CONFIG.conversionId, {
    send_page_view:            CONFIG.sendPageView,
    allow_enhanced_conversions: true
  });
  if (CONFIG.debug) console.log('[GAds] gtag initialized');
})();

// === UTILITAIRES ===
const hashValue = async value => {
  if (!value || !window.crypto) return null;
  const enc  = new TextEncoder().encode(value);
  const hash = await crypto.subtle.digest('SHA-256', enc);
  return Array.from(new Uint8Array(hash))
    .map(b => b.toString(16).padStart(2,'0')).join('');
};

const formatItemId = variant => {
  if (!variant) return null;
  switch (CONFIG.productIdFormat) {
    case 'sku':        return variant.sku;
    case 'variant_id': return variant.id;
    case 'id':         return variant.product?.id;
    default:           return `${CONFIG.prefixProductId}${variant.product?.id}_${variant.id}`;
  }
};

// Envoi remarketing (sans label) 
const trackRemarketing = (eventName, data) => {
  gtag('event', eventName, {
    send_to: CONFIG.conversionId,
    google_business_vertical: CONFIG.businessVertical,
    ...data
  });
  if (CONFIG.debug) console.log(`[GAds] Remarketing: ${eventName}`, data);
};

// Envoi conversion si label défini
const trackConversion = (eventKey, data) => {
  const label = CONFIG.conversions[eventKey];
  if (!label) return;
  gtag('event','conversion',{
    send_to: `${CONFIG.conversionId}/${label}`,
    google_business_vertical: CONFIG.businessVertical,
    ...data
  });
  if (CONFIG.debug) console.log(`[GAds] Conversion: ${eventKey}`, data);
};

// Utilitaire combiné
const trackDual = (eventKey, remarketingName, data) => {
  trackRemarketing(remarketingName, data);
  trackConversion(eventKey, data);
};

// === ÉCOUTE DES ÉVÉNEMENTS SHOPIFY ===

// 1. Vue produit
analytics.subscribe('product_viewed', e => {
  const id = formatItemId(e.data.productVariant);
  if (!id) return;
  const payload = {
    items: [{ id }],
    value: e.data.productVariant?.price?.amount
  };
  trackDual('view_item','view_item', payload);
});

// 2. Vue collection
analytics.subscribe('collection_viewed', e => {
  const c = e.data.collection;
  const payload = {
    collection_id: c?.id,
    collection_title: c?.title
  };
  trackDual('view_item_list','view_item_list', payload);
});

// 3. Résultats de recherche
analytics.subscribe('search_submitted', e => {
  const payload = { query: e.data?.searchResult?.query || '' };
  trackDual('view_search_results','view_search_results', payload);
});

// 4. Ajout au panier
analytics.subscribe('product_added_to_cart', e => {
  const id = formatItemId(e.data.cartLine?.merchandise);
  if (!id) return;
  const payload = {
    items: [{ id }],
    value: e.data.cartLine?.merchandise?.price?.amount
  };
  trackDual('add_to_cart','add_to_cart', payload);
});

// 5. Vue du panier
analytics.subscribe('cart_viewed', e => {
  const items = (e.data.cart?.lines || []).map(l => ({
    id:       formatItemId(l.merchandise),
    quantity: l.quantity,
    price:    l.merchandise?.price?.amount
  }));
  trackDual('view_cart','view_cart', { items });
});

// 6. Début de tunnel (clic Checkout)
analytics.subscribe('checkout_started', e => {
  const items = (e.data.checkout?.lineItems || []).map(li => ({
    id:       formatItemId(li.variant),
    quantity: li.quantity,
    price:    li.variant?.price?.amount
  }));
  trackDual('begin_checkout','begin_checkout', { items });
});

// 7. Infos de livraison
analytics.subscribe('checkout_shipping_info_submitted', e => {
  const items = (e.data.checkout?.lineItems || []).map(li => ({
    id:       formatItemId(li.variant),
    quantity: li.quantity,
    price:    li.variant?.price?.amount
  }));
  trackDual('add_shipping_info','add_shipping_info', { items });
});

// 8. Achat final
analytics.subscribe('checkout_completed', async e => {
  const c = e.data.checkout;
  const items = c.lineItems.map(li => ({
    id:       formatItemId(li.variant),
    quantity: li.quantity,
    price:    li.variant?.price?.amount
  }));

  // Discount
  let totalDiscount = 0;
  (c.lineItems || []).forEach(li => {
    (li.discountAllocations || []).forEach(d => {
      const amt = parseFloat(d?.amount?.amount);
      if (!isNaN(amt)) totalDiscount += amt;
    });
  });
  totalDiscount = totalDiscount.toFixed(2);

  // User data
  const userData = {
    email:                c.email,
    sha256_email_address: await hashValue(c.email),
    phone_number:         c.phone,
    sha256_phone_number:  await hashValue(c.phone),
    address: {
      first_name:         c.shippingAddress?.firstName,
      sha256_first_name:  await hashValue(c.shippingAddress?.firstName),
      last_name:          c.shippingAddress?.lastName,
      sha256_last_name:   await hashValue(c.shippingAddress?.lastName),
      street:             await hashValue(`${c.shippingAddress?.address1} ${c.shippingAddress?.address2}`),
      city:               c.shippingAddress?.city,
      postal_code:        c.shippingAddress?.zip,
      country:            c.shippingAddress?.countryCode
    }
  };
  gtag('set','user_data', userData);

  const total = (() => {
    const t  = c.totalPrice?.amount || 0,
          s  = c.subtotalPrice?.amount || 0,
          sh = c.shippingLine?.price?.amount || 0,
          tx = c.totalTax?.amount || 0;
    switch (CONFIG.valueOption) {
      case 'net':         return s;
      case 'no_shipping': return s + tx;
      case 'no_tax':      return s + sh;
      default:            return t;
    }
  })();

  trackDual('purchase','purchase',{
    transaction_id:    c.order?.id || c.token,
    value:             total,
    currency:          c.currencyCode,
    discount:          parseFloat(totalDiscount),
    aw_merchant_id:    CONFIG.merchantId,
    aw_feed_country:   CONFIG.feedCountry,
    aw_feed_language:  CONFIG.feedLanguage,
    items
  });
});

Étape 4 – Tester l’implémentation

Active l’option debug.status = true dans ton script (partie const debug = {}).
Fais un test d’achat avec une commande fictive (réelle mais avec un produit gratuit, si besoin).
Ouvre l’onglet Console de ton navigateur et observe :
- les logs gtag initialized
- les user_data générés
- l’événement conversion envoyé avec send_to: AW-XXXXXXX/Label

Étape 5 – Suivi dans Google Ads

Dans Google Ads > Outils > Conversions :

Vérifie que des conversions commencent à s’enregistrer sous quelques jours
Tu peux aussi consulter le statut du tag dans la colonne “État du tag”
Le délai habituel est de 12 h pour une première conversion

4. Utilisation de Google Tag Manager (optionnel)

🔒 Remarque importante : Ce guide est conçu pour une intégration sans Google Tag Manager (GTM). Si vous utilisez GTM, la logique d’implémentation change entièrement.

Pourquoi utiliser GTM ?

Google Tag Manager permet de centraliser la gestion de tous vos tags marketing, pixels de suivi, événements e-commerce, règles de déclenchement et variables personnalisées. C’est particulièrement utile pour les sites à forte volumétrie ou nécessitant beaucoup d’A/B tests, de scripts tiers ou de coordination entre équipes.

Documentation utile :

Support Google Ads Enhanced Conversions (GTM)
Exemple GTM + Shopify via Analyzify