4/11/2026
Vous durcissez la sécurité de votre site et Google Tag Manager affiche des erreurs « blocked » dans la console ? Cette page s’adresse aux équipes marketing, SEO et techniques qui doivent faire cohabiter une Content Security Policy (CSP) pour Google Tag Manager et une mesure GA4 fiable.
Elle vous aide à choisir les directives à ouvrir, la stratégie (allowlist, nonce ou hash) et la séquence de déploiement sans rupture de collecte. Le consentement et les cookies relèvent d’un guide dédié.
Configurer une Content Security Policy (CSP) pour Google Tag Manager sans casser la mesure ni la sécurité web
Une CSP force le navigateur à n’exécuter et ne charger que des ressources explicitement autorisées : elle bloque ainsi le JavaScript inline injecté et les scripts venus de domaines non listés, typiques d’une attaque XSS. Pour les bases, voyez notre guide Google Tag Manager ; pour les scripts du conteneur, l’article sur les scripts et balises GTM.
Le conflit vient de la conception de GTM : un chargeur (gtm.js) injecte ensuite d’autres scripts. Sous une politique stricte, le navigateur refuse le chargement (« Refused to load the script because it violates the Content Security Policy ») si les sources ne sont pas autorisées ou si l’inline n’est pas géré par nonce ou hash.
Trois décisions structurent le travail :
- Les directives : lesquelles ouvrir, et pour quels domaines réellement appelés.
- La stratégie pour l’inline : allowlist de domaines, nonce avec
'strict-dynamic', ou hash. - La séquence de déploiement : observation en Report-Only, puis bascule en mode bloquant.
Comprendre le conflit entre CSP et GTM : mécanismes, risques et surface d’attaque
Avant d’écrire une règle, sachez ce que la CSP protège et ce que GTM charge.
Définition : Content Security Policy (CSP), objectifs, limites et rôles côté navigateur
La CSP est une couche de sécurité appliquée par le navigateur, définie via l’en-tête HTTP Content-Security-Policy (plus rarement via une balise <meta http-equiv="Content-Security-Policy">). Elle restreint les origines autorisées pour les scripts, images, styles, connexions et iframes. Elle ne corrige pas une vulnérabilité : elle limite l’effet d’une injection réussie.
Comment le script de Google Tag Manager se charge et ce que le conteneur appelle réellement
L’intégration démarre par un snippet inline qui initialise le dataLayer et charge gtm.js depuis un domaine Google. Une fois chargé, GTM peut :
- injecter d’autres scripts (mesure, publicité) selon les balises publiées ;
- déclencher des requêtes réseau vers des points de collecte ;
- charger des pixels (images) ou des iframes, notamment pour la prévisualisation et le débogage.
Cette combinaison « inline + chargement distant + injection dynamique » provoque les violations. Cartographiez donc ce que le conteneur consomme :
- Scripts : le chargeur (
www.googletagmanager.com), puis les domaines de chaque balise déclenchée. - Connexions réseau : points de collecte (
*.googletagmanager.com,www.google-analytics.com,*.analytics.google.com). - Images : pixels et beacons des sous-domaines GTM et GA4, ou d’autres fournisseurs.
Autoriser GTM ne couvre pas les balises tierces qu’il charge : chaque balise ajoutée peut nécessiter une évolution de la politique.
Paramétrage côté Google Tag Manager : settings de déploiement et boucle d’itération avant durcissement
Le durcissement se fait par itérations courtes : observer, corriger, puis bloquer.
Commencer en Report-Only et lire les rapports de violation
Démarrez avec Content-Security-Policy-Report-Only : le navigateur signale les violations sans les bloquer. Une fois les directives stabilisées, basculez sur Content-Security-Policy. Trois sources guident le diagnostic :
- la console du navigateur, avec les messages « Refused to load… » et la directive en cause ;
- les rapports CSP, si un point de reporting agrège les erreurs sur tout le trafic ;
- la ligne d’erreur elle-même, qui cite
script-src,connect-src,img-srcouframe-src.
Check-list préprod : environnements, mode aperçu et impacts sur le débogage
Avant de toucher à l’en-tête, stabilisez le conteneur puis validez en préproduction :
- Inventoriez les balises actives, les balises « HTML personnalisé » et les variables « JavaScript personnalisé ».
- Testez sur une préproduction qui reproduit exactement les en-têtes finaux servis en production, CSP comprise.
- Vérifiez la prévisualisation (Tag Assistant) : panneau absent, styles manquants, erreurs CSP en console.
- Contrôlez les parcours critiques (atterrissage, formulaire, paiement), où la mesure est la plus sensible.
Règles CSP minimales pour que Tag Manager fonctionne : rules, directives et arbitrages
Le tableau suivant résume ce que chaque directive doit autoriser pour GTM et le risque d’une ouverture trop large.
| Directive | Ce qu’elle autorise pour GTM, GA4, Ads, prévisualisation | Risque si trop large |
|---|---|---|
script-src | Chargeur gtm.js, snippet inline noncé, scripts des balises | 'unsafe-inline' annule la protection XSS |
connect-src | Requêtes GA4, GTM, Google Ads et DoubleClick | Un joker * laisse sortir des données partout |
img-src | Pixels et beacons GA4, Ads, images de prévisualisation | data: ou joker élargissent la surface |
frame-src | Iframes Google, dont le <noscript> du conteneur | Contenus tiers encadrés sans contrôle |
font-src | Polices de la prévisualisation (fonts.gstatic.com) | Faible, mais domaines inutiles en production |
style-src | Styles du panneau de prévisualisation (fonts.googleapis.com) | 'unsafe-inline' permanent permet l’injection de styles |
script-src : autoriser le chargeur, cadrer l’inline script policy et éviter les ouvertures inutiles
Pour GTM, script-src est la directive la plus critique : elle couvre le chargeur et l’inline. Un minimum comme script-src 'nonce-{nonce}'; se complète selon les domaines réellement nécessaires ; ajouter un domaine ne suffit pas si le snippet inline n’est pas autorisé.
Quand « allow » impose un nonce. Le cas le plus robuste combine un nonce (valeur aléatoire par réponse HTTP) et 'strict-dynamic' : script-src 'nonce-{nonce}' 'strict-dynamic';. Les scripts chargés par un script approuvé héritent de sa confiance, sans liste de hash à maintenir.
unsafe-inline et unsafe-eval. Ces deux options, à n’ajouter qu’en dernier recours, relâchent fortement la politique :
'unsafe-inline'autorise tout JavaScript inline, exactement ce qu’une CSP cherche à empêcher.'unsafe-eval'autorise l’évaluation de chaînes (eval(),new Function) ; GTM le requiert dès que vous utilisez des variables « JavaScript personnalisé ».- Les balises « HTML personnalisé » ne relèvent pas de
'unsafe-eval': elles se traitent par le nonce.
connect-src et img-src : appels réseau, pixels et beacons sans sur-autoriser
connect-src contrôle les requêtes réseau JavaScript (fetch, XHR, beacons) ; img-src couvre les pixels, qui partent comme des requêtes d’image. Les domaines à autoriser dépendent des balises publiées :
- GTM :
*.googletagmanager.com, enconnect-srcetimg-src. - GA4 :
*.google-analytics.comet*.analytics.google.com, dans les deux directives. - Google Ads : les domaines Ads et DoubleClick signalés par la console, dans les deux directives.
N’élargissez qu’après avoir observé les appels réels en Report-Only. Le schéma data: en img-src est parfois demandé, mais il élargit la surface : décidez à partir des violations constatées.
frame-src, font-src et style-src : les domaines de la prévisualisation
Si la production fonctionne mais que le panneau de prévisualisation reste vide ou sans mise en forme, il manque presque toujours les domaines de Tag Assistant. À la date de rédaction :
fonts.googleapis.com, enstyle-src;fonts.gstatic.com, enfont-src;www.gstatic.com, enimg-src.
Le panneau dépend aussi de styles inline : réservez 'unsafe-inline' en style-src aux environnements de débogage si possible. frame-src doit couvrir les iframes Google que vos flux utilisent.
Trois approches pour autoriser GTM avec une CSP stricte : domaines, nonce et hash
Le choix dépend de la fréquence d’évolution du conteneur et de votre capacité à générer une valeur côté serveur :
| Approche | Quand la choisir | Limite |
|---|---|---|
| Allowlist de domaines | Démarrage rapide, conteneur stable | Fragile dès que de nouvelles balises apparaissent |
Nonce + 'strict-dynamic' | Conteneur qui évolue, rendu côté serveur | Nonce à générer à chaque réponse HTTP |
| Hash | Snippet inline figé, pages statiques | À recalculer à la moindre modification |
| Report-Only | Avant chaque durcissement | Signale sans protéger |
Approche 1 : démarrer vite avec une liste de domaines autorisés (allow) sans bloquer le chargement
La stratégie la plus simple autorise les domaines GTM, par exemple script-src 'self' https://www.googletagmanager.com;, complétés au besoin par *.googletagmanager.com. Rapide, elle devient fragile si le conteneur évolue souvent.
Approche 2 : nonce côté serveur pour une politique stricte avec chargement dynamique
Le nonce est l’option la plus durable face à l’injection dynamique. Trois étapes :
- générez un nonce côté serveur, un par chargement de page ;
- déclarez-le dans l’en-tête (
script-src 'nonce-…') ; - ajoutez l’attribut
nonce="…"sur le snippet inline GTM.
Google fournit une version du snippet compatible nonce, qui transmet le nonce au script gtm.js qu’elle charge. La valeur doit être identique dans l’en-tête et dans la balise script.
Pour les balises « HTML personnalisé », transmettez le nonce (par exemple via une variable exposée par l’application) et n’autorisez que ce qui est noncé, plutôt que d’ouvrir 'unsafe-inline'. Évitez les contournements qui « réparent » GTM en dégradant la sécurité.
Approche 3 : hash pour autoriser un snippet inline figé (et comprendre quand cela casse)
Le hash autorise un contenu inline précis via sha256-… (ou sha384, sha512) dans script-src, sans nonce à générer. Mais dès que le snippet change, même d’un espace, le hash doit être recalculé et redéployé : plus de maintenance que le nonce.
Exemples d’en-tête : construire un header CSP lisible et inclure « allow googletagmanager » sans sur-autoriser
Une structure lisible (base stricte, exceptions nécessaires, puis durcissement) évite les erreurs de syntaxe. Exemple, une directive par ligne, à adapter :
Content-Security-Policy:
default-src 'self';
script-src 'nonce-{nonce}' 'strict-dynamic';
connect-src https://*.googletagmanager.com https://*.google-analytics.com https://*.analytics.google.com;
img-src https://*.googletagmanager.com https://*.google-analytics.com https://www.gstatic.com;
frame-src https://*.google.com;
style-src 'self' 'unsafe-inline' https://fonts.googleapis.com;
font-src https://fonts.gstatic.com;
Dans l’en-tête réel, ces lignes forment une seule valeur.
Déployer à un seul endroit et vérifier que l’en-tête est bien actif
Définissez la CSP à un seul endroit, source de vérité, pour éviter en-têtes dupliqués et règles incohérentes ; versionnez les variantes par environnement. Vérifiez ensuite qu’elle est servie :
- dans le navigateur, onglet Réseau, en-tête de réponse
Content-Security-Policy; - en ligne de commande, avec
curl -I https://votre-domaine.tld/page; - en recette fonctionnelle, sur les parcours de conversion où partent les balises sensibles.
Résoudre rapidement l’erreur « blocked » liée à la CSP : méthode de diagnostic
Commencez par la console : l’erreur cite la directive et l’URL bloquée. C’est votre point de départ, pas une hypothèse ; autorisez ensuite l’origine minimale, en Report-Only d’abord.
Cas fréquents : prévisualisation, tags tiers, HTML personnalisé, redirections et iFrame
La plupart des erreurs se rattachent à quelques situations récurrentes :
| Symptôme | Directive en cause | Correctif |
|---|---|---|
| Prévisualisation absente ou sans styles | style-src, font-src, img-src | Ajouter les trois domaines de prévisualisation |
| Requêtes GA4 absentes de DebugView | connect-src | Ajouter *.google-analytics.com et *.analytics.google.com |
| Pixel tiers récent refusé | img-src, connect-src | Autoriser l’origine exacte observée |
| Variable JavaScript personnalisée en erreur | script-src ('unsafe-eval') | Remplacer la variable ou assumer l’option |
| Balise HTML personnalisé bloquée | script-src (inline) | Transmettre le nonce à la balise |
| Iframe Google vide | frame-src | Autoriser le domaine Google concerné |
Lisez toujours l’URL citée par la console, pas celle que vous attendiez.
Quand le consentement et le mode Consentement changent le comportement de chargement des scripts
Certaines balises ne partent qu’après acceptation : des violations n’apparaissent que dans ce scénario. Testez chaque cas :
- refus de tous les traceurs, où seules les ressources nécessaires se chargent ;
- acceptation partielle (mesure seule, par exemple) ;
- acceptation totale, qui charge l’ensemble des balises publiées.
Durcir au-delà de la CSP : gouvernance GTM, Trusted Types et prévention des injections
GTM centralise la capacité d’injecter du code. Sans gouvernance (droits, revue, préproduction, versions), une balise peut élargir la CSP « en urgence ». Si chaque changement marketing réclame 'unsafe-inline', le problème est organisationnel autant que technique.
Une CSP stricte implique une discipline de maintenance :
- revue régulière des balises et des droits de publication ;
- documentation des ressources externes appelées par le conteneur, directive par directive ;
- tests systématiques après chaque publication de version, avec le reporting CSP actif en continu.
Trusted Types : réduire les sinks DOM à risque et compléter la CSP sur les applications modernes
Trusted Types complète la CSP en réduisant l’exposition aux injections DOM XSS sur certains « sinks » comme innerHTML. Sur les applications fortement dynamiques, il ajoute une barrière en plus de script-src, sans remplacer la CSP.
Quand la CSP révèle un problème plus large : quoi auditer côté technique
Quand les violations se multiplient, le problème dépasse souvent GTM. Symptômes typiques :
- deux implémentations concurrentes de GTM (script en dur et module) ;
- balises ajoutées sans documentation, qui appellent des domaines inconnus ;
- dépendances chargées différemment selon les gabarits ;
- en-têtes différents entre préproduction et production.
Remettez la chaîne à plat plutôt que d’empiler les exceptions, et durcissez gabarit par gabarit, pages à fort enjeu d’abord.
Selon votre situation
Selon l’endroit où vous en êtes, l’article utile n’est pas le même :
- Vous placez le snippet noncé : vérifiez son emplacement dans le guide pour installer Google Tag Manager.
- Vos variables imposent
'unsafe-eval': identifiez celles à remplacer avec notre guide des variables GTM. - Vous publiez une nouvelle version du conteneur : avant de basculer la CSP en mode bloquant, déroulez la procédure pour tester Google Tag Manager sur la version à publier.
- Vos violations dépendent du consentement : réglez la chaîne CMP dans l’article sur les cookies et le consentement dans GTM.
Avant et après la bascule en mode bloquant, un audit avec le module audit GEO et SEO 360 d’Incremys vous aide à repérer, gabarit par gabarit, les pages dont la santé technique s’est dégradée.
FAQ : CSP et Google Tag Manager
GTM est-il compatible avec une Content Security Policy stricte ?
Oui, à condition de gérer l’inline par nonce ou hash plutôt que par une simple allowlist. Une CSP stricte fonctionne avec GTM si vous autorisez aussi les appels réseau (connect-src) et les pixels (img-src) réellement utilisés. La combinaison nonce et 'strict-dynamic' est la plus robuste face au chargement dynamique des balises.
Quelles rules CSP ajuster en priorité (script-src, connect-src, img-src) ?
Ajustez d’abord script-src, qui conditionne le chargement de GTM et de son snippet inline. Traitez ensuite connect-src pour les requêtes de collecte, puis img-src pour les pixels. Complétez enfin frame-src, font-src et style-src si des iframes Google ou la prévisualisation sont bloquées.
Quelles erreurs surviennent si « allow googletagmanager » reste incomplet ?
La console affiche des messages « Refused to load… » qui citent la directive fautive. Un script-src incomplet bloque le chargeur, un connect-src incomplet bloque les requêtes de mesure, un img-src incomplet refuse les pixels. Autoriser www.googletagmanager.com sans ses sous-domaines laisse souvent des blocages résiduels.
Quel nonce utiliser avec GTM (nonce GTM), et où l’injecter exactement ?
Utilisez un nonce aléatoire généré côté serveur, unique à chaque chargement de page. Injectez-le dans l’en-tête (script-src 'nonce-…') et dans l’attribut nonce du script inline qui initialise GTM. Les deux valeurs doivent être strictement identiques, sinon le navigateur bloque le snippet.
Que faire si le mode aperçu ne fonctionne plus après durcissement et affiche « blocked » ?
Ajoutez les domaines de la prévisualisation : fonts.googleapis.com, fonts.gstatic.com et www.gstatic.com. Leur absence est la cause la plus fréquente de ce blocage. Rejouez ensuite la prévisualisation en Report-Only pour repérer les violations restantes, notamment en style-src, dont le panneau dépend pour sa mise en forme.
Comment éviter unsafe inline et unsafe eval tout en gardant des balises fonctionnelles ?
Remplacez 'unsafe-inline' par un nonce, éventuellement avec 'strict-dynamic', et transmettez ce nonce aux balises HTML personnalisé. 'unsafe-eval' n’est requis que par les variables JavaScript personnalisées : les remplacer par des variables de couche de données ou des constantes permet souvent de s’en passer.
Une CSP suffit-elle pour la XSS protection, ou faut-il activer Trusted Types en plus ?
Une CSP réduit fortement le risque XSS sans remplacer la correction des vulnérabilités applicatives. Trusted Types la complète sur les applications modernes en verrouillant les sinks DOM à risque. La défense la plus cohérente associe CSP stricte, Trusted Types et hygiène du code.

%2520-%2520blue.jpeg)

.jpeg)
.jpeg)
.avif)