> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kameleoon.com/llms.txt
> Use this file to discover all available pages before exploring further.

# FAQ

> Antworten auf häufige technische Fragen zu Kameleoon-Implementierungen, Sicherheit und Leistung.

Kameleoon aktualisiert diese Liste regelmäßig mit häufigen Fragen von Kunden.

<AccordionGroup>
  <Accordion title="Welche Kameleoon-Domains muss ich auf die Whitelist setzen?" id="what-are-the-kameleoon-domains-that-i-need-to-whitelist">
    Wenn Ihre Website das Laden von Ressourcen (Skripte, Bilder, Medien, CSS) über den standardmäßigen HTTP-Header **Content-Security-Policy (CSP)** einschränkt, aktualisieren Sie die CSP Ihrer Website, um das Laden von Kameleoon-Ressourcen zu erlauben.

    #### Einfache Einrichtung (mit Wildcards)

    <Warning>
      `script-src` hat immer Vorrang vor `default-src`. Verwenden Sie diese Einrichtung nicht, wenn Sie bereits die vollständige Einrichtung in Ihrer CSP verwenden.
    </Warning>

    Fügen Sie der Konfiguration Ihres CSP-Headers den folgenden Inhalt hinzu:

    ```html theme={null}
    default-src https://*.kameleoon.com https://*.kameleoon.io https://*.kameleoon.eu https://*.kameleoon.net wss://*.kameleoon.com https://*.experimentation.dev;
    ```

    #### Vollständige Einrichtung (vollständig detailliert)

    <Warning>
      Kameleoon fügt dem Produkt regelmäßig neue Funktionen hinzu, was zu zusätzlichen URLs führen kann. Listen Sie alle möglichen Hosts und Ressourcentypen (Skript, Bild usw.) explizit im CSP-Header auf.
    </Warning>

    Ersetzen Sie `[your-site-code]` durch Ihren Kameleoon-[Site-Code](/user-manual/faq#how-do-i-find-my-sitecode) in jeder Zeile, in der er erscheint, und fügen Sie dies Ihrer Konfiguration hinzu:

    ```html theme={null}
    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;
    ```

    Jede URL in der CSP-Richtlinie erfüllt einen bestimmten Zweck:

    ##### Web Experimentation

    * `https://[your-site-code].kameleoon.xx`: Lädt das Anwendungsskript von Kameleoon Web Experimentation, `engine.js` (früher `kameleoon.js` genannt).
    * `https://(eu|na)-data.kameleoon.(eu|io)`: Wird für das Tracking verwendet.
    * `https://logger.kameleoon.io`: Sendet Tracking-Daten zur Protokollierung.
    * `https://data.kameleoon.net`: Erforderlich, wenn Sie das Kameleoon-Simulationstool zum QA von Experimenten über mehrere Subdomains hinweg verwenden.

    ##### Feature Experimentation (clientseitige SDKs)

    * `https://client-config.kameleoon.com`: Erforderlich für SDK-Versionen \< 2.1.0.
    * `https://sdk-config.kameleoon.eu`: Erforderlich für SDK-Versionen >= 2.1.0.
    * `https://(eu|na)-data.kameleoon.(eu|io)`: Wird für das Tracking verwendet.
    * `https://logger.kameleoon.io`: Sendet Tracking-Daten zur Protokollierung.

    ##### Grafische Editoren

    * `https://static.kameleoon.com`: (veraltet) Lädt statische Ressourcen für den alten grafischen Editor.
    * `https://editor.kameleoon.com`: (veraltet) Wird vom alten grafischen Editor verwendet.
    * `https://graphical-editor.kameleoon.com`: Wird vom neuen grafischen Editor verwendet.
    * `https://storage.kameleoon.(eu|io)`: Lädt Bilder, die in mit den grafischen Editoren erstellten Experimenten verwendet werden.

    ##### Prompt-Based Experimentation (PBX)

    * `https://aibuilder.kameleoon.com`: Wird vom Prompt-basierten Editor verwendet.
    * `https://electra.kameleoon.com`: Wird vom Prompt-basierten Editor verwendet.
    * `https://storage.kameleoon.(eu|io)`: Lädt Bilder im Prompt-basierten Editor.
    * `https://api.kameleoon.com`: Lädt kontobezogene Informationen.
    * `https://sdk-config.kameleoon.eu`: Steuert die im Prompt-basierten Editor aktivierten Kameleoon-Feature-Flags.
    * `wss://electra.kameleoon.com` : Wird für den Datenaustausch verwendet.

    ##### Simulation

    * `https://api.kameleoon.com`: Wird von der alten Simulation verwendet.
    * `https://simulation.kameleoon.com`: Wird von der neuen Simulation verwendet.

    ##### Produktempfehlung

    * `https://static.products.kameleoon.com`: Lädt Ressourcen für das Produktempfehlungs-Modul.
    * `https://api.products.kameleoon.com`: API, die vom Produktempfehlungs-Modul verwendet wird.
    * `https://images.products.kameleoon.com`: Lädt Produktbilder für Empfehlungen.

    ##### APIs und Integrationen

    * `https://api.kameleoon.com`: Erforderlich, wenn Sie die Automation API zum Testen direkt aus dem Browser verwenden möchten.
    * `https://customers.kameleoon.com`: Erforderlich, wenn Sie die [SDK API](../feature-experimentation/get-started/overview#api) oder eine von Kameleoon entwickelte benutzerdefinierte Integration verwenden.

    ##### Interne Ressourcen

    <Note>
      Standardmäßig enthält `engine.js` keine Simulationspfade oder anwendungsspezifischen Informationen, um die Skriptgröße zu minimieren. Um diese Details bereitzustellen, laden Sie das vollständige Skript `kameleoonFull.js`, das `engine.js` mit den notwendigen Daten zu internen Ressourcen und Ladeanweisungen versorgt.
    </Note>

    * `https://static.kameleoon.com`: Lädt interne Ressourcen.
    * `https://static.experimentation.dev`: Lädt interne Ressourcen.
    * `https://sdk-config.experimentation.dev`: Steuert die im Kameleoon-Produkt aktivierten Kameleoon-Feature-Flags.
    * `https://eu-data.experimentation.dev`: Sendet Tracking-Daten zu Protokollierungszwecken.

    <Warning>
      Die Domain für Ihre Kameleoon-Skripte `https://[your-site-code].kameleoon.xx` kann von Projekt zu Projekt variieren. Projekte verwenden je nach Erstellungsdatum entweder `kameleoon.eu` oder `kameleoon.io`. Verwenden Sie die in der Kameleoon App für Ihr Projekt angezeigte Domain.
    </Warning>
  </Accordion>

  <Accordion title="Verlangsamt das Skript von Kameleoon (engine.js) meine Website?" id="will-kameleoons-script-enginejs-slow-down-my-website">
    Nein. Das Skript von Kameleoon nutzt modernste Technologie, um asynchron zu laufen (bei Verwendung des asynchronen Installations-Snippets), und bleibt 90 Minuten lang vollständig im Browser-Cache. Es blockiert niemals das Laden der Seite, selbst bei seltenen CDN-Störungen (99,99 % Verfügbarkeit). Im Durchschnitt lädt das Skript in unter 70 ms über eine 4G-Verbindung oder schnellere Netzwerkbedingungen.

    Kameleoon minimiert die Auswirkungen weiter durch fortschrittliche Kompressionstechniken, die TypeScript und Brotli kombinieren, was zu einer Basis-Skriptgröße von nur 28,4 KB führt.

    #### CDN-Bereitstellung und Skalierbarkeit

    Das Skript `engine.js` wird über das **Cloudflare CDN** bereitgestellt, was bedeutet, dass es unabhängig vom Traffic-Volumen Ihrer Website automatisch skaliert. Es gibt keine Lade- oder Verzögerungsprobleme bei beliebigem Traffic-Niveau – Cloudflares globales Netzwerk übernimmt die Bereitstellung, sodass weder Spitzen noch anhaltend hoher Traffic die Skriptleistung für Ihre Besucher beeinträchtigen.

    #### Caching

    Standardmäßig speichert der Browser `engine.js` 90 Minuten lang im Cache, was die wiederkehrenden Ladezeiten für wiederkehrende Besucher minimiert. Wenn Ihr Anwendungsfall eine kürzere Cache-Dauer erfordert, kann diese auf Anfrage auf bis zu 1 Minute reduziert werden. [Kontaktieren Sie den Kameleoon-Support](https://www.kameleoon.com/contact), um diese Einstellung für Ihr Konto anzupassen.

    #### Wichtige Hinweise

    Die Skriptgröße kann je nach Anzahl der von Ihnen durchgeführten Experimente und deren Inhalt (CSS/JavaScript) zunehmen.

    Verwenden Sie für Experimente oder Personalisierungskampagnen, die nicht sofort geladen werden müssen, den [Tag](/user-manual/experimentation/web-experimentation/advanced-experiment-features/predefined-tags) „DELAYED". Dies verzögert das Laden nicht essenzieller Experimente bis nach dem ersten Seitenladevorgang. Kameleoon verwaltet diese intelligent: Es lädt die Konfiguration erst nach 10 Sekunden Inaktivität herunter oder wenn ein Besucher angesprochen und einer Variation zugewiesen wird, die nicht der Kontrollvariante entspricht. Dieser Ansatz sorgt für minimale Auswirkungen auf die Ladeleistung bei gleichzeitiger voller Funktionalität für priorisierte Experimente.

    #### Web Experimentation (engine.js)

    Die engine.js verarbeitet ausgehende Anfragen über eine interne Warteschlange, die ungefähr alle 500 ms läuft. Die Warteschlange bündelt Ereignisse in Batches und sendet bei Bedarf rekursiv weitere Batches. Beim Entladen oder Bereinigen der Seite erzwingt die Engine die sofortige Verarbeitung aller ausstehenden Ereignisse. In Safari speichert die Engine nicht gesendete Ereignisse im Sitzungsspeicher, um Datenverlust zu vermeiden.

    Zudem sendet die Engine alle 60 Sekunden ein Aktivitätsereignis, wenn ein Scroll oder Klick erkannt wird. Wenn keine Aktivität erkannt wird, führt sie keinen zusätzlichen Tracking-Aufruf durch.

    #### Feature Experimentation (SDKs)

    Bei Feature-Flag- und SDK-Anwendungsfällen führt Kameleoon die Flag-Auswertungen nach der Initialisierung lokal durch. Tracking-Anfragen an die Data API werden gebündelt und im Hintergrund gesendet, anstatt einzeln pro Auswertung. Die Bündelung reduziert das Anfragevolumen und verhindert Leistungseinbußen bei Verkehrsspitzen. Das Flush-Intervall ist im SDK konfigurierbar, standardmäßig beträgt es 1 Sekunde.

    #### Ratenlimits der Data API

    Kameleoon wendet Ratenlimits auf die Data API an, um die Zuverlässigkeit des Dienstes zu schützen. Die Limits basieren auf Ihren vertraglich vereinbarten monatlich einzigartigen Besuchern (MUV) und der IP-Adresse des Anforderers. Wenn Sie diese Limits überschreiten, gibt die API HTTP 429 zurück.

    Diese Limits gelten für alle Anfragen, die die Data API erreichen, einschließlich der Tracking-Aufrufe, die `engine.js` automatisch sendet, und der gebündelten Tracking-Anfragen, die Feature Experimentation SDKs senden. In Umgebungen, in denen viele Besucher eine einzige IP-Adresse teilen (zum Beispiel in Büros oder Unternehmensnetzwerken), können IP-basierte Limits auch dann gelten, wenn Ihre gesamten MUV innerhalb des Vertrags bleiben.

    Bei serverseitigen Integrationen können Sie IP-basierte Limits aufheben, indem Sie Ihre Anfragen authentifizieren. Wenn Ihr Anwendungsfall höhere Limits erfordert, [wenden Sie sich an den Kameleoon-Support](https://www.kameleoon.com/contact), um die Optionen zu besprechen.

    Ratenlimits gelten für Ihr gesamtes Kundenkonto, nicht für einzelne Projekte. Wenn ein Projekt übermäßig viele Anfragen erzeugt (beispielsweise weil eine fehlerhafte Implementierung eine Schleife erstellt, die Custom-Data-Events wiederholt sendet), verbraucht dieses Projekt das gemeinsame Konto-Limit und kann HTTP 429-Fehler in all Ihren anderen Projekten verursachen.

    Um das Projekt zu identifizieren, das unerwarteten Traffic erzeugt, verwenden Sie die [Live events](/user-manual/experiment-analytics/analyze-results/data-and-metrics/live-events)-Seite (**Insights > Live events**). Wählen Sie jedes Projekt nacheinander aus und vergleichen Sie die Ereignisanzahl der letzten Stunde oder 24 Stunden mit dem erwarteten Volumen. Ein Projekt, das deutlich mehr Ereignisse erzeugt, als sein Besuchervolumen rechtfertigt (beispielsweise mehrere Millionen Ereignisse bei einem Vertrag mit 100.000 MUV), ist wahrscheinlich die Ursache. Filtern Sie die Ereignisse nach Typ, um die Ursache einzugrenzen: Custom-Data-Events sind die häufigste Ursache, oft weil eine fehlerhafte Schleife dieselbe Custom-Data-Variable oder alle Custom-Data-Variablen bei jedem Seitenaufruf sendet.

    #### Skalierbarkeit der Plattform

    Die Kameleoon-Plattform verwendet horizontale Skalierung, Auto-Scaling-Infrastruktur, Lastverteilung sowie regelmäßige Last- und Stresstests. Weitere Details finden Sie unter [Wie unterstützt die Plattform von Kameleoon Skalierbarkeit und Elastizität?](#how-does-kameleoons-platform-support-scalability-and-elasticity).
  </Accordion>

  <Accordion title="Warum verwendet die Kameleoon-Engine (Anwendungsdatei engine.js) die eval()-Funktion?">
    Die Kameleoon-JavaScript-Engine benötigt die `eval()`-Funktion, um benutzerdefinierten Code zu Kameleoon hinzuzufügen, wie z. B. benutzerdefinierte Daten und benutzerdefiniertes JavaScript, wenn Variationen einer Seite implementiert werden. Die `eval()`-Funktion ermöglicht es Kameleoon, diesen benutzerdefinierten Code dynamisch zur Laufzeit auszuführen.

    Wenn Sie eine Content-Security-Policy-(CSP)-Direktive verwenden, die die Verwendung der `eval()`-Funktion verhindert, implementieren Sie das folgende JavaScript-Snippet vor dem Kameleoon-Installations-Tag:

    ```html theme={null}
    <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>
    ```

    <Note>
      Wenn Ihre CSP `eval()` blockiert, hebt die Implementierung des Code-Snippets diese Einschränkungen nicht auf. Um die volle Funktionalität sicherzustellen, passen Sie die entsprechende CSP-Direktive an, um `eval()` oder ähnliche Funktionen zuzulassen. Andernfalls bleiben bestimmte erweiterte Targeting- oder Anpassungsfunktionen in Kameleoon aufgrund der Browser-Sicherheitsdurchsetzung unzugänglich.
    </Note>

    Der grafische Editor von Kameleoon (einschließlich des Simulationspanels) erfordert ebenfalls die `eval()`-Funktion. Sie können diese Anforderung jedoch umgehen, indem Sie die Kameleoon Chrome-Erweiterung installieren und die Einstellung **Dev Tools > Tag injection > Bypass policies** aktivieren, um die Richtlinien lokal zu überschreiben. Sie müssen außerdem Ihren Sitecode angeben. Das Aktivieren der Einstellung **Bypass policies** ermöglicht es Ihnen, den grafischen Editor in einem Chrome-Browser zu verwenden.

    <Frame>
      ![Bypass-policies-Einstellung in der Chrome-Erweiterung](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/web-experimentation/faq/tag-injection.png)
    </Frame>

    Einige Funktionen von Kameleoon sind nicht verfügbar, wenn eine CSP-Direktive die `eval()`-Funktion blockiert. Diese Einschränkungen gelten auch dann, wenn Sie eines der in der FAQ erwähnten Code-Snippets oder Workarounds verwenden. Die folgenden Funktionen bleiben nicht verfügbar, sofern Ihre CSP `eval()` nicht explizit zulässt:

    * Ansprechen eines Segments mit einer benutzerdefinierten JavaScript-Bedingung (nur unterstützt, wenn **die Bedingung asynchron ausgeführt wird**).

    <Frame>
      ![Asynchrone Einstellung der Targeting-Bedingung](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/web-experimentation/faq/no-eval-run-async.png)
    </Frame>

    * Verwendung benutzerdefinierter Daten mit benutzerdefiniertem JavaScript-Code.
    * Verwendung von Akquisitionskanälen mit benutzerdefiniertem JavaScript-Code.
  </Accordion>

  <Accordion title="Kann ich meinen Server als Proxy für die Tracking-Aufrufe von Kameleoon verwenden?" id="does-kameleoon-offer-on-premise-tracking-request-urls">
    Ja, Kameleoon bietet diese erweiterte Option an. Leiten Sie alle HTTP-Anfragen, die auf Ihrem Server eingehen, an `(eu|na)-data.kameleoon.(eu|io)` weiter. Wenn Sie beispielsweise `tracking.yourdomain.com` als Ihre Tracking-Domain wählen, wäre eine Tracking-Anfrage ein POST an `tracking.yourdomain.com`. Ihr Server sollte die Anfrage dann zusammen mit allen erforderlichen Daten und Parametern an den Host `(eu|na)-data.kameleoon.(eu|io)` weiterleiten. Um diese Option zu aktivieren, wenden Sie sich an Ihren Customer Success Manager.

    <Warning>
      Stellen Sie beim Weiterleiten von Anfragen an `(eu|na)-data.kameleoon.(eu|io)` sicher, dass Sie die Anfrage-URL in `(eu|na)-data.kameleoon.(eu|io)` umschreiben. Es reicht nicht aus, die Anfrage einfach weiterzuleiten und den ursprünglichen HTTP-Header **Host:** auf Ihre Domain gesetzt zu lassen. Setzen Sie den Header **Host:** auf `(eu|na)-data.kameleoon.(eu|io)`.
    </Warning>
  </Accordion>

  <Accordion title="Kann ich Subresource Integrity (SRI) mit der Kameleoon-Anwendungsdatei verwenden?">
    Leider nein. Obwohl SRI eine nützliche Sicherheitsfunktion bietet, ändert sich die Kameleoon-Anwendungsdatei im Laufe der Zeit. Andernfalls wären Funktionen wie das sofortige Starten und Stoppen von Experimenten ohne erneute Bereitstellung unmöglich. Da sich der Dateiinhalt ändert, ändert sich auch der Ressourcen-Hash, was bedeutet, dass SRI nicht verwendet werden kann. Andernfalls würde der Browser die Ressource blockieren, sobald sie auf den Servern aktualisiert wird.
  </Accordion>

  <Accordion title="Warum lädt meine Website mit einem starken Flash-/Flicker-Effekt auf Firefox?">
    Dies ist ein [bekannter Fehler in Firefox](https://bugzilla.mozilla.org/show_bug.cgi?id=1404468). Bis das Firefox-Team ihn behebt, befolgen Sie diesen Workaround: Stellen Sie sicher, dass auf Ihre verlinkte CSS-Ressource ein `<script>`-Tag folgt (auch ein nahezu leeres).

    Beispiel:

    ```html theme={null}
    <link href="https://www.example.com/web/style.css" media="all" rel="stylesheet" type="text/css" />
    <script>/**/</script>
    ```

    Dies entfernt den Flackereffekt vollständig.
  </Accordion>

  <Accordion title="Kann ich minifizierte Versionen der Installations-Tags verwenden?">
    Kameleoon-Skripte sind bereits kurz, und die Verwendung einer minifizierten Version beeinflusst die Seitenladezeit nicht wesentlich, da der Code bereits mit Brotli oder Gzip komprimiert ist. Kameleoon empfiehlt minifizierte Versionen nicht, aber falls erforderlich, sind sie unten verfügbar.

    #### Asynchrones Laden mit Anti-Flicker

    ```html theme={null}
    <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>
    ```

    #### Sitzungsdaten über Subdomains vereinheitlichen

    Wenn Sie das Tag zur Vereinheitlichung von Sitzungsdaten verwenden, um [Sitzungsdaten über Subdomains zu vereinheitlichen](./technical-concepts/unify-session-data-storage-across-subdomains), entweder mit dem synchronen Tag oder dem asynchronen Tag ohne Anti-Flicker:

    ```html theme={null}
    <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>
    ```

    Wenn Sie das Tag zur Vereinheitlichung von Sitzungsdaten und das asynchrone Tag mit Anti-Flicker verwenden, fügen Sie die drei Skript-Tags in der folgenden Reihenfolge hinzu:

    1. Asynchrones Tag mit Anti-Flicker.
    2. Tag zur Vereinheitlichung von Sitzungsdaten.
    3. Kameleoon-Installations-Tag.

    ```html theme={null}
    <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>
    ```
  </Accordion>

  <Accordion title="Kann ich das von Kameleoon bereitgestellte Installations-Tag ändern?">
    Ändern Sie keine Installations-Tags. Ihr Code ist umfassend getestet und optimiert. Änderungen können zu einer nicht funktionierenden Einrichtung führen. Wenn ein Installations-Tag geändert werden muss, wenden Sie sich an Ihren Customer Success Manager, um sich mit den Entwicklern abzustimmen. Versuchen Sie keine eigenständigen Änderungen.
  </Accordion>

  <Accordion title="Kann ich das Installations-Tag in einem separaten externen Skript hinzufügen?">
    Schließen Sie kein Installations-Tag in ein eigenes separates externes Skript ein. Tun Sie zum Beispiel niemals Folgendes:

    ```html theme={null}
    <script src="resources/scripts/kameloon-loader.js" fetchpriority="high" async></script>
    ```

    Obwohl dies technisch funktionieren kann, beeinträchtigt es die Leistung von Kameleoon erheblich und verursacht einen merklichen Flackereffekt. Diese Einrichtung schafft die Probleme der Verwendung eines Tag Managers ohne damit verbundene Vorteile.
  </Accordion>

  <Accordion title="Ist es möglich, Daten im Fall dedizierter Datenspeicher-Cluster (On-Premises-Setup) zu verschlüsseln?">
    Ja, die Partitionen, in denen die Daten gespeichert sind, können verschlüsselt werden. Diese Option erfordert zusätzliche Einrichtungskosten. Wenden Sie sich an Ihren Customer Success Manager für weitere Informationen.
  </Accordion>

  <Accordion title="Kann ich nicht essenzielle Experimente bis nach dem ersten Seitenladevorgang verzögern?" id="can-i-delay-non-essential-experiments-until-after-the-first-page-load">
    Ja, Sie können nicht essenzielle Experimente bis nach dem ersten Seitenladevorgang verzögern. Um ein Experiment zu verzögern, fügen Sie den Tag `DELAYED` den Experimenten hinzu, die Sie verschieben möchten. Weitere Informationen finden Sie in der Dokumentation zur [Tag-Verwaltung](/user-manual/experimentation/web-experimentation/manage-your-web-experiments/manage-your-experiments#Manage_tags).

    Kameleoon verwaltet als „DELAYED" markierte Experimente intelligent. Es lädt die Konfiguration erst nach 10 Sekunden Inaktivität herunter oder wenn der Besucher angesprochen und einer Variation zugewiesen wird, die nicht der Kontrollvariante entspricht. Konzentrieren Sie sich darauf, das beste Nutzererlebnis zu bieten, indem Sie ressourcenintensive Tests verschieben.
  </Accordion>

  <Accordion title="Wie unterstützt die Plattform von Kameleoon Skalierbarkeit und Elastizität?" id="how-does-kameleoons-platform-support-scalability-and-elasticity">
    Die Plattform von Kameleoon bietet hohe Skalierbarkeit und Elastizität und gewährleistet optimale Leistung, wenn die Datenmengen wachsen. Die Plattform bewältigt eine durchschnittliche Last von 20.000 Abfragen pro Sekunde mit Spitzen von bis zu 100.000 Abfragen. Zu den Schlüsselfaktoren gehören:

    * **Skalierbare Architektur**: Eine verteilte und modulare Architektur ermöglicht horizontale Skalierung.
    * **Auto-Scaling-Infrastruktur**: Die cloudbasierte Infrastruktur skaliert Rechenressourcen automatisch.
    * **Lastverteilung**: Fortgeschrittene Techniken verteilen den Traffic gleichmäßig auf die Server.
    * **Datenaufnahme und -verarbeitung**: Robuste APIs und ein Data Broker verwalten große Datenmengen effizient.
    * **Skalierbarkeitstests**: Regelmäßige Last- und Stresstests stellen sicher, dass das System extreme Bedingungen bewältigt.
    * **Elastische Datenspeicherung**: Mehrstufiger Speicher ermöglicht schnellen Datenzugriff und langfristige Skalierbarkeit.
  </Accordion>

  <Accordion title="Welche Datenbanken und Frameworks verwendet Kameleoon?">
    Kameleoon verwendet die folgenden NoSQL-Datenbanken und -Technologien in der Datenfluss-Architektur:

    * Hadoop File System (zusammen mit Spark)
    * Cassandra
    * ClickHouse
    * Kafka
  </Accordion>

  <Accordion title="Welche Netzwerkanfragen stellt die Kameleoon-Engine?">
    Die Kameleoon-Engine initiiert mehrere Netzwerkanfragen, um eine reibungslose Funktionalität zu gewährleisten:

    #### Segments-Anfrage

    * **Zweck**: Erfasst Ereignisse für die vom Besucher angesprochenen Segmente.
    * **Endpoint**: `https://${SITECODE}.kameleoon.io/audiences/segments.js`
    * **Methode**: GET
    * **Hinweis**: Der Browser speichert die Datei 90 Minuten lang im Cache.

    #### Live-Update-Experiments-Konfigurationsanfrage

    * **Zweck**: Ruft die Konfiguration der mit LIVE-UPDATE markierten Experimente ab.
    * **Endpoint**: `https://${SITECODE}.kameleoon.io/live-experiments/config.js`
    * **Methode**: GET
    * **Hinweis**: Der Browser speichert die Datei 2 Minuten lang im Cache.

    #### Anfrage für verzögerte Experimentvariation

    * **Zweck**: Lädt Variationsdaten für [mit DELAYED markierte Experimente](./faq#can-i-delay-non-essential-experiments-until-after-the-first-page-load).
    * **Endpoint**: `https://${SITECODE}.kameleoon.io/experiments/${action.id}/variations/${variationId}.js`
    * **Methode**: GET
    * **Hinweis**: Der Browser speichert die Datei 30 Tage lang im Cache.

    #### Anfrage für verzögerte Personalisierungsvariation

    * **Zweck**: Lädt Variationsdaten für [mit DELAYED markierte Personalisierungen](./faq#can-i-delay-non-essential-experiments-until-after-the-first-page-load).
    * **Endpoint**: `https://${SITECODE}.kameleoon.io/personalizations/${action.id}/variations/${variationId}.js`
    * **Methode**: GET
    * **Hinweis**: Der Browser speichert die Datei 30 Tage lang im Cache.

    #### Anfrage zu vorherigen Besuchen

    * **Zweck**: Ruft vorherige Besuche für die [geräteübergreifende Abstimmung](../cross-device-experimentation) und die [Echtzeit-Synchronisation von Besuchen](../sdks/web-sdks/js-sdk#synchronizing-custom-data-across-devices) ab.
    * **Endpoint**: `https://(eu|na)-data.kameleoon.(eu|io)/visit/visitor`
    * **Methode**: GET

    #### Anfrage für Tracking-Ereignisse

    * **Zweck**: Zeichnet [Ereignisse](../privacy-and-compliance/data-collection-backend) während der Besuche auf.
    * **Endpoint**: `https://(eu|na)-data.kameleoon.(eu|io)/visit/events`
    * **Methode**: POST

    <Note>
      Kameleoon sendet alle 60 Sekunden ein Ereignis, wenn ein Scroll oder Klick erfolgt. Dies stellt eine korrekte Sitzungsdauer-Verfolgung sicher. Wenn die Engine keine Aktivität erkennt, führt sie keinen zusätzlichen Tracking-Aufruf durch.
    </Note>

    #### IP-Adressenanfrage

    * **Zweck**: Ermöglicht das Ausschließen/Einschließen von Besuchern basierend auf der IP-Adresse.
    * **Endpoint**: `https://(eu|na)-data.kameleoon.(eu|io)/ip`
    * **Methode**: GET
    * **Hinweis**: Kameleoon speichert IPs niemals in Datenbanken. Der Browser des Besuchers verwendet die IP ausschließlich zu Vergleichszwecken.

    #### Geolokalisierungsanfrage

    * **Zweck**: Erhält Geolokalisierungsdaten für Targeting und Analytik.
    * **Endpoint**: `https://(eu|na)-data.kameleoon.(eu|io)/geolocation`
    * **Methode**: GET

    #### Anfrage zum aktuellen Wetter

    * **Zweck**: Gibt die aktuellen Wetterbedingungen zurück.
    * **Endpoint**: `https://(eu|na)-data.kameleoon.(eu|io)/weather/weather`
    * **Methode**: GET

    #### Wettervorhersage-Anfrage

    * **Zweck**: Gibt eine 5-Tage-Wettervorhersage zurück.
    * **Endpoint**: `https://(eu|na)-data.kameleoon.(eu|io)/weather/forecast`
    * **Methode**: GET

    #### Kameleoon-Skript-Erkennungsanfrage

    * **Zweck**: Erkennt den Implementierungsstatus des Kameleoon-Skripts.
    * **Endpoint**: `https://(eu|na)-data.kameleoon.(eu|io)/active-script/event`
    * **Methode**: POST

    #### Produktanfrage

    * **Zweck**: Sammelt Produktereignisse für Targeting und Empfehlungen.
    * **Endpoint**: `https://(eu|na)-data.kameleoon.(eu|io)/product/events`
    * **Methode**: POST

    #### Kameleoon-Konversions-Scores-Anfrage

    * **Zweck**: Ruft prädiktive Scores für das Targeting ab.
    * **Endpoint**: `https://(eu|na)-data.kameleoon.(eu|io)/predict/latestPredictionScoreHistograms`
    * **Methode**: GET
  </Accordion>

  <Accordion title="Sind meine Daten von den Daten anderer Kunden isoliert?" id="is-my-data-isolated-from-other-customers-data">
    Der Standarddienst von Kameleoon basiert auf einer mandantenfähigen SaaS-Architektur. Ihre Daten teilen sich die Infrastruktur mit anderen Mandanten, sind jedoch durch rollenbasierte Zugriffskontrollen, Umgebungstrennung und regionsbasiertes Hosting logisch von allen anderen Kundendaten isoliert. Kein anderer Mandant kann auf Ihre Daten zugreifen.

    Wenn Ihre Sicherheitsanforderungen eine physische Isolation erfordern, bietet Kameleoon eine [Einzelmandanten-Architektur](https://docs.kameleoon.com/developer-docs/web-experimentation/self-hosting/simple-self-hosting-and-on-premises-options#dedizierte-cluster-fuer-die-datenspeicherung) an. Wenden Sie sich vor Vertragsunterzeichnung an Ihren Customer Success Manager, um die verfügbaren Optionen zu besprechen.
  </Accordion>

  <Accordion title="Wie kontrolliert Kameleoon den Mitarbeiterzugriff auf mein Konto?" id="how-does-kameleoon-control-employee-access-to-my-account">
    Kameleoon regelt den Mitarbeiterzugriff auf Kundenkonten nach dem Prinzip der geringsten Privilegien und einem rollenbasierten Zugriffsmodell. Mitarbeiter erhalten nur dann Zugriff, wenn ein legitimer betrieblicher Bedarf es erfordert: Servicebereitstellung, Support, Fehlerbehebung, Sicherheitsbetrieb oder Incident Response. Der Zugriff auf Ihr Konto ist innerhalb von Kameleoon nicht allgemein verfügbar; nur autorisierte Mitarbeiter mit einem dokumentierten Bedarf können darauf zugreifen.

    #### Wer auf Ihr Konto zugreifen kann

    Autorisierter Zugriff kann Support- oder Servicemitarbeiter umfassen, die Ihrem Konto zugeordnet sind. Der Zugriff auf Produktionssysteme ist auf speziell autorisiertes technisches Personal beschränkt. Jeder Zugriff auf Produktionssysteme erfordert eine Multi-Faktor-Authentifizierung (MFA) und unterliegt regelmäßigen Überprüfungen.

    #### Was Mitarbeiter in Ihrem Konto tun können

    Kameleoon-Mitarbeiter können keine uneingeschränkten Aktionen in Ihrem Konto durchführen. Rollenbasierte Berechtigungen, Umgebungstrennung und mandantenspezifische Autorisierungskontrollen schränken alle Aktivitäten ein. Alle Zugriffe und Verwaltungsaktionen werden protokolliert und sind auditierbar.
  </Accordion>
</AccordionGroup>