Saltar al contenido principal
Kameleoon actualiza periódicamente esta lista con preguntas habituales de los clientes.
Si su sitio web restringe la carga de recursos (scripts, imágenes, multimedia, CSS) mediante la cabecera HTTP estándar Content-Security-Policy (CSP), actualice la CSP de su sitio para permitir que se carguen los recursos de Kameleoon.

Configuración sencilla (con comodines)

script-src siempre prevalece sobre default-src. No use esta configuración si ya utiliza la configuración completa en su CSP.
Añada el siguiente contenido a la configuración de su cabecera CSP:
default-src https://*.kameleoon.com https://*.kameleoon.io https://*.kameleoon.eu https://*.kameleoon.net wss://*.kameleoon.com https://*.experimentation.dev;

Configuración completa (con todo el detalle)

Kameleoon añade regularmente nuevas funcionalidades al producto, lo que podría dar lugar a URLs adicionales. Liste explícitamente en la cabecera CSP todos los hosts y tipos de recursos posibles (script, image, etc.).
Reemplace [your-site-code] por su site code de Kameleoon en cada línea donde aparezca y añada esto a su configuración:
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 wss://electra.kameleoon.com;
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;
Cada URL de la política CSP tiene un propósito específico:
Web Experimentation
  • https://[your-site-code].kameleoon.xx: carga el script de la aplicación Kameleoon Web Experimentation, engine.js (antes llamado kameleoon.js).
  • https://(eu|na)-data.kameleoon.(eu|io): se utiliza para el tracking.
  • https://logger.kameleoon.io: envía datos de tracking para logging.
  • https://data.kameleoon.net: necesario si utiliza la herramienta de simulación de Kameleoon para hacer QA de experimentos en varios subdominios.
Feature Experimentation (SDKs client-side)
  • https://client-config.kameleoon.com: necesario para versiones de SDK < 2.1.0.
  • https://sdk-config.kameleoon.eu: necesario para versiones de SDK >= 2.1.0.
  • https://(eu|na)-data.kameleoon.(eu|io): se utiliza para el tracking.
  • https://logger.kameleoon.io: envía datos de tracking para logging.
Editores gráficos
  • https://static.kameleoon.com: (obsoleto) carga recursos estáticos para el antiguo editor gráfico.
  • https://editor.kameleoon.com: (obsoleto) utilizado por el antiguo editor gráfico.
  • https://graphical-editor.kameleoon.com: utilizado por el nuevo editor gráfico.
  • https://storage.kameleoon.(eu|io): carga imágenes usadas en experimentos creados con los editores gráficos.
Prompt-Based Experimentation (PBX)
  • https://aibuilder.kameleoon.com: utilizado por el editor prompt-based.
  • https://electra.kameleoon.com: utilizado por el editor prompt-based.
  • https://storage.kameleoon.(eu|io): carga imágenes en el editor prompt-based.
  • https://api.kameleoon.com: carga información relacionada con la cuenta.
  • https://sdk-config.kameleoon.eu: controla los feature flags de Kameleoon activados en el editor prompt-based.
  • wss://electra.kameleoon.com : se utiliza para el intercambio de datos.
Simulación
  • https://api.kameleoon.com: utilizado por la simulación antigua.
  • https://simulation.kameleoon.com: utilizado por la nueva simulación.
Product Recommendation
  • https://static.products.kameleoon.com: carga recursos para el módulo Product Recommendation.
  • https://api.products.kameleoon.com: API utilizada por el módulo Product Recommendation.
  • https://images.products.kameleoon.com: carga imágenes de producto para las recomendaciones.
APIs e integraciones
  • https://api.kameleoon.com: necesario si tiene intención de usar la Automation API para pruebas directamente desde el navegador.
  • https://customers.kameleoon.com: necesario si utiliza la SDK API o una integración personalizada desarrollada por Kameleoon.
Recursos internos
Por defecto, engine.js no incluye rutas de simulación ni información específica de la aplicación para minimizar el tamaño del script. Para incluir estos detalles, cargue el script completo kameleoonFull.js, que proporciona a engine.js los datos necesarios sobre recursos internos e instrucciones de carga.
  • https://static.kameleoon.com: carga recursos internos.
  • https://static.experimentation.dev: carga recursos internos.
  • https://sdk-config.experimentation.dev: controla los feature flags de Kameleoon activados en el producto Kameleoon.
  • https://eu-data.experimentation.dev: envía datos de tracking con fines de logging.
El dominio de sus scripts de Kameleoon https://[your-site-code].kameleoon.xx puede variar entre proyectos. Los proyectos usan kameleoon.eu o kameleoon.io según su fecha de creación. Use el dominio que se muestra en la app de Kameleoon para su proyecto.
No. El script de Kameleoon utiliza tecnología de vanguardia para ejecutarse de forma asincrónica (cuando se usa el snippet de instalación async) y permanece totalmente cacheado por el navegador durante 90 minutos. Nunca bloquea la carga de la página, incluso durante los raros incidentes de la CDN (99,99% de uptime). En promedio, el script se carga en menos de 70 ms con una conexión 4G o condiciones de red más rápidas.Kameleoon minimiza aún más el impacto mediante técnicas avanzadas de compresión, combinando TypeScript y Brotli, resultando en un tamaño base del script de tan solo 28,4 KB.

Entrega por CDN y escalabilidad

El script engine.js se sirve a través de la CDN de Cloudflare, lo que significa que escala automáticamente independientemente del volumen de tráfico de su sitio web. No hay problemas de carga ni de lentitud a ningún nivel de tráfico: la red global de Cloudflare gestiona la entrega, por lo que ni los picos ni el tráfico alto sostenido afectan al rendimiento del script para sus visitantes.

Caché

Por defecto, el navegador cachea engine.js durante 90 minutos, minimizando los tiempos de carga repetidos para los visitantes que regresan. Si su caso de uso requiere una duración de caché más corta, puede reducirse hasta un mínimo de 1 minuto bajo petición. Contacte con el soporte de Kameleoon para ajustar esta configuración en su cuenta.

Consideraciones importantes

El tamaño del script puede aumentar según el número de experimentos que ejecute y su contenido (CSS/JavaScript).Para experimentos o campañas de personalización que no necesiten cargarse de inmediato, use el tag “DELAYED”. Esto retrasa la carga de experimentos no esenciales hasta después de la primera carga de página. Kameleoon los gestiona de forma inteligente: solo descarga la configuración tras 10 segundos de inactividad o cuando un visitante está segmentado y se le asigna una variación distinta del control. Este enfoque garantiza un impacto mínimo en el rendimiento de carga al tiempo que ofrece toda la funcionalidad para los experimentos priorizados.

Web Experimentation (engine.js)

El engine.js procesa las solicitudes salientes a través de una cola interna que se ejecuta aproximadamente cada 500 ms. La cola agrupa los eventos en lotes y envía lotes adicionales de forma recursiva si es necesario. Al descargar o limpiar la página, el motor fuerza el procesamiento inmediato de todos los eventos en cola. En Safari, el motor persiste los eventos no enviados en el almacenamiento de sesión para evitar la pérdida de datos.Además, el motor envía un evento de actividad cada 15 segundos cuando se detecta un desplazamiento o un clic. Cuando no se detecta actividad, el motor no realiza llamadas de seguimiento adicionales.

Feature Experimentation (SDKs)

Para los casos de uso con feature flags y SDKs, Kameleoon realiza las evaluaciones de flags localmente después de la inicialización. Las solicitudes de seguimiento hacia la Data API se agrupan en lotes y se envían en segundo plano, en lugar de enviarse individualmente por cada evaluación. El procesamiento por lotes reduce el volumen de solicitudes y evita la degradación del rendimiento durante los picos de tráfico. El intervalo de envío es configurable en el SDK, con un valor predeterminado de 1 segundo.

Límites de frecuencia de la Data API

Kameleoon aplica límites de frecuencia a la Data API para proteger la fiabilidad del servicio. Los límites se basan en sus visitantes únicos mensuales (MUV) contractuales y la dirección IP del solicitante. Si supera esos límites, la API devuelve HTTP 429.Estos límites se aplican a todas las solicitudes que llegan a la Data API, incluidas las llamadas de seguimiento que engine.js envía automáticamente y las solicitudes de seguimiento agrupadas que los SDK de Feature Experimentation envían. En entornos donde muchos visitantes comparten una única dirección IP (como oficinas o redes corporativas), los límites basados en IP pueden aplicarse incluso cuando sus MUV totales se mantienen dentro del contrato.Para integraciones del lado del servidor, puede eliminar los límites basados en IP autenticando sus solicitudes. Si su caso de uso requiere límites más altos, contacte con el soporte de Kameleoon para discutir las opciones.Los límites de frecuencia se aplican a toda su cuenta de cliente, no a proyectos individuales. Si un proyecto genera un número excesivo de solicitudes (por ejemplo, porque una implementación defectuosa crea un bucle que envía eventos de datos personalizados repetidamente), ese proyecto consume el límite compartido de la cuenta y puede causar errores HTTP 429 en todos sus otros proyectos.Para identificar qué proyecto está generando tráfico inesperado, use la página Live events (Insights > Live events). Seleccione cada proyecto por turnos y compare el recuento de eventos de la última hora o de las últimas 24 horas con el volumen esperado. Un proyecto que genera muchos más eventos de los que justifica su volumen de visitantes (por ejemplo, decenas de millones de eventos con un contrato de 100.000 MUV) es probablemente la fuente del problema. Filtre los eventos por tipo para identificar la causa: los eventos de datos personalizados son los más frecuentes, a menudo porque un bucle mal configurado envía la misma variable de datos personalizados, o todas las variables de datos personalizados, en cada carga de página.

Escalabilidad de la plataforma

La plataforma de Kameleoon utiliza escalado horizontal, infraestructura con auto-scaling, balanceo de carga, y pruebas de carga y estrés periódicas. Para más detalles, consulte ¿Cómo soporta la plataforma de Kameleoon la escalabilidad y la elasticidad?.
El motor JavaScript de Kameleoon requiere la función eval() para añadir código personalizado a Kameleoon, como datos personalizados y JavaScript personalizado, al implementar variaciones de una página. La función eval() permite a Kameleoon ejecutar dinámicamente este código personalizado en tiempo de ejecución.Si utiliza una directiva Content Security Policy (CSP) que impide el uso de la función eval(), implemente el siguiente snippet JavaScript antes del tag de instalación de 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>

//Añada aquí el tag de instalación de Kameleoon. Consulte esta documentación: 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 su CSP bloquea eval(), implementar el snippet de código no eliminará estas restricciones. Para garantizar toda la funcionalidad, ajuste la directiva CSP correspondiente para permitir eval() o funciones similares. De lo contrario, ciertas funcionalidades avanzadas de segmentación o personalización en Kameleoon seguirán siendo inaccesibles debido a la aplicación de la seguridad del navegador.
El Graphic Editor de Kameleoon (incluido el panel de simulación) también requiere la función eval(). No obstante, puede sortear este requisito instalando la extensión Kameleoon para Chrome y habilitando el ajuste Dev Tools > Tag injection > Bypass policies para anular las políticas localmente. También debe proporcionar su sitecode. Habilitar el ajuste Bypass policies le permite usar el Graphic editor en un navegador Chrome.
Ajuste Bypass policies en la extensión de Chrome
Algunas funcionalidades de Kameleoon no están disponibles si una directiva CSP bloquea la función eval(). Estas limitaciones se aplican incluso si utiliza alguno de los snippets de código o soluciones alternativas mencionados en la FAQ. Las siguientes funcionalidades seguirán sin estar disponibles a menos que su CSP permita explícitamente eval():
  • Segmentar un segmento con una condición JavaScript personalizada (solo se admite cuando la condición se ejecuta de forma asincrónica).
Ajuste de condición de segmentación async
  • Uso de datos personalizados con código JavaScript personalizado.
  • Uso de canales de adquisición con código JavaScript personalizado.
Sí, Kameleoon ofrece esta opción avanzada. Reenvíe todas las solicitudes HTTP recibidas en su servidor a (eu|na)-data.kameleoon.(eu|io). Por ejemplo, si elige tracking.yourdomain.com como su dominio de tracking, una solicitud de tracking sería un POST a tracking.yourdomain.com. Su servidor debe entonces reenviar la solicitud, junto con todos los datos y parámetros necesarios, al host (eu|na)-data.kameleoon.(eu|io). Para activar esta opción, contacte con su Customer Success Manager.
Al reenviar solicitudes a (eu|na)-data.kameleoon.(eu|io), asegúrese de reescribir la URL de la solicitud a (eu|na)-data.kameleoon.(eu|io). No basta con reenviar la solicitud manteniendo la cabecera HTTP original Host: apuntando a su dominio. Establezca la cabecera Host: en (eu|na)-data.kameleoon.(eu|io).
Lamentablemente, no. Aunque SRI ofrece una funcionalidad de seguridad útil, el archivo de la aplicación Kameleoon cambia con el tiempo. Si no lo hiciera, funcionalidades como iniciar y detener experimentos al instante sin un redespliegue serían imposibles. Dado que el contenido del archivo cambia, el hash del recurso también cambia, lo que significa que no se puede usar SRI. De lo contrario, el navegador bloquearía el recurso en cuanto se actualizara en los servidores.
Se trata de un bug conocido en Firefox. Hasta que el equipo de Firefox lo corrija, siga esta solución alternativa: asegúrese de que su recurso CSS enlazado vaya seguido de una etiqueta <script> (aunque sea casi vacía).Ejemplo:
<link href="https://www.example.com/web/style.css" media="all" rel="stylesheet" type="text/css" />
<script>/**/</script>
Esto elimina por completo el efecto de parpadeo.
Los scripts de Kameleoon ya son cortos y usar una versión minificada no afecta significativamente al tiempo de carga de la página, ya que el código ya está comprimido con Brotli o Gzip. Kameleoon no recomienda las versiones minificadas, pero si son necesarias, están disponibles a continuación.

Carga asincrónica con anti-parpadeo

<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>

Unificar datos de sesión entre subdominios

Si utiliza el tag de datos de sesión unificados para unificar datos de sesión entre subdominios con el tag sincrónico o el tag asincrónico sin anti-parpadeo:
<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 utiliza el tag de datos de sesión unificados y el tag asincrónico con anti-parpadeo, añada los tres tags de script en el siguiente orden:
  1. Tag asincrónico con anti-parpadeo.
  2. Tag de datos de sesión unificados.
  3. Tag de instalación de 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>
No modifique los tags de instalación. Su código está exhaustivamente probado y optimizado. Modificarlos puede resultar en una configuración que no funciona. Si es necesario modificar un tag de instalación, contacte con su Customer Success Manager de Kameleoon para coordinarse con los desarrolladores. No intente realizar modificaciones por su cuenta.
No incluya ningún tag de instalación en su propio script externo aparte. Por ejemplo, nunca haga esto:
<script src="resources/scripts/kameloon-loader.js" fetchpriority="high" async></script>
Aunque técnicamente puede funcionar, afecta significativamente al rendimiento de Kameleoon e introduce un efecto de parpadeo notable. Esta configuración crea los problemas de usar un tag manager sin ninguno de los beneficios asociados.
Sí, las particiones donde se almacenan los datos pueden cifrarse. Esta opción requiere un coste de configuración adicional. Contacte con su Customer Success Manager para más información.
Sí, puede retrasar los experimentos no esenciales hasta después de la primera carga de página. Para retrasar un experimento, añada el tag DELAYED a los experimentos que desee diferir. Para más información, consulte la documentación sobre gestión de tags.Kameleoon gestiona de forma inteligente los experimentos etiquetados como “DELAYED”. Solo descarga la configuración tras 10 segundos de inactividad o cuando el visitante está segmentado y se le asigna una variación distinta del control. Céntrese en ofrecer la mejor experiencia de usuario difiriendo los tests que consumen muchos recursos.
La plataforma de Kameleoon ofrece alta escalabilidad y elasticidad, garantizando un rendimiento óptimo a medida que crecen los volúmenes de datos. La plataforma gestiona una carga media de 20.000 consultas por segundo con picos de hasta 100.000 consultas. Los factores clave incluyen:
  • Arquitectura escalable: una arquitectura distribuida y modular permite el escalado horizontal.
  • Infraestructura con auto-scaling: la infraestructura basada en la nube escala automáticamente los recursos computacionales.
  • Balanceo de carga: técnicas avanzadas distribuyen el tráfico de forma equitativa entre los servidores.
  • Ingesta y procesamiento de datos: APIs robustas y un data broker gestionan grandes volúmenes de datos de forma eficiente.
  • Tests de escalabilidad: tests de carga y estrés periódicos garantizan que el sistema soporte condiciones extremas.
  • Almacenamiento de datos elástico: el almacenamiento multinivel permite un acceso rápido a los datos y una escalabilidad a largo plazo.
Kameleoon utiliza las siguientes bases de datos NoSQL y tecnologías en la arquitectura del flujo de datos:
  • Hadoop File System (junto con Spark)
  • Cassandra
  • ClickHouse
  • Kafka
El motor de Kameleoon inicia varias solicitudes de red para garantizar un funcionamiento fluido:

Solicitud de Segments

  • Propósito: recopila eventos para los segmentos objetivo del visitante.
  • Endpoint: https://${SITECODE}.kameleoon.io/audiences/segments.js
  • Método: GET
  • Nota: el navegador cachea el archivo durante 90 minutos.

Solicitud de configuración de experimentos Live-update

  • Propósito: recupera la configuración de los experimentos etiquetados como LIVE-UPDATE.
  • Endpoint: https://${SITECODE}.kameleoon.io/live-experiments/config.js
  • Método: GET
  • Nota: el navegador cachea el archivo durante 2 minutos.

Solicitud de variación de experimento diferido

  • Propósito: carga datos de variación para experimentos etiquetados como DELAYED.
  • Endpoint: https://${SITECODE}.kameleoon.io/experiments/${action.id}/variations/${variationId}.js
  • Método: GET
  • Nota: el navegador cachea el archivo durante 30 días.

Solicitud de variación de personalización diferida

  • Propósito: carga datos de variación para personalizaciones etiquetadas como DELAYED.
  • Endpoint: https://${SITECODE}.kameleoon.io/personalizations/${action.id}/variations/${variationId}.js
  • Método: GET
  • Nota: el navegador cachea el archivo durante 30 días.

Solicitud de visitas anteriores

Solicitud de eventos de tracking

  • Propósito: registra eventos durante las visitas.
  • Endpoint: https://(eu|na)-data.kameleoon.(eu|io)/visit/events
  • Método: POST
Kameleoon envía un evento cada 15 segundos cuando se produce un scroll o un clic. Esto garantiza un seguimiento correcto de la duración de la sesión. Si el motor no detecta actividad, no realiza ninguna llamada adicional de tracking.

Solicitud de dirección IP

  • Propósito: permite la exclusión/inclusión de visitantes en función de la dirección IP.
  • Endpoint: https://(eu|na)-data.kameleoon.(eu|io)/ip
  • Método: GET
  • Nota: Kameleoon nunca almacena IPs en las bases de datos. El navegador del visitante utiliza la IP únicamente con fines de comparación.

Solicitud de geolocalización

  • Propósito: obtiene datos de geolocalización para segmentación y analítica.
  • Endpoint: https://(eu|na)-data.kameleoon.(eu|io)/geolocation
  • Método: GET

Solicitud del clima actual

  • Propósito: devuelve las condiciones meteorológicas actuales.
  • Endpoint: https://(eu|na)-data.kameleoon.(eu|io)/weather/weather
  • Método: GET

Solicitud de pronóstico del clima

  • Propósito: devuelve un pronóstico meteorológico de 5 días.
  • Endpoint: https://(eu|na)-data.kameleoon.(eu|io)/weather/forecast
  • Método: GET

Solicitud de detección del script de Kameleoon

  • Propósito: detecta el estado de implementación del script de Kameleoon.
  • Endpoint: https://(eu|na)-data.kameleoon.(eu|io)/active-script/event
  • Método: POST

Solicitud de Products

  • Propósito: recopila eventos de producto para segmentación y recomendaciones.
  • Endpoint: https://(eu|na)-data.kameleoon.(eu|io)/product/events
  • Método: POST

Solicitud de Kameleoon Conversion Scores

  • Propósito: recupera scores predictivos para segmentación.
  • Endpoint: https://(eu|na)-data.kameleoon.(eu|io)/predict/latestPredictionScoreHistograms
  • Método: GET
El servicio estándar de Kameleoon funciona sobre una arquitectura SaaS multiinquilino. Sus datos comparten infraestructura con otros inquilinos, pero están lógicamente aislados de todos los demás datos de clientes mediante controles de acceso basados en roles, segregación de entornos y alojamiento regional. Ningún otro inquilino puede acceder a sus datos.Si sus requisitos de seguridad exigen aislamiento físico, Kameleoon ofrece una opción de arquitectura de inquilino único. Póngase en contacto con su Customer Success Manager de Kameleoon para hablar sobre el alojamiento de inquilino único antes de firmar su contrato.
Kameleoon controla el acceso de los empleados a las cuentas de los clientes mediante un modelo de acceso basado en roles y el principio de mínimo privilegio. Los empleados solo reciben acceso cuando una necesidad operativa legítima lo requiere: entrega de servicios, soporte, resolución de problemas, operaciones de seguridad o respuesta a incidentes. El acceso a su cuenta no está disponible de forma general dentro de Kameleoon; solo el personal autorizado con una necesidad documentada puede acceder a ella.

Quién puede acceder a su cuenta

El acceso autorizado puede incluir personal de soporte o servicio asignado a su cuenta. El acceso a nivel de producción está restringido al personal técnico específicamente autorizado. Todo acceso a los sistemas de producción requiere autenticación multifactor (MFA) y está sujeto a revisiones periódicas.

Qué pueden hacer los empleados en su cuenta

Los empleados de Kameleoon no pueden realizar acciones sin restricciones en su cuenta. Los permisos basados en roles, la segregación de entornos y los controles de autorización a nivel de inquilino limitan toda la actividad. Todos los accesos y las acciones administrativas quedan registrados y son auditables.