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

# Erste Schritte

> Erfahren Sie, wie Sie sich authentifizieren und mit der Kameleoon Automation API beginnen.

Die **Automation API** ist ein REST-konformer Dienst, mit dem Sie die meisten Aktionen, die in der Kameleoon-Weboberfläche verfügbar sind, programmgesteuert ausführen können. Verwenden Sie die Automation API, um benutzerdefinierte Software zu erstellen, die mit der Kameleoon-Plattform und ihren Kernfunktionen interagiert.

Sie können die Automation API beispielsweise verwenden, um:

* Kameleoon mit Git-Repositories zu verbinden, um Variationscode zu verwalten.
* Benutzerdefinierte Dashboards zu entwerfen, die mit Echtzeit-Experimentergebnissen gefüllt sind.
* Die Erstellung von Zielen und Segmenten projektübergreifend zu automatisieren.

<Warning>
  Kameleoon kann Endpoints und Parameter in neuen Versionen der Automation API ändern. Abonnieren Sie Updates im [Kameleoon-Änderungsprotokoll](https://changelog.kameleoon.com/en/), um Benachrichtigungen zu geplanten Änderungen zu erhalten.
</Warning>

<Warning>
  Die Automation API unterstützt keine hohen Anfragevolumen. Begrenzen Sie Aufrufe auf **12 Mal pro Minute** pro Konto oder Benutzer. Verwenden Sie die Automation API nicht für die hochfrequente Verfolgung jedes Website-Besuchers. Verwenden Sie für größere Anfragevolumen die [Data API](../../data-api-rest/overview).
</Warning>

<Note>
  Wenden Sie sich an das Kameleoon-Team, um eine Erweiterung der Automation API anzufordern. Wir schätzen Ihr Feedback und können vorhandene UI-Funktionen schnell zur API hinzufügen.
</Note>

## Tutorials

### Ein Experiment erstellen

Dieses Tutorial bietet eine Schritt-für-Schritt-Anleitung zur Durchführung wichtiger Aufgaben auf der Kameleoon-Plattform. Sie lernen, wie Sie:

* [Ein neues Experiment erstellen](../tutorials/experiments/create-a-new-experiment)
* [JavaScript-Code in einer Variation pushen und ändern](../tutorials/experiments/add-and-edit-javascript-in-the-variant-of-your-new-experiment)
* [Ein neues Segment erstellen](../tutorials/experiments/create-a-segment-to-target-visitors-by-page-url)
* [Ein neues Ziel erstellen](../tutorials/experiments/create-a-new-goal-for-an-experiment)
* [Ein Experiment aktualisieren und starten](../tutorials/experiments/add-a-goal-and-segment-to-your-experiment-before-launching)

### Experimentergebnisse abrufen

Nachdem Sie ein Experiment gestartet haben, werden Ergebnisse generiert, die Einblicke zur Ermittlung der leistungsstärksten Variation bieten. Erfahren Sie im Tutorial [Experimentergebnisse abrufen](../tutorials/experiments/retrieving-experiment-results-using-the-automation-api), wie Sie Ergebnisse anfordern und die gewinnende Variation identifizieren können.

## Authentifizierung

Die Automation API verwendet das OAuth 2.0-Framework zur Autorisierung. Kameleoon unterstützt je nach Anwendungsfall zwei primäre Flows:

* **Client Credentials Flow**: Verwenden Sie diesen Flow, wenn Sie ein Kameleoon-Kunde sind und die API für interne Zwecke verwenden. Dieser Flow ermöglicht es Ihnen, Ihr eigenes Konto und Ihre Web-Properties programmgesteuert zu verwalten.
* **Authorization Code Flow**: Verwenden Sie diesen Flow, wenn Sie ein Technologiepartner sind, der eine Anwendung in Kameleoon integriert. Dieser Flow ermöglicht es Ihnen, sicher auf Daten im Namen anderer Kameleoon-Benutzer zuzugreifen.

### Client Credentials Flow

Der Client Credentials Flow ist die einfachste Authentifizierungsmethode. Um diesen Flow zu verwenden, tauschen Sie Ihre Client-Anmeldedaten gegen ein Zugriffstoken.

<Tip>
  Sie finden Ihre `client_id` und `client_secret` auf der Kameleoon-Plattform. Navigieren Sie zu **Konto > Mein Profil** und klicken Sie auf **Meine API-Anmeldedaten anzeigen**.
</Tip>

#### 1. Ein Zugriffstoken erhalten

Senden Sie eine POST-Anfrage mit Ihren Anmeldedaten an den Token-Endpoint.

```bash curl theme={null}
curl -X POST "https://api.kameleoon.com/oauth/token" \
     -H "Content-Type: application/x-www-form-urlencoded" \
     -d "grant_type=client_credentials" \
     -d "client_id=YOUR_CLIENT_ID" \
     -d "client_secret=YOUR_CLIENT_SECRET"
```

Der Autorisierungsserver antwortet mit einem JSON-Objekt, das das `access_token` enthält:

```json theme={null}
{
  "access_token": "eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9..."
}
```

#### 2. Auf die API zugreifen

Fügen Sie das Zugriffstoken als Bearer-Token in den `Authorization`-HTTP-Header Ihrer Anfragen ein.

```bash curl theme={null}
curl -H "Authorization: Bearer <ACCESS_TOKEN>" \
     -H "Content-Type: application/json" \
     "https://api.kameleoon.com/experiments"
```

* Zugriffstoken bleiben standardmäßig **2 Stunden** gültig.
* Der Client Credentials Flow verwendet keine Refresh-Tokens.
* Sie müssen **HTTPS** für alle API-Anfragen verwenden. Anfragen über reines HTTP schlagen fehl.

### Authorization Code Flow

Der Authorization Code Flow ermöglicht es Drittanbieter-Entwicklern, ihre Anwendungen mit Kameleoon-Daten zu integrieren. Sie müssen die ausdrückliche Genehmigung eines Benutzers einholen, um auf seine Kontoressourcen zugreifen zu können.

<Note>
  Wenden Sie sich an Ihren Kameleoon Technical Account Manager, um eine OAuth-Anwendung anzufordern. Sie müssen eine Weiterleitungs-URL für Ihre Anwendung angeben. Kameleoon stellt dann eine `client_id` und ein `client_secret` bereit.
</Note>

#### 1. Den Benutzer zur Autorisierung weiterleiten

Leiten Sie Benutzer von Ihrer Anwendung zur Autorisierungs-URL weiter:

```https theme={null}
https://api.kameleoon.com/oauth/authorize?client_id=my-application-name&response_type=code&redirect_uri=https://application.company.com/
```

Nachdem der Benutzer die Erlaubnis erteilt hat, leitet Kameleoon den Benutzer mit einem Autorisierungscode an Ihre Anwendungs-URL weiter:

```https theme={null}
https://application.company.com/?code=AUTHORIZATION_CODE
```

#### 2. Zugriffs- und Refresh-Tokens erhalten

Tauschen Sie den Autorisierungscode gegen Tokens aus. Kodieren Sie den String `client_id:client_secret` in Base64 und fügen Sie ihn in den Header `Authorization: Basic` ein.

```bash curl theme={null}
curl -X POST "https://api.kameleoon.com/oauth/token" \
     -H "Content-Type: application/x-www-form-urlencoded" \
     -H "Authorization: Basic <BASE64_ENCODED_CREDENTIALS>" \
     -d "grant_type=authorization_code" \
     -d "code=AUTHORIZATION_CODE" \
     -d "redirect_uri=https://application.company.com/"
```

Die Antwort enthält sowohl Zugriffs- als auch Refresh-Tokens:

```json theme={null}
{
  "access_token": "...",
  "refresh_token": "..."
}
```

#### 3. Ein abgelaufenes Token aktualisieren

Um ein neues Zugriffstoken zu erhalten, ohne den Benutzer erneut zu autorisieren:

```bash curl theme={null}
curl -X POST "https://api.kameleoon.com/oauth/token" \
     -H "Content-Type: application/x-www-form-urlencoded" \
     -H "Authorization: Basic <BASE64_ENCODED_CREDENTIALS>" \
     -d "grant_type=refresh_token" \
     -d "refresh_token=YOUR_REFRESH_TOKEN"
```

## Ratenbegrenzung

Die Ratenbegrenzung für die Automation API erfolgt pro Benutzerzugriffstoken. Kameleoon verwendet zwei Ratenbegrenzungsfenster:

* **10-Sekunden-Intervall**: Bis zu 50 Anfragen.
* **1-Stunden-Intervall**: Bis zu 1.000 Anfragen.

Wenn Sie diese Limits überschreiten, gibt die API einen Fehler `HTTP 429 Too Many Requests` zurück. So minimieren Sie die Ratenbegrenzung:

* **Caching implementieren**: Speichern Sie API-Antworten lokal und vermeiden Sie API-Aufrufe bei jedem Seitenaufruf.
* **Data API verwenden**: Wenn Ihre Anwendung Echtzeit-Tracking in großem Umfang erfordert, verwenden Sie die [Data API](../../data-api-rest/overview).

## HTTP-Statuscodes

| Code | Status            | Beschreibung                                                                                                       |
| :--- | :---------------- | :----------------------------------------------------------------------------------------------------------------- |
| 200  | OK                | Die Anfrage war erfolgreich.                                                                                       |
| 201  | Created           | Die Ressource wurde erfolgreich erstellt.                                                                          |
| 400  | Bad Request       | Der Anfragetext ist ungültig. Stellen Sie sicher, dass der Header `Content-Type: application/json` vorhanden ist.  |
| 401  | Unauthorized      | Das API-Token fehlt oder ist fehlerhaft.                                                                           |
| 403  | Forbidden         | Ihnen fehlen die erforderlichen Berechtigungen oder das Token wurde widerrufen.                                    |
| 429  | Too Many Requests | Sie haben das Ratenlimit überschritten.                                                                            |
| 5xx  | Server Error      | Ein interner Fehler ist aufgetreten. Wenden Sie sich an den Kameleoon-Support, wenn das Problem weiterhin besteht. |

## Abfrageparameter

Verwenden Sie für Endpoints, die mehrere Objekte abrufen, Abfrageparameter, um Daten zu paginieren, zu filtern oder zu sortieren.

### Paginierung

Abfragen geben standardmäßig **20 Elemente pro Seite** zurück (maximal 200). Verwenden Sie `perPage=-1`, um die maximale Grenze abzurufen.

| Parameter | Typ     | Beschreibung                                |
| :-------- | :------ | :------------------------------------------ |
| `page`    | integer | Die abzurufende Seitenzahl.                 |
| `perPage` | integer | Elemente pro Seite (Standard 20, max. 200). |
| `filter`  | array   | Filterparameter.                            |
| `sort`    | array   | Sortierparameter.                           |

### Filterung

Sie müssen Filter prozentkodieren, wenn Sie sie in einer URL senden.
**Beispiel**: `filter=[{"field":"name","operator":"EQUAL","parameters":["Test"]}]`

| Feld         | Typ    | Beschreibung                                                                             |
| :----------- | :----- | :--------------------------------------------------------------------------------------- |
| `field`      | string | Das Feld, nach dem gefiltert werden soll.                                                |
| `operator`   | enum   | Optionen umfassen: `EQUAL`, `NOT_EQUAL`, `LESS`, `GREATER`, `LIKE`, `IN`, `IS_NULL` usw. |
| `parameters` | array  | Die spezifischen Werte, die übereinstimmen sollen.                                       |

### Sortierung

| Feld        | Typ    | Beschreibung                                  |
| :---------- | :----- | :-------------------------------------------- |
| `field`     | string | Das Feld, nach dem sortiert werden soll.      |
| `direction` | enum   | `ASC` (aufsteigend) oder `DESC` (absteigend). |