Passer au contenu principal
Kameleoon met regulierement a jour cette liste avec les questions courantes des clients.
Si votre site web restreint le chargement de ressources (scripts, images, médias, CSS) via l’en-tête HTTP standard Content-Security-Policy (CSP), mettez à jour la CSP de votre site pour permettre le chargement des ressources Kameleoon.

​
Configuration simple (avec caractères génériques)

script-src l’emporte toujours sur default-src. N’utilisez pas cette configuration si vous utilisez déjà la configuration complète dans votre CSP.
Ajoutez le contenu suivant à la configuration de votre en-tête CSP :
default-src https://*.kameleoon.com https://*.kameleoon.io https://*.kameleoon.eu https://*.kameleoon.net https://*.experimentation.dev;

​
Configuration complète (entièrement détaillée)

Kameleoon ajoute régulièrement de nouvelles fonctionnalités au produit, ce qui peut entraîner des URL supplémentaires. Listez explicitement tous les hôtes et types de ressources possibles (script, image, etc.) dans l’en-tête CSP.
Remplacez [your-site-code] par votre site code Kameleoon dans chaque ligne où il apparaît et ajoutez ceci à votre configuration :
script-src https://[your-site-code].kameleoon.xx https://static.kameleoon.com https://graphical-editor.kameleoon.com https://simulation.kameleoon.com https://client-config.kameleoon.com https://sdk-config.kameleoon.eu https://electra.kameleoon.com https://aibuilder.kameleoon.com https://static.experimentation.dev 'unsafe-eval';
style-src https://static.kameleoon.com https://static.products.kameleoon.com https://graphical-editor.kameleoon.com https://simulation.kameleoon.com https://electra.kameleoon.com https://aibuilder.kameleoon.com https://static.experimentation.dev 'unsafe-inline'; 
connect-src https://[your-site-code].kameleoon.xx https://static.kameleoon.com https://eu-data.kameleoon.io https://eu-data.kameleoon.eu https://na-data.kameleoon.io https://na-data.kameleoon.eu https://editor.kameleoon.com https://graphical-editor.kameleoon.com https://simulation.kameleoon.com https://api.kameleoon.com https://customers.kameleoon.com https://logger.kameleoon.io https://client-config.kameleoon.com https://sdk-config.kameleoon.eu https://api.products.kameleoon.com https://static.experimentation.dev https://sdk-config.experimentation.dev https://eu-data.experimentation.dev;
img-src https://[your-site-code].kameleoon.xx https://storage.kameleoon.eu https://storage.kameleoon.io https://graphical-editor.kameleoon.com https://simulation.kameleoon.com https://static.kameleoon.com https://images.products.kameleoon.com https://static.experimentation.dev;
frame-src 'self' https://graphical-editor.kameleoon.com https://static.experimentation.dev;
Chaque URL de la politique CSP a un objectif spécifique :
Web Experimentation
  • https://[your-site-code].kameleoon.xx : Charge le script de l’application Kameleoon Web Experimentation, engine.js (précédemment nommé kameleoon.js).
  • https://(eu|na)-data.kameleoon.(eu|io) : Utilisé pour le suivi.
  • https://logger.kameleoon.io : Envoie les données de suivi pour la journalisation.
  • https://data.kameleoon.net : Requis si vous utilisez l’outil de simulation Kameleoon pour faire le QA des expériences sur plusieurs sous-domaines.
Feature Experimentation (SDK côté client)
  • https://client-config.kameleoon.com : Requis pour les versions de SDK < 2.1.0.
  • https://sdk-config.kameleoon.eu : Requis pour les versions de SDK >= 2.1.0.
  • https://(eu|na)-data.kameleoon.(eu|io) : Utilisé pour le suivi.
  • https://logger.kameleoon.io : Envoie les données de suivi pour la journalisation.
Éditeurs graphiques
  • https://static.kameleoon.com : (déprécié) Charge les ressources statiques de l’ancien éditeur graphique.
  • https://editor.kameleoon.com : (déprécié) Utilisé par l’ancien éditeur graphique.
  • https://graphical-editor.kameleoon.com : Utilisé par le nouvel éditeur graphique.
  • https://storage.kameleoon.(eu|io) : Charge les images utilisées dans les expériences créées avec les éditeurs graphiques.
Prompt-Based Experimentation (PBX)
  • https://aibuilder.kameleoon.com : Utilisé par l’éditeur basé sur prompt.
  • https://electra.kameleoon.com : Utilisé par l’éditeur basé sur prompt.
  • https://storage.kameleoon.(eu|io) : Charge les images dans l’éditeur basé sur prompt.
  • https://api.kameleoon.com : Charge les informations liées au compte.
  • https://sdk-config.kameleoon.eu : Contrôle les feature flags Kameleoon activés dans l’éditeur basé sur prompt.
Simulation
  • https://api.kameleoon.com : Utilisé par l’ancienne simulation.
  • https://simulation.kameleoon.com : Utilisé par la nouvelle simulation.
Recommandation produit
  • https://static.products.kameleoon.com : Charge les ressources pour le module de recommandation produit.
  • https://api.products.kameleoon.com : API utilisée par le module de recommandation produit.
  • https://images.products.kameleoon.com : Charge les images de produits pour les recommandations.
API et intégrations
  • https://api.kameleoon.com : Requis si vous comptez utiliser l’API d’automatisation pour les tests directement depuis le navigateur.
  • https://customers.kameleoon.com : Requis si vous utilisez l’API SDK ou une intégration personnalisée développée par Kameleoon.
Ressources internes
Par défaut, engine.js n’inclut pas les chemins de simulation ni les informations spécifiques à l’application pour minimiser la taille du script. Pour fournir ces détails, chargez le script complet kameleoonFull.js, qui fournit à engine.js les données nécessaires sur les ressources internes et les instructions de chargement.
  • https://static.kameleoon.com : Charge les ressources internes.
  • https://static.experimentation.dev : Charge les ressources internes.
  • https://sdk-config.experimentation.dev : Contrôle les feature flags Kameleoon activés dans le produit Kameleoon.
  • https://eu-data.experimentation.dev : Envoie les données de suivi à des fins de journalisation.
Le domaine de vos scripts Kameleoon https://[your-site-code].kameleoon.xx peut varier d’un projet à l’autre. Les projets utilisent soit kameleoon.eu soit kameleoon.io selon leur date de création. Utilisez le domaine affiché dans l’application Kameleoon pour votre projet.
Non. Le script de Kameleoon utilise une technologie de pointe pour s’exécuter de manière asynchrone (lorsque le snippet d’installation asynchrone est utilisé) et reste entièrement mis en cache par le navigateur pendant 90 minutes. Il ne bloque jamais le chargement de la page, même lors de rares incidents CDN (disponibilité de 99,99 %). En moyenne, le script se charge en moins de 70 ms sur une connexion 4G ou des conditions réseau plus rapides.Kameleoon minimise encore l’impact grâce à des techniques de compression avancées, combinant TypeScript et Brotli, ce qui donne une taille de script de base de seulement 28,4 Ko.

​
Livraison CDN et évolutivité

Le script engine.js est servi via le CDN Cloudflare, ce qui signifie qu’il évolue automatiquement quel que soit le volume de trafic de votre site web. Il n’y a aucun problème de chargement ou de lenteur, quel que soit le niveau de trafic — le réseau mondial de Cloudflare gère la diffusion, de sorte que ni les pics ni un trafic élevé soutenu n’affectent les performances du script pour vos visiteurs.

​
Mise en cache

Par défaut, le navigateur met en cache engine.js pendant 90 minutes, ce qui minimise les temps de chargement répétés pour les visiteurs récurrents. Si votre cas d’usage nécessite une durée de cache plus courte, elle peut être réduite — jusqu’à seulement 1 minute — sur demande. Contactez le support Kameleoon pour ajuster ce paramètre pour votre compte.

​
Considérations importantes

La taille du script peut augmenter en fonction du nombre d’expériences que vous exécutez et de leur contenu (CSS/JavaScript).Pour les expériences ou campagnes de personnalisation qui n’ont pas besoin de se charger immédiatement, utilisez le tag “DELAYED”. Cela retarde le chargement des expériences non essentielles après le premier chargement de la page. Kameleoon gère ces expériences intelligemment : il ne télécharge la configuration qu’après 10 secondes d’inactivité ou lorsqu’un visiteur est ciblé et alloué à une variation autre que la version de contrôle. Cette approche garantit un impact minimal sur les performances de chargement tout en offrant une fonctionnalité complète pour les expériences prioritaires.
Le moteur JavaScript Kameleoon nécessite la fonction eval() pour ajouter du code personnalisé à Kameleoon, comme des données personnalisées et du JavaScript personnalisé, lors de la mise en œuvre de variations d’une page. La fonction eval() permet à Kameleoon d’exécuter dynamiquement ce code personnalisé au moment de l’exécution.Si vous utilisez une directive Content Security Policy (CSP) qui empêche l’utilisation de la fonction eval(), implémentez le snippet JavaScript suivant avant le tag d’installation Kameleoon :
<script>
window.kameleoonQueue = window.kameleoonQueue || [];

function excludeKameleoonEval() {
	Kameleoon.Utils.runProtectedScript = function (code, fileName) {
		const script = document.createElement("script");

		const wrappedCode = "(function () {\n" + code + "\n})();";
		script.innerHTML = wrappedCode;

		if (fileName) {
			script.innerHTML += "\n//# sourceURL=" + fileName;
		}

		document.head.appendChild(script);
	};
}

kameleoonQueue.push({
	level: "IMMEDIATE",
	command: excludeKameleoonEval
}); 
</script>

//Add the Kameleoon Installation tag here. Refer to this documentation: https://developers.kameleoon.com/developer-docs/web-experimentation/implementation-and-deployment/standard-implementation.mdx
<script src="//SITE_CODE.kameleoon.eu/engine.js" fetchpriority="high" async></script>
Si votre CSP bloque eval(), la mise en œuvre du snippet de code ne supprimera pas ces restrictions. Pour assurer une fonctionnalité complète, ajustez la directive CSP concernée pour autoriser eval() ou des fonctions similaires. Sinon, certaines fonctionnalités avancées de ciblage ou de personnalisation dans Kameleoon resteront inaccessibles en raison de l’application des règles de sécurité du navigateur.
L’éditeur graphique Kameleoon (y compris le panneau de simulation) nécessite également la fonction eval(). Cependant, vous pouvez contourner cette exigence en installant l’extension Chrome Kameleoon et en activant le paramètre Dev Tools > Tag injection > Bypass policies pour outrepasser localement les politiques. Vous devez également fournir votre sitecode. L’activation du paramètre Bypass policies vous permet d’utiliser l’éditeur graphique dans un navigateur Chrome.
Parametre Bypass policies dans l'extension Chrome
Certaines fonctionnalités de Kameleoon ne sont pas disponibles si une directive CSP bloque la fonction eval(). Ces limitations s’appliquent même si vous utilisez l’un des snippets de code ou contournements mentionnés dans la FAQ. Les fonctionnalités suivantes resteront indisponibles sauf si votre CSP autorise explicitement eval() :
  • Cibler un segment avec une condition JavaScript personnalisée (uniquement pris en charge lorsque la condition s’exécute de manière asynchrone).
Parametre asynchrone de la condition de ciblage
  • Utiliser des données personnalisées avec du code JavaScript personnalisé.
  • Utiliser des canaux d’acquisition avec du code JavaScript personnalisé.
Oui, Kameleoon propose cette option avancée. Transférez toutes les requêtes HTTP reçues sur votre serveur vers (eu|na)-data.kameleoon.(eu|io). Par exemple, si vous choisissez tracking.yourdomain.com comme domaine de suivi, une requête de suivi serait une POST vers tracking.yourdomain.com. Votre serveur devrait alors transférer la requête, avec toutes les données et paramètres nécessaires, vers l’hôte (eu|na)-data.kameleoon.(eu|io). Pour activer cette option, contactez votre Customer Success Manager.
Lors du transfert des requêtes vers (eu|na)-data.kameleoon.(eu|io), assurez-vous de réécrire l’URL de la requête vers (eu|na)-data.kameleoon.(eu|io). Il ne suffit pas de transférer la requête en conservant l’en-tête HTTP Host: d’origine défini sur votre domaine. Définissez l’en-tête Host: sur (eu|na)-data.kameleoon.(eu|io).
Malheureusement, non. Bien que SRI offre une fonctionnalité de sécurité utile, le fichier d’application Kameleoon change au fil du temps. Si ce n’était pas le cas, des fonctionnalités comme démarrer et arrêter des expériences instantanément sans redéploiement seraient impossibles. Comme le contenu du fichier change, le hash de la ressource change également, ce qui signifie que SRI ne peut pas être utilisé. Sinon, le navigateur bloquerait la ressource dès qu’elle serait mise à jour sur les serveurs.
Il s’agit d’un bug connu sur Firefox. En attendant que l’équipe Firefox le corrige, suivez ce contournement : assurez-vous que votre ressource CSS liée est suivie d’une balise <script> (même presque vide).Exemple :
<link href="https://www.example.com/web/style.css" media="all" rel="stylesheet" type="text/css" />
<script>/**/</script>
Cela supprime entièrement l’effet de clignotement.
Les scripts Kameleoon sont déjà courts, et utiliser une version minifiée n’affecte pas significativement le temps de chargement de la page car le code est déjà compressé avec Brotli ou Gzip. Kameleoon ne recommande pas les versions minifiées, mais si nécessaire, elles sont disponibles ci-dessous.

​
Chargement asynchrone avec anti-flicker

<script>
  var a=750;window.kameleoonQueue=window.kameleoonQueue||[];window.kameleoonStartLoadTime=Date.now();if(!document.getElementById("kameleoonLoadingStyleSheet")&&!window.kameleoonDisplayPageTimeOut){var b=document.getElementsByTagName("script")[0];var c="html::after { content: ''; position: fixed; inset: 0; background: #fff; z-index: 2147483647; }";var d=document.createElement("style");d.type="text/css";d.id="kameleoonLoadingStyleSheet";if(d.styleSheet){d.styleSheet.cssText=c}else{d.appendChild(document.createTextNode(c))}b.parentNode.insertBefore(d,b);window.kameleoonDisplayPage=function(e){if(!e){window.kameleoonTimeout=true}if(d.parentNode){d.parentNode.removeChild(d)}};window.kameleoonDisplayPageTimeOut=window.setTimeout(window.kameleoonDisplayPage,a)};
</script>
<script src="//SITE_CODE.kameleoon.eu/engine.js" fetchpriority="high" async></script>

​
Unifier les donnees de session entre sous-domaines

Si vous utilisez le tag de données de session unifiées pour unifier les données de session entre sous-domaines avec soit le tag synchrone, soit le tag asynchrone sans anti-flicker :
<script>
  window.kameleoonIframeURL="https://www.customerdomain.com/path/to/kameleoon-iframe.html";var f=document.createElement("a");window.kameleoonLightIframe=false;f.href=window.kameleoonIframeURL;window.kameleoonIframeOrigin=f.origin||(f.protocol+"//"+f.hostname);if(location.href.indexOf(window.kameleoonIframeOrigin)!=0){window.kameleoonLightIframe=true;var g=function(event){if(window.kameleoonIframeOrigin==event.origin&&event.data.slice&&event.data.slice(0,9)=="Kameleoon"){window.removeEventListener("message",g);window.kameleoonExternalIFrameLoaded=true;if(window.Kameleoon){Kameleoon.Utils.runProtectedScript(event.data);Kameleoon.Analyst.load()}else{window.kameleoonExternalIFrameLoadedData=event.data}}};if(window.addEventListener){window.addEventListener("message",g,false)}var h=document.createElement("iframe");h.src=kameleoonIframeURL;h.id="kameleoonExternalIframe";h.style="float: left !important; opacity: 0.0 !important; width: 0px !important; height: 0px !important;";document.head.appendChild(h)};
</script>
Si vous utilisez le tag de données de session unifiées et le tag asynchrone avec anti-flicker, ajoutez les trois balises de script dans l’ordre suivant :
  1. Tag asynchrone avec anti-flicker.
  2. Tag de données de session unifiées.
  3. Tag d’installation Kameleoon.
<script>
  var a=750;window.kameleoonQueue=window.kameleoonQueue||[];window.kameleoonStartLoadTime=Date.now();if(!document.getElementById("kameleoonLoadingStyleSheet")&&!window.kameleoonDisplayPageTimeOut){var b=document.getElementsByTagName("script")[0];var c="html::after { content: ''; position: fixed; inset: 0; background: #fff; z-index: 2147483647; }";var d=document.createElement("style");d.type="text/css";d.id="kameleoonLoadingStyleSheet";if(d.styleSheet){d.styleSheet.cssText=c}else{d.appendChild(document.createTextNode(c))}b.parentNode.insertBefore(d,b);window.kameleoonDisplayPage=function(e){if(!e){window.kameleoonTimeout=true}if(d.parentNode){d.parentNode.removeChild(d)}};window.kameleoonDisplayPageTimeOut=window.setTimeout(window.kameleoonDisplayPage,a)};
</script>
<script>
  window.kameleoonIframeURL="https://www.customerdomain.com/path/to/kameleoon-iframe.html";var f=document.createElement("a");window.kameleoonLightIframe=false;f.href=window.kameleoonIframeURL;window.kameleoonIframeOrigin=f.origin||(f.protocol+"//"+f.hostname);if(location.href.indexOf(window.kameleoonIframeOrigin)!=0){window.kameleoonLightIframe=true;var g=function(event){if(window.kameleoonIframeOrigin==event.origin&&event.data.slice&&event.data.slice(0,9)=="Kameleoon"){window.removeEventListener("message",g);window.kameleoonExternalIFrameLoaded=true;if(window.Kameleoon){Kameleoon.Utils.runProtectedScript(event.data);Kameleoon.Analyst.load()}else{window.kameleoonExternalIFrameLoadedData=event.data}}};if(window.addEventListener){window.addEventListener("message",g,false)}var h=document.createElement("iframe");h.src=kameleoonIframeURL;h.id="kameleoonExternalIframe";h.style="float: left !important; opacity: 0.0 !important; width: 0px !important; height: 0px !important;";document.head.appendChild(h)};
</script>
<script src="//SITE_CODE.kameleoon.eu/engine.js" fetchpriority="high" async></script>
Ne modifiez pas les tags d’installation. Leur code est largement testé et optimisé. Les modifier peut entraîner une configuration non fonctionnelle. Si un tag d’installation nécessite une modification, contactez votre Account Manager Kameleoon pour coordonner avec les développeurs. Ne tentez pas de modifications indépendantes.
N’incluez aucun tag d’installation dans son propre script externe séparé. Par exemple, ne faites jamais ceci :
<script src="resources/scripts/kameloon-loader.js" fetchpriority="high" async></script>
Bien que cela puisse techniquement fonctionner, cela affecte significativement les performances de Kameleoon et introduit un effet de clignotement notable. Cette configuration crée les problèmes de l’utilisation d’un tag manager sans aucun des avantages associés.
Oui, les partitions où les données sont stockées peuvent être chiffrées. Cette option nécessite un coût de configuration supplémentaire. Contactez votre Customer Success Manager pour plus d’informations.
Oui, vous pouvez différer les expériences non essentielles après le premier chargement de page. Pour différer une expérience, ajoutez le tag DELAYED aux expériences que vous souhaitez reporter. Pour plus d’informations, consultez la documentation sur la gestion des tags.Kameleoon gère intelligemment les expériences taguées “DELAYED”. Il ne télécharge la configuration qu’après 10 secondes d’inactivité ou lorsque le visiteur est ciblé et alloué à une variation autre que la version de contrôle. Concentrez-vous sur la fourniture de la meilleure expérience utilisateur en différant les tests gourmands en ressources.
La plateforme Kameleoon offre une évolutivité et une élasticité élevées, garantissant des performances optimales à mesure que les volumes de données augmentent. La plateforme gère une charge moyenne de 20 000 requêtes par seconde avec des pics jusqu’à 100 000 requêtes. Les facteurs clés incluent :
  • Architecture évolutive : L’architecture distribuée et modulaire permet un dimensionnement horizontal.
  • Infrastructure à mise à l’échelle automatique : L’infrastructure basée sur le cloud met à l’échelle automatiquement les ressources de calcul.
  • Répartition de charge : Des techniques avancées répartissent uniformément le trafic entre les serveurs.
  • Ingestion et traitement des données : Des API robustes et un broker de données gèrent efficacement de grands volumes de données.
  • Tests d’évolutivité : Les tests réguliers de charge et de stress garantissent que le système gère des conditions extrêmes.
  • Stockage de données élastique : Le stockage à plusieurs niveaux permet un accès rapide aux données et une évolutivité à long terme.
Kameleoon utilise les bases de données NoSQL et technologies suivantes dans l’architecture de flux de données :
  • Hadoop File System (avec Spark)
  • Cassandra
  • ClickHouse
  • Kafka
Le moteur Kameleoon initie plusieurs requêtes réseau pour assurer un fonctionnement transparent :

​
Requête de segments

  • Objectif : Collecte les événements pour les segments ciblés par le visiteur.
  • Endpoint : https://${SITECODE}.kameleoon.io/audiences/segments.js
  • Méthode : GET
  • Note : Le navigateur met le fichier en cache pendant 90 minutes.

​
Requête de configuration des expériences en mise à jour en direct

  • Objectif : Récupère la configuration des expériences taguées LIVE-UPDATE.
  • Endpoint : https://${SITECODE}.kameleoon.io/live-experiments/config.js
  • Méthode : GET
  • Note : Le navigateur met le fichier en cache pendant 2 minutes.

​
Requête de variation d’expérience différée

  • Objectif : Charge les données de variation pour les expériences taguées DELAYED.
  • Endpoint : https://${SITECODE}.kameleoon.io/experiments/${action.id}/variations/${variationId}.js
  • Méthode : GET
  • Note : Le navigateur met le fichier en cache pendant 30 jours.

​
Requête de variation de personnalisation différée

  • Objectif : Charge les données de variation pour les personnalisations taguées DELAYED.
  • Endpoint : https://${SITECODE}.kameleoon.io/personalizations/${action.id}/variations/${variationId}.js
  • Méthode : GET
  • Note : Le navigateur met le fichier en cache pendant 30 jours.

​
Requête des visites précédentes

​
Requête des événements de suivi

  • Objectif : Enregistre les événements pendant les visites.
  • Endpoint : https://(eu|na)-data.kameleoon.(eu|io)/visit/events
  • Méthode : POST
Kameleoon envoie un événement toutes les 15 secondes lorsqu’un défilement ou un clic se produit. Cela garantit le suivi correct de la durée de session. Si le moteur ne détecte aucune activité, il n’effectue pas d’appel de suivi supplémentaire.

​
Requête d’adresse IP

  • Objectif : Permet l’exclusion/inclusion de visiteurs en fonction de l’adresse IP.
  • Endpoint : https://(eu|na)-data.kameleoon.(eu|io)/ip
  • Méthode : GET
  • Note : Kameleoon ne stocke jamais les IPs dans des bases de données. Le navigateur du visiteur utilise l’IP uniquement à des fins de comparaison.

​
Requête de géolocalisation

  • Objectif : Obtient les données de géolocalisation pour le ciblage et l’analyse.
  • Endpoint : https://(eu|na)-data.kameleoon.(eu|io)/geolocation
  • Méthode : GET

​
Requête météo actuelle

  • Objectif : Retourne les conditions météorologiques actuelles.
  • Endpoint : https://(eu|na)-data.kameleoon.(eu|io)/weather/weather
  • Méthode : GET

​
Requête de prévisions météorologiques

  • Objectif : Retourne des prévisions météo sur 5 jours.
  • Endpoint : https://(eu|na)-data.kameleoon.(eu|io)/weather/forecast
  • Méthode : GET

​
Requête de détection du script Kameleoon

  • Objectif : Détecte le statut d’implémentation du script Kameleoon.
  • Endpoint : https://(eu|na)-data.kameleoon.(eu|io)/active-script/event
  • Méthode : POST

​
Requête des produits

  • Objectif : Recueille les événements produits pour le ciblage et les recommandations.
  • Endpoint : https://(eu|na)-data.kameleoon.(eu|io)/product/events
  • Méthode : POST

​
Requête des scores de conversion Kameleoon

  • Objectif : Récupère les scores prédictifs pour le ciblage.
  • Endpoint : https://(eu|na)-data.kameleoon.(eu|io)/predict/latestPredictionScoreHistograms
  • Méthode : GET