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

# JS- und CSS-Code aus Experimenten abrufen

> Rufen Sie JavaScript- und CSS-Code aus den Gewinnervariationen pausierter oder gestoppter Experimente mithilfe der Automation API ab.

Dieser Leitfaden erklärt, wie Sie JavaScript- und CSS-Code aus den Gewinnervariationen von Developer-(codebasierten)-Experimenten abrufen, die seit 2026 pausiert oder gestoppt wurden.

Um den Code abzurufen, führen Sie die folgenden Schritte aus:

1. [Den Filter erstellen](#den-filter-erstellen), um codebasierte Experimente abzurufen, die seit 2026 pausiert oder gestoppt wurden.
2. [Die gefilterten Experimente abrufen](#die-gefilterten-experimente-abrufen) mit dem [Get all experiments-Endpoint](/api-reference/experiment/get-all-experiments).
3. [Die Gewinnervariation identifizieren](#die-gewinnervariation-finden), indem Sie die [Experimentergebnisse abrufen](./retrieving-experiment-results-using-the-automation-api).
4. [Den JS- und CSS-Code abrufen](#den-js-und-css-code-abrufen) mit dem [Get a variation-Endpoint](/api-reference/variation/get-a-variation).

Am Ende dieses Leitfadens finden Sie auch ein [vollständiges Python-Skript](#vollständiges-python-skript), das den Workflow implementiert.

## Voraussetzungen

Bevor Sie die Automation API verwenden, stellen Sie sicher, dass Sie ein Access Token haben.

Um ein Token zu erhalten, lesen Sie den [Authentifizierungsleitfaden](/developer-docs/apis/automation-api-rest/get-started/get-started#1-obtain-an-access-token).

## Den Filter erstellen

Verwenden Sie zum Filtern von Experimenten den Abfrageparameter `filter`. Filtern Sie die Experimente anhand der folgenden Kriterien:

* `status`: Auf `PAUSED` oder `STOPPED` setzen.
* `dateStatusModified`: Auf größer als 1. Januar 2026 setzen.
* `type`: Auf `DEVELOPER` setzen.

### Beispielfilter

```json theme={null}
[
  {
    "field": "status",
    "operator": "IN",
    "parameters": ["PAUSED", "STOPPED"]
  },
  {
    "field": "dateStatusModified",
    "operator": "GREATER",
    "parameters": ["2026-01-01T00:00:00"]
  },
  {
    "field": "type",
    "operator": "IN",
    "parameters": ["DEVELOPER"]
  }
]
```

<Tip>
  So generieren Sie einen gültigen Filter direkt vom Experiment-Dashboard:

  1. Öffnen Sie Ihr [Experiment-Dashboard](/user-manual/experimentation/web-experimentation/manage-your-web-experiments/manage-your-experiments#access-the-experiments-dashboard).
  2. Wenden Sie die gewünschten Filter über die Dashboard-Benutzeroberfläche an.
  3. Öffnen Sie die **Entwicklertools** Ihres Browsers.
  4. Gehen Sie zur Registerkarte **Network**.
  5. Suchen Sie nach der `GetExperiments`-Anfrage.
  6. Öffnen Sie die entsprechende **GraphQL**-Anfrage und wählen Sie die Registerkarte **Payload**.

  Sie können die genaue Filterkonfiguration kopieren, die von der Benutzeroberfläche generiert wurde, und sie in der Automation API wiederverwenden.

  <Frame>
    ![GraphQL filter example](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/apis/automation-api-rest/tutorials/retrieve-js-and-css-code-from-experiments/filter-graphql.png)
  </Frame>
</Tip>

## Die gefilterten Experimente abrufen

Übergeben Sie den Filter als URL-Abfrageparameter. Kodieren Sie das JSON-Filter prozentkodiert, bevor Sie es zur URL hinzufügen.

### Beispielanfrage

```bash theme={null}
curl -L "https://api.kameleoon.com/experiments?filter=%5B%7B%22field%22%3A%22status%22%2C%22operator%22%3A%22IN%22%2C%22parameters%22%3A%5B%22PAUSED%22%2C%22STOPPED%22%5D%7D%2C%7B%22field%22%3A%22dateStatusModified%22%2C%22operator%22%3A%22GREATER%22%2C%22parameters%22%3A%5B%222026-01-01T00%3A00%3A00%22%5D%7D%2C%7B%22field%22%3A%22type%22%2C%22operator%22%3A%22IN%22%2C%22parameters%22%3A%5B%22DEVELOPER%22%5D%7D%5D" \
-H "Accept: */*" \
-H "Authorization: Bearer <ACCESS_TOKEN>"
```

### Beispielantwort

```json theme={null}
[
  {
    "id": 344428,
    "siteId": 31553,
    "name": "TestJavascriptHelpDoc",
    "type": "DEVELOPER",
    "status": "STOPPED",
    "mainGoalId": 396889,
    "variations": [1199120, 1199121],
    "dateStatusModified": "2026-02-09T11:23:31+0100",
    "commonJavaScriptCode": "console.log(\"hello world\");",
    "globalScript": "console.log(\"hello world\");"
  }
]
```

Beachten Sie aus dieser Antwort die folgenden Felder für die nächsten Schritte:

* `id`: Die Experiment-ID.
* `mainGoalId`: Erforderlich, um die Experimentergebnisse abzurufen.
* `variations`: Die Liste der Variations-IDs.

***

## Die Gewinnervariation finden

Um die Gewinnervariation zu identifizieren, führen Sie die folgenden Schritte aus:

1. Rufen Sie die Experimentergebnisse ab. Weitere Informationen finden Sie unter [Experimentergebnisse abrufen](./retrieving-experiment-results-using-the-automation-api).
2. Fügen Sie die `mainGoalId` aus der vorherigen Antwort ein.
3. Vergleichen Sie die `improvementRate` für jede Variation.

### Beispielanfrage

```bash theme={null}
curl -L -X POST "https://api.kameleoon.com/experiments/344428/results" \
-H "Content-Type: application/json" \
-H "Accept: */*" \
-H "Authorization: Bearer <ACCESS_TOKEN>" \
--data-raw '{
  "visitorData": false,
  "sequentialTesting": true,
  "referenceVariationId": "0",
  "goalsIds": [396889]
}'
```

### Antwort

Nach dem Absenden der Anfrage erhalten Sie einen Datencode. Verwenden Sie diesen Code, um die Ergebnisse abzurufen. Weitere Informationen finden Sie im [Leitfaden zum Abrufen von Experimentergebnissen](./retrieving-experiment-results-using-the-automation-api).

### Den Gewinner identifizieren

Suchen Sie in den Antwortdaten die `goalsData` für jede Variations-ID (zum Beispiel `1199120` und `1199121`) und ignorieren Sie die Variation `_reference` (Basislinie).

Vergleichen Sie die `improvementRate` jeder Variation. Die Variation mit der höchsten positiven `improvementRate` ist der Gewinner.

In diesem Beispiel:

* `1199120` hat eine `improvementRate` von **26,57**.
* `1199121` hat eine `improvementRate` von **-15,5**.

Daher ist die Gewinnervariation `1199120`.

## Den JS- und CSS-Code abrufen

Sie finden den Code auf Experimentebene in den folgenden Feldern Ihrer ursprünglichen Experimentantwort:

* `commonJavaScriptCode`
* `commonCssCode`
* `globalScript` (benutzerdefiniertes Experimentskript)

Um den Code auf Variationsebene abzurufen, verwenden Sie den Get a variation-Endpoint.

### Beispielanfrage

```bash theme={null}
curl -L "https://api.kameleoon.com/variations/1199120" \
-H "Accept: */*" \
-H "Authorization: Bearer <ACCESS_TOKEN>"
```

### Beispielantwort

```json theme={null}
{
  "id": 804410,
  "siteId": 24101,
  "name": "Variation 1",
  "jsCode": "(function() {})();",
  "cssCode": "/* Add CSS code to this variation */",
  "isJsCodeAfterDomReady": false
}
```

### Den Code lokalisieren

Sie finden den Code auf Variationsebene in den folgenden Feldern:

* **JavaScript-Code**: `jsCode`
* **CSS-Code**: `cssCode`

## Vollständiges Python-Skript

Das folgende Skript automatisiert den vollständigen Workflow, um den Filter zu erstellen, die Experimente abzurufen, die Gewinnervariation zu finden und den Code zu extrahieren.

```python theme={null}
import requests
import json
import urllib.parse
import time
from datetime import datetime

# ==============================
# Configuration
# ==============================

ACCESS_TOKEN = "<ACCESS TOKEN>"
BASE_URL = "https://api.kameleoon.com"
DATE_FILTER = "2026-01-01T00:00:00"

HEADERS = {
    "Accept": "*/*",
    "Authorization": f"Bearer {ACCESS_TOKEN}"
}


# ==============================
# Step 1: Build and Encode Filter
# ==============================

def build_filter():
    filter_payload = [
        {
            "field": "status",
            "operator": "IN",
            "parameters": ["PAUSED", "STOPPED"]
        },
        {
            "field": "dateStatusModified",
            "operator": "GREATER",
            "parameters": [DATE_FILTER]
        },
        {
            "field": "type",
            "operator": "IN",
            "parameters": ["DEVELOPER"]
        }
    ]

    filter_json = json.dumps(filter_payload)
    encoded_filter = urllib.parse.quote(filter_json)
    return encoded_filter


# ==============================
# Step 2: Retrieve Experiments
# ==============================

def get_filtered_experiments(encoded_filter):
    url = f"{BASE_URL}/experiments?filter={encoded_filter}"
    response = requests.get(url, headers=HEADERS)
    response.raise_for_status()
    return response.json()


# ==============================
# Step 3: Retrieve Experiment Results
# ==============================

def get_experiment_results(experiment_id, main_goal_id):
    url = f"{BASE_URL}/experiments/{experiment_id}/results"

    payload = {
        "visitorData": False,
        "sequentialTesting": True,
        "referenceVariationId": "0",
        "goalsIds": [main_goal_id]
    }

    response = requests.post(url, headers={
        **HEADERS,
        "Content-Type": "application/json"
    }, json=payload)

    response.raise_for_status()
    data_code = response.json()["dataCode"]

    experiment_results = requests.get(f"{BASE_URL}/results?dataCode={data_code}")

    if experiment_results.json().get("status") != "READY":
        print("Results not ready. Waiting 1s and retrying.")
        time.sleep(1)
        experiment_results = requests.get(f"{BASE_URL}/results?dataCode={data_code}")

    return experiment_results.json()


# ==============================
# Step 4: Identify Winning Variation
# ==============================

def get_winning_variation(results_json, main_goal_id):
    variation_data = results_json.get("data", {}).get("variationData", {})

    best_variation_id = None
    best_improvement = float("-inf")

    for variation_id, variation_content in variation_data.items():

        # Skip reference
        if variation_id == "_reference":
            continue

        try:
            goal_data = (
                variation_content["breakdownData"]["_reference"]
                ["generalData"]["goalsData"][str(main_goal_id)]
            )

            improvement = goal_data.get("improvementRate", None)

            if improvement is not None and improvement > best_improvement:
                best_improvement = improvement
                best_variation_id = variation_id

        except KeyError:
            continue

    return best_variation_id, best_improvement


# ==============================
# Step 5: Retrieve Variation Code
# ==============================

def get_variation_code(variation_id):
    url = f"{BASE_URL}/variations/{variation_id}"
    response = requests.get(url, headers=HEADERS)
    response.raise_for_status()
    return response.json()


# ==============================
# Main Workflow
# ==============================

def main():
    print("Building filter...")
    encoded_filter = build_filter()

    print("Retrieving experiments...")
    experiments = get_filtered_experiments(encoded_filter)

    if not experiments:
        print("No experiments found.")
        return

    for experiment in experiments:
        experiment_id = experiment["id"]
        main_goal_id = experiment.get("mainGoalId")

        print(f"\nProcessing experiment {experiment_id}...")

        if not main_goal_id:
            print("No main goal defined. Skipping.")
            continue

        print("Retrieving results...")
        results = get_experiment_results(experiment_id, main_goal_id)

        if results.get("status") != "READY":
            print("Results not ready. Skipping.")
            continue

        winning_variation_id, improvement = get_winning_variation(results, main_goal_id)

        if not winning_variation_id:
            print("No winning variation found.")
            continue

        print(f"Winning variation: {winning_variation_id} (Improvement: {improvement}%)")

        print("Retrieving JS and CSS code...")
        variation_data = get_variation_code(winning_variation_id)

        global_js_code = experiment.get("globalScript","")
        common_css_code = experiment.get("commonCssCode","")
        common_js_code = experiment.get("commonJavaScriptCode","")
        js_code = variation_data.get("jsCode", "")
        css_code = variation_data.get("cssCode", "")
        
        print("\n--- Global JavaScript Code ---")
        print(global_js_code)

        print("\n--- Common JavaScript Code ---")
        print(common_js_code)

        print("\n--- Common CSS Code ---")
        print(common_css_code)

        print("\n--- JavaScript Code ---")
        print(js_code)

        print("\n--- CSS Code ---")
        print(css_code)


if __name__ == "__main__":
    main()
```