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

# Amplitude Cohorts

> Importieren Sie Amplitude-Kohorten in Kameleoon, um Besucher auf Basis von Verhaltenssegmenten anzusprechen und prazise A/B-Tests und Personalisierungen durchzufuhren.

<Note>
  Diese Funktion befindet sich in der offenen Beta-Phase und in aktiver Entwicklung. Wenden Sie sich an das [Kameleoon-Support-Team](https://www.kameleoon.com/en/contact), um Unterstutzung bei dieser Integration zu erhalten.
</Note>

[Amplitude](https://amplitude.com/) ist ein Produkt-Analytics-Tool, das Unternehmen dabei hilft, das Nutzerverhalten zu verfolgen, Daten zu analysieren und ihre digitalen Produkte zu verbessern, um Engagement und Wachstum zu steigern.

Die Kameleoon Amplitude Cohorts-Integration ermoglicht es Ihnen, Kohorten von Amplitude mit Kameleoon zu synchronisieren.

## Hauptvorteile

* **Nahtlose Kohorten-Synchronisierung:** Importieren Sie muhelos Benutzersegmente von Amplitude in Kameleoon.
* **Personalisiertes Targeting:** Liefern Sie massgeschneiderte Erfahrungen basierend auf dem Nutzerverhalten.
* **Verbesserte Experimentation:** Fuhren Sie prazise A/B-Tests fur bestimmte Zielgruppen durch.
* **Echtzeit-Updates:** Halten Sie Benutzersegmente automatisch auf dem neuesten Stand.

## Anwendungsfalle

### Experimente mit verhaltensbasiertem Targeting optimieren

Synchronisieren Sie Amplitude-Kohorten mit Kameleoon, um Variations bei Benutzern basierend auf ihrem Echtzeitverhalten zu testen.

Fuhren Sie beispielsweise einen A/B-Test bei Benutzern durch, die eine Produktseite mehrmals aufgerufen, aber nichts in ihren Warenkorb gelegt haben. Testen Sie verschiedene Anreize (z. B. ein zeitlich begrenztes Angebot vs. Social-Proof-Botschaft), um zu ermitteln, welche Strategie die meisten Conversions erzielt.

### Ergebnisse mit Verhaltenssegmentierung analysieren

Schlusseln Sie Kameleoon-Kampagnen mit Amplitude-Kohorten auf, um tiefere Einblicke zu erhalten.

Wenn eine Test- oder Personalisierungskampagne beispielsweise einen Ruckgang der Conversions zeigt, analysieren Sie wichtige Amplitude-Segmente (z. B. hochwertige Kunden, abwanderungsgefahrdete Nutzer), um Muster zu erkennen. Amplitude-Segmente helfen Ihnen zu verstehen, welche Erfahrungen bei verschiedenen Nutzergruppen am besten ankommen, und Ihre Strategie entsprechend zu verfeinern.

### Erfahrungen mit den umfangreichen Nutzererkenntnissen von Amplitude personalisieren

Nutzen Sie die umfangreichen Nutzerdaten von Amplitude wie Verhalten, Lebenszyklusphase oder Kaufhistorie, um in Kameleoon hochrelevante Erlebnisse zu schaffen.

Identifizieren Sie beispielsweise haufige Kaufer, Nutzer, die ihr Abonnement vor Kurzem herabgestuft haben, oder Nutzer, die mit bestimmten Inhalten interagieren. Passen Sie dann Botschaften, Aktionen oder Funktionsempfehlungen in Kameleoon an, um Engagement und Conversions zu maximieren.

## Erste Schritte

### Kameleoon Visitor Code als Amplitude User Property speichern

Fugen Sie diesen Code unmittelbar nach der `amplitude.init()`-Funktion in Ihr Amplitude SDK ein:

```javascript theme={null}
// Ensure the SDK is loaded before setting user properties
 const identifyEvent = new amplitude.Identify();
 identifyEvent.set('kameleoon_visitorcode', Kameleoon.API.Visitor.code); 
 amplitude.identify(identifyEvent);
```

Sie konnen die Eigenschaft `kameleoon_visitorcode` anschliessend in Amplitude einsehen.

### Ihren Kameleoon API Key generieren

<Note>
  Bitte beachten Sie, dass Sie ein [Kameleoon Client-Secret](../../../account-and-team-management/users-and-teams/api-credentials) benotigen, das Sie von Ihrem Kameleoon Customer Success Manager erhalten konnen.
</Note>

Offnen Sie diese URL in Ihrem Browser und ersetzen Sie die Platzhalter durch Ihre [Kameleoon Client ID](../../../account-and-team-management/users-and-teams/api-credentials) und Ihr [Client Secret](../../../account-and-team-management/users-and-teams/api-credentials), um Ihren Kameleoon API Key zu generieren.

`https://customers.kameleoon.com/kameleoon/amplitude/getapikey?id=CLIENT ID&secret=CLIENT SECRET`

## Die Kameleoon-Integration in Kameleoon aktivieren

Suchen Sie die Kameleoon Cohorts-Integration in Ihrem Amplitude-Konto unter **Data** > **Catalog** > **Destinations**.

### Mit Kameleoon verbinden

* **Neues Ziel erstellen:** Klicken Sie auf **Kameleoon Cohorts**.
* **Integration einrichten:**
  * **Name:** Geben Sie einen Namen fur die Verbindung an (z. B. Kameleoon Cohorts).
  * **Kameleoon API Key:** Geben Sie den zuvor generierten Kameleoon API Key ein.
  * **Kameleoon Sitecode:** Geben Sie hier Ihren [project sitecode](../../../faq#how-do-i-find-my-sitecode) ein.
  * **Kameleoon Visitor Code:** Wahlen Sie die User Property `kameleoon_visitorcode` aus. Wenn Sie sie nicht finden konnen, beachten Sie bitte den Abschnitt "Store Kameleoon Visitor Code as an Amplitude User Property".
* **Integration speichern:** Klicken Sie auf **Save**.

### Cohort Sync in Amplitude aktivieren

Navigieren Sie zu Ihren Cohorts und beginnen Sie mit der Erstellung der Cohort Sync. Wahlen Sie Kameleoon Cohorts, das API-Ziel fur die Synchronisierung und die Sync-Frequenz aus.

## Amplitude-Kohorten in Ihren Kameleoon-Kampagnen nutzen

### Custom Data zur Ansprache von Amplitude-Kohorten in Ihren Experimenten erstellen

Um ein Segment basierend auf Amplitude-Kohorten zu erstellen, richten Sie eine Custom Data unter **Kameleoon** > **Configure** > **Custom data** ein.

#### Amplitude-Kohorten fur clientseitige Experimente abrufen

* **Eine neue Custom Data erstellen:** Klicken Sie auf **New custom data**.
* **Die Custom Data einrichten:**
  * **Name:** Amplitude Cohorts.
  * Wahlen Sie Ihr Projekt.
  * **Abrufmethode wahlen:** Custom JavaScript code.

<Frame>
  ![](https://storage.googleapis.com/kameleoon-storage-documentation/user-manual/images/integrations/as-a-source/analytics/amplitude-cohorts/AmplitudeCohorts.png)
</Frame>

Fugen Sie dieses Snippet in das dafur vorgesehene Feld ein.

```javascript theme={null}
Kameleoon.API.Data.retrieveDataFromRemoteSource("AMPLITUDE_COHORTS_" + Kameleoon.API.Visitor.code, function (data) {
  if (data?.cohorts) {
  data.amplitude_cohorts.map(function (segment) {
 Kameleoon.API.Data.setCustomData("Amplitude Cohorts", segment);
});
  }
 });
 return { "value": null}
```

* **Type:** List.
* **Format:** String.
* **Scope:** Der Scope kann je nach Anwendungsfall auf **Page** gesetzt werden. Wenn der Scope Page ist, werden die Daten bei jedem Seitenaufruf neu ausgewertet, wenn der Benutzer in einer bestimmten von Amplitude identifizierten Kohorte ist.

#### Amplitude-Kohorten fur serverseitige Experimente abrufen

* **Eine neue Custom Data erstellen:** Klicken Sie auf **New custom data**.
* **Die Custom Data einrichten:**
  * **Name:** Amplitude Cohorts.
  * Wahlen Sie Ihr Projekt.
  * **Abrufmethode wahlen:** Kameleoon SDK.
  * **Type:** List.
  * **Format:** String.
  * **Scope:** Der Scope kann je nach Anwendungsfall auf **Page** gesetzt werden. Wenn der Scope Page ist, werden die Daten bei jedem Seitenaufruf neu ausgewertet, wenn der Benutzer in einer bestimmten von Amplitude identifizierten Kohorte ist.

Um Amplitude-Kohorten in serverseitigen Experimenten oder Feature Flags zu verwenden, konnen Sie die in der Dokumentation der jeweiligen SDKs beschriebenen Richtlinien einsehen. Wenn Sie beispielsweise das [GO SDK](../../../../developer-docs/sdks/web-sdks/go-sdk#retrieving-data-from-a-remote-source) verwenden, finden Sie in seiner Dokumentation detaillierte Anweisungen.

Das GO SDK verwendet wie unsere anderen SDKs die Methode `getRemoteData()`. Diese Methode ruft die von Amplitude auf unseren Servern gespeicherten Daten ab und macht sie in Ihrem Backend-Code zuganglich.

#### Amplitude-Kohorten-Namen in Kameleoon abrufen

Aktivieren Sie im letzten Schritt der Custom Data-Erstellung die Option **Save the values for the targeting condition associated with the custom data point**.

Fugen Sie dieses Snippet in das dafur vorgesehene Feld ein und ersetzen Sie den Wert `ADD_YOUR_SITECODE` durch Ihren Projekt-Sitecode.

```javascript theme={null}
 var xhr = new XMLHttpRequest();
   xhr.open("GET", 'https://data.kameleoon.io/map/map?siteCode=ADD_YOUR_SITECODE&key=AMPLITUDE_common', false);
   xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
   var amplitudeSegments = [];
   xhr.onreadystatechange = function() { // Call a function when the state changes.
       if (this.readyState === XMLHttpRequest.DONE && this.status === 200)
       {
           var amplitude = JSON.parse(xhr.response);
           amplitude["cohorts"].forEach(function (segment) {
               
            amplitudeSegments.push({value: segment, label: segment});
               
           });
       }
   }
   xhr.send();
   return amplitudeSegments;
```

## Amplitude-Kohorten-IDs in einem Kameleoon-Segment verwenden

Nachdem die Custom Data fur die Amplitude-Kohorten-Namen eingerichtet wurde, konnen Sie Segmente mit dem Kameleoon Segment Builder erstellen, indem Sie die Custom Data wahlen und **is among the values** auswahlen. Dann wird eine Liste aller Kohorten-IDs von Amplitude angezeigt. Die Auswahl einer oder mehrerer Amplitude-Kohorten ermoglicht das Targeting in Personalisierungen und Experimenten.