Experimentergebnisse nach Notion exportieren

Rufen Sie ein Experiment und seine Ergebnisse mit der Automation API ab, wandeln Sie sie in Notion-Seiteneigenschaften um und schreiben Sie den Datensatz mit einem einzigen Python-Skript per Upsert in eine Notion-Datenbank.

Ziel

Dieses Tutorial beschreibt Schritt für Schritt, wie das Skript kameleoon_to_notion.py funktioniert. Anhand einer Kameleoon-Experiment-ID und einer Notion-Datenbank-ID ruft das Skript die Experimentmetadaten und die statistischen Ergebnisse ab, ermittelt die leistungsstärkste Variation, bildet die Daten auf eine Notion-Datenbank Experiments ab und schreibt den Datensatz zurück nach Notion. Ein erneuter Lauf des Skripts für dasselbe Experiment aktualisiert die bestehende Seite, statt ein Duplikat zu erstellen. Die Schritte 1–5 verwenden denselben Ablauf für Anfrage und Abfrage wie das Airtable-Export-Tutorial; nur das Ziel ändert sich.

Die API von Notion verfügt über keinen nativen Upsert. Das Skript emuliert einen: Es fragt die Data Source der Datenbank nach einer Seite ab, deren Titel dem Namen des Experiments entspricht, aktualisiert diese Seite bei einem Treffer oder erstellt andernfalls eine neue. Dieses Tutorial richtet sich an die Notion-API-Version 2025-09-03, die jede Datenbank um eine oder mehrere Data Sources organisiert.

Voraussetzungen

Kameleoon-API-Anmeldedaten. Die Automation API erfordert ein Access Token. Das Skript ruft dieses programmgesteuert anhand einer client_id und eines client_secret über den client_credentials-Grant ab. Siehe Access Token abrufen.
Ein internes Notion-Integrationstoken. Erstellen Sie eine Integration unter notion.so/my-integrations und kopieren Sie deren Token.
Eine Notion-Datenbank mit dem Schema Experiments und den folgenden Eigenschaften: Experiment Name (title), Status (select), Start date (date), End date (date), Notes (rich text), Actual (number), Probability (select) und Result (select).
Die Notion-Datenbank-ID. Öffnen Sie die Datenbank als vollständige Seite (die ID ist die 32-stellige Zeichenkette in der URL, vor dem View-Parameter ?v=).
Python 3.9+ mit der Bibliothek requests (pip install requests).

Teilen Sie die Datenbank mit Ihrer Integration, sonst gibt jede Anfrage object_not_found zurück. Öffnen Sie die Datenbank, gehen Sie zu ••• → Connections → Add connections, und wählen Sie Ihre Integration aus.

Speichern Sie alle Anmeldedaten in Umgebungsvariablen. Codieren Sie Geheimnisse niemals fest im Skript.

export KAMELEOON_CLIENT_ID="..."
export KAMELEOON_CLIENT_SECRET="..."
export NOTION_TOKEN="..."

Das Tutorial verwendet das Beispielexperiment Product Page Redesign (ID 188308) mit zwei Variationen zusätzlich zur Originalversion: Redesign 1 (ID 828220) und Redesign 2 (ID 828221).

1. Bei der Automation API authentifizieren

Endpoint: Rufen Sie ein Access Token ab, indem Sie eine POST-Anfrage an den Token-Endpoint senden.

POST https://api.kameleoon.com/oauth/token

Feld	Typ	Beschreibung
grant_type	String	Auf `client_credentials` setzen.
client_id	String	Ihre Automation-API-Client-ID.
client_secret	String	Ihr Automation-API-Client-Secret.

Beispiel:

def kameleoon_token(client_id, client_secret):
    resp = requests.post(
        "https://api.kameleoon.com/oauth/token",
        headers={"Content-Type": "application/x-www-form-urlencoded"},
        data={
            "grant_type": "client_credentials",
            "client_id": client_id,
            "client_secret": client_secret,
        },
    )
    resp.raise_for_status()
    return resp.json()["access_token"]

Antwort:

{ "access_token": "eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9..." }

Der zurückgegebene access_token wird als Bearer-Token bei jeder weiteren Anfrage an die Automation API gesendet. Access Tokens sind standardmäßig 2 Stunden lang gültig.

2. Das Experiment abrufen

Endpoint: Rufen Sie die Experimentmetadaten ab, indem Sie eine GET-Anfrage an den Endpoint Get an experiment senden.

GET https://api.kameleoon.com/experiments/{experimentId}

Feld	Typ	Beschreibung
experimentId	Integer	Obligatorischer Pfadparameter. Die ID des abzurufenden Experiments.

Beispiel:

def get_experiment(token, experiment_id):
    resp = requests.get(
        f"https://api.kameleoon.com/experiments/{experiment_id}",
        headers={"Authorization": f"Bearer {token}"},
    )
    resp.raise_for_status()
    return resp.json()

Antwort (gekürzt):

{
  "id": 188308,
  "name": "Product Page Redesign",
  "status": "STOPPED",
  "dateStarted": "2025-01-15T09:00:00Z",
  "dateEnded": "2025-02-12T18:00:00Z",
  "description": "Testing two redesigns of the product page.",
  "mainGoalId": 279599,
  "variations": [828220, 828221]
}

Das Skript liest name, status, dateStarted, dateEnded und description für die Notion-Seite sowie mainGoalId, um die Ergebnisanfrage im nächsten Schritt einzugrenzen.

Die API gibt mainGoalId standardmäßig zurück, sodass das Skript keinen optionalFields-Parameter benötigt, um sie zu lesen. Die Automation API veröffentlicht kein festes Enum für das Feld status, und die Token können sich weiterentwickeln. Schritt 7 vergleicht status ohne Berücksichtigung der Groß-/Kleinschreibung, sodass Unterschiede in der Schreibweise zwischen Konten das Mapping nicht beeinträchtigen.

3. Die Ergebnisse des Experiments anfordern

Endpoint: Lösen Sie die Erstellung des Ergebnisberichts aus, indem Sie eine POST-Anfrage an den Endpoint Request experiment’s results senden.

POST https://api.kameleoon.com/experiments/{experimentId}/results

Feld	Typ	Beschreibung
experimentId	Integer	Obligatorischer Pfadparameter.
goalsIds	Array	Beschränkt den Bericht auf die angegebenen Ziel-IDs. Das Skript übergibt die `mainGoalId` des Experiments.
referenceVariationId	String	Die Variation, die als Referenz für den Vergleich verwendet wird. `"0"` verwendet die Originalseite.
visitorData	Boolean	`false` für besuchsbasierte Daten, `true` für besucherbasierte Daten.
sequentialTesting	Boolean	Auf `true` setzen, um Sequential Testing für Konfidenzintervalle anstelle der Bayesianischen Erfolgswahrscheinlichkeit zu verwenden. Aktivieren Sie nur eine der beiden Methoden.
bayesian	Boolean	Auf `true` setzen, um die Bayesianische Erfolgswahrscheinlichkeit in den Bericht aufzunehmen. Das Skript liest diesen Wert aus, um die Eigenschaft Probability zu befüllen.
conversionType	String	`ALL_CONVERSION` oder `CONVERTED_VISITS`.

Beispiel:

def request_results(token, experiment_id, goal_id):
    body = {
        "visitorData": False,
        "sequentialTesting": False,
        "bayesian": True,
        "referenceVariationId": "0",
        "conversionType": "ALL_CONVERSION",
        "goalsIds": [goal_id] if goal_id else None,
    }
    resp = requests.post(
        f"https://api.kameleoon.com/experiments/{experiment_id}/results",
        headers={
            "Authorization": f"Bearer {token}",
            "Content-Type": "application/json",
            "Accept": "*/*",
        },
        json=body,
    )
    resp.raise_for_status()
    return resp.json()["dataCode"]

Antwort:

{ "dataCode": "14443931880924098266207585267983330260134079899081739889989435434342588016765" }

Kameleoon erstellt den Bericht asynchron. Der Endpoint gibt einen dataCode zurück, der im nächsten Schritt zum Abfragen des Ergebnisses verwendet wird.

Dieses Skript erfordert bayesian: true und setzt sequentialTesting: false. bayesian und sequentialTesting sind alternative Methoden zur Berechnung der Signifikanz, und dieses Tutorial gibt die Bayesianische Erfolgswahrscheinlichkeit aus. Bei aktiviertem Bayesian-Modus trägt der Wert reliability des Berichts die Bayesianische Erfolgswahrscheinlichkeit (die Wahrscheinlichkeit, dass eine Variation die Referenz übertrifft), die das Skript auf die Eigenschaft Probability abbildet. Gleichen Sie den Wert mit demselben Bericht in der Kameleoon-App ab, wenn Ihr Konto eine andere Standardstatistikmethode verwendet.

4. Die Ergebnisse abfragen

Endpoint: Rufen Sie den Bericht ab, indem Sie GET-Anfragen an den Endpoint Poll results senden, bis er bereit ist.

GET https://api.kameleoon.com/results?dataCode={dataCode}

Feld	Typ	Beschreibung
dataCode	String	Obligatorischer Query-Parameter, der vom vorherigen Schritt zurückgegeben wird.

Der status der Antwort lautet WAITING, solange der Bericht berechnet wird, READY, sobald die Daten verfügbar sind, oder ERROR beziehungsweise TIMEOUT bei einem Fehler. Wenn der Status ERROR oder TIMEOUT lautet, enthält die Antwort ein errorDescription-Feld auf oberster Ebene. Das Skript fragt in einem festen Intervall ab, bis der Status READY lautet. Beispiel:

def poll_results(token, data_code, max_attempts=30, delay=2.0):
    for _ in range(max_attempts):
        resp = requests.get(
            "https://api.kameleoon.com/results",
            headers={"Authorization": f"Bearer {token}"},
            params={"dataCode": data_code},
        )
        resp.raise_for_status()
        payload = resp.json()
        status = payload.get("status")
        if status == "READY":
            return payload["data"]
        if status in ("ERROR", "TIMEOUT"):
            raise RuntimeError(payload.get("errorDescription") or status)
        time.sleep(delay)  # status == "WAITING"
    raise TimeoutError("Timed out waiting for results.")

Antwort (gekürzt):

{
  "status": "READY",
  "data": {
    "variationData": {
      "_reference": { "breakdownData": { "_reference": { "generalData": {
        "goalsData": { "279599": { "conversionRate": 0.0149 } } } } } },
      "828220": { "breakdownData": { "_reference": { "generalData": {
        "goalsData": { "279599": {
          "reliability": 100.0,
          "improvementRate": 211.48,
          "conversionRate": 0.0466
        } } } } } },
      "828221": { "breakdownData": { "_reference": { "generalData": {
        "goalsData": { "279599": {
          "reliability": 100.0,
          "improvementRate": -43.33,
          "conversionRate": 0.0085
        } } } } } }
    }
  }
}

5. Die leistungsstärkste Variation auswählen

Die Ergebnisse enthalten unter variationData einen Eintrag pro Variation sowie die Zeile _reference für die Originalseite. Für jede Variation liegen die Metriken für das angeforderte Ziel unter breakdownData._reference.generalData.goalsData[goalId]. Das Skript überspringt den Eintrag _reference, liest für jede Variation improvementRate und reliability (die Bayesianische Erfolgswahrscheinlichkeit) und wählt die Variation mit der höchsten Verbesserungsrate als leistungsstärkste aus. Enthält das goalsData einer Variation die angeforderte Goal-ID nicht, greift das Skript auf das vorhandene Goal zurück, welches auch immer das ist; da Schritt 3 die Anfrage bereits auf ein einzelnes Goal über goalsIds beschränkt, gibt es bei diesem Fallback normalerweise nichts anderes zur Auswahl. Die später abgebildete Eigenschaft Result erfasst, ob diese Variation eine ausreichend hohe Erfolgswahrscheinlichkeit bei einer positiven Verbesserung erreicht hat, um als echter Gewinner zu zählen. Beispiel:

def pick_best_variation(result_data, goal_id):
    best, best_improvement = {}, float("-inf")
    for variation_id, vdata in result_data["variationData"].items():
        if variation_id == "_reference":
            continue
        general = vdata["breakdownData"]["_reference"]["generalData"]
        goals_data = general.get("goalsData", {})
        if not goals_data:
            continue
        key = str(goal_id) if str(goal_id) in goals_data else next(iter(goals_data))
        metrics = goals_data[key]
        improvement = metrics.get("improvementRate")
        if improvement is not None and improvement > best_improvement:
            best_improvement = improvement
            best = {
                "variation_id": variation_id,
                "improvement_rate": improvement,
                "bayesian_probability": metrics.get("reliability"),
            }
    return best

Im Beispiel erreichen beide Variationen eine Bayesianische Erfolgswahrscheinlichkeit von 100 %, aber Redesign 1 (828220) zeigt eine Verbesserung von +211,48 % gegenüber -43,33 % bei Redesign 2. Redesign 1 ist daher die leistungsstärkste Variation und, mit einer Wahrscheinlichkeit über 95 % und einer positiven Verbesserung, ein echter Gewinner.

6. Die Notion-Data-Source auflösen

Seit Version 2025-09-03 ist eine Notion-Datenbank ein Container für eine oder mehrere Data Sources, und Seiten-Schreibvorgänge sowie Abfragen zielen auf eine Data-Source-ID statt auf die Datenbank-ID. Die beiden IDs sind nicht austauschbar. Endpoint: Rufen Sie die Datenbank ab, um ihre Data Sources zu ermitteln, indem Sie eine GET-Anfrage an den Endpoint Retrieve a database senden.

GET https://api.notion.com/v1/databases/{databaseId}

Jede Notion-Anfrage sendet das Integrationstoken als Bearer-Token sowie den Header Notion-Version. Beispiel:

NOTION_VERSION = "2025-09-03"


def notion_headers(token):
    return {
        "Authorization": f"Bearer {token}",
        "Notion-Version": NOTION_VERSION,
        "Content-Type": "application/json",
    }


def get_data_source_id(token, database_id):
    resp = requests.get(
        f"https://api.notion.com/v1/databases/{database_id}",
        headers=notion_headers(token),
    )
    resp.raise_for_status()
    data_sources = resp.json().get("data_sources", [])
    if not data_sources:
        raise RuntimeError("The database has no data sources.")
    return data_sources[0]["id"]

Antwort (gekürzt):

{
  "object": "database",
  "id": "255104cd-477e-808c-b279-d39ab803a7d2",
  "data_sources": [
    { "id": "bc1211ca-e3f1-4939-ae34-5260b16f627c", "name": "Experiments" }
  ]
}

Das Skript verwendet die erste Data Source. Wenn Ihre Datenbank mehrere bereitstellt, wählen Sie diejenige aus, deren Schema den Experiments-Eigenschaften entspricht.

7. Die Daten auf Notion-Eigenschaften abbilden

Das Skript wandelt die Experimentmetadaten und die Metriken der leistungsstärksten Variation in Notion-Eigenschaftswerte um. Jeder Eigenschaftstyp hat seine eigene JSON-Struktur.

Notion-Eigenschaft	Typ	Quelle	Transformation
Experiment Name	Title	`experiment.name`	Direkt. Wird als Upsert-Schlüssel verwendet.
Status	Select	`experiment.status`	Zugeordnet, ohne Berücksichtigung der Groß-/Kleinschreibung: `active → Running`, `draft`/`planned → Implementing`, `stopped`/`diverted → Completed`, `paused → Defunct`.
Start date	Date	`experiment.dateStarted`	Datum/Uhrzeit, gekürzt auf ein ISO-Datum (`YYYY-MM-DD`).
End date	Date	`experiment.dateEnded`	Datum/Uhrzeit, gekürzt auf ein ISO-Datum.
Notes	Rich text	`experiment.description`	Direkt.
Actual	Number	`improvementRate` der besten Variation	Direkt (gemessene Verbesserung, %).
Probability	Select	Bayesianische Erfolgswahrscheinlichkeit der besten Variation	In Stufen eingeteilt: `≥95 → 80% - High`, `≥80 → 50% - Medium`, sonst `20% - Low`.
Result	Select	Bayesianische Erfolgswahrscheinlichkeit + `improvementRate`	Wahrscheinlichkeit `≥ 95` und Verbesserung > 0 → `Success`; `≥ 95` und Verbesserung < 0 → `Failure`; andernfalls `Inconclusive`.

Das Skript lässt leere Werte aus, sodass bestehende Eigenschaftswerte bei einer Aktualisierung niemals mit leeren Werten überschrieben werden. Notion erstellt fehlende Select-Optionen automatisch, aber die Eigenschaften selbst müssen bereits mit den korrekten Typen im Schema der Data Source vorhanden sein. Beispiel:

STATUS_MAP = {
    "ACTIVE": "Running",
    "DRAFT": "Implementing",
    "PLANNED": "Implementing",
    "PAUSED": "Defunct",
    "STOPPED": "Completed",
    "DIVERTED": "Completed",
}


def map_status(status):
    return STATUS_MAP.get((status or "").upper())


def to_iso_date(value):
    return value[:10] if value else None


def bayesian_to_probability(probability):
    if probability is None:
        return None
    if probability >= 95:
        return "80% - High"
    if probability >= 80:
        return "50% - Medium"
    return "20% - Low"


def derive_result(probability, improvement):
    if probability is None or improvement is None:
        return "Inconclusive"
    if probability >= 95 and improvement > 0:
        return "Success"
    if probability >= 95 and improvement < 0:
        return "Failure"
    return "Inconclusive"


def build_notion_properties(experiment, best):
    probability = best.get("bayesian_probability")
    improvement = best.get("improvement_rate")
    props = {}

    name = experiment.get("name")
    if name:
        props["Experiment Name"] = {"title": [{"text": {"content": name}}]}

    status = map_status(experiment.get("status"))
    if status:
        props["Status"] = {"select": {"name": status}}

    start = to_iso_date(experiment.get("dateStarted"))
    if start:
        props["Start date"] = {"date": {"start": start}}

    end = to_iso_date(experiment.get("dateEnded"))
    if end:
        props["End date"] = {"date": {"start": end}}

    notes = experiment.get("description")
    if notes:
        props["Notes"] = {"rich_text": [{"text": {"content": notes}}]}

    if improvement is not None:
        props["Actual"] = {"number": improvement}

    bucket = bayesian_to_probability(probability)
    if bucket:
        props["Probability"] = {"select": {"name": bucket}}

    result = derive_result(probability, improvement)
    if result:
        props["Result"] = {"select": {"name": result}}

    return props

Notion erlaubt nur eine Title-Eigenschaft pro Data Source. Das Skript verwendet die Eigenschaft mit dem Namen Experiment Name als Upsert-Schlüssel; wenn Ihre Title-Eigenschaft einen anderen Namen hat, benennen Sie sie hier und im Abfragefilter in Schritt 8 entsprechend um.

8. Die Seite per Upsert in Notion schreiben

Notion verfügt über keinen Upsert-Endpoint, daher fragt das Skript die Data Source nach einer Seite ab, deren Experiment Name übereinstimmt, und aktualisiert diese Seite oder erstellt eine neue. Suchen: Fragen Sie die Data Source mit einem Title-Filter über den Endpoint Query a data source ab.

POST https://api.notion.com/v1/data_sources/{dataSourceId}/query

Erstellen: Fügen Sie über den Endpoint Create a page eine Seite hinzu, deren übergeordnetes Element die Data Source ist.

POST https://api.notion.com/v1/pages

Aktualisieren: Überschreiben Sie die Eigenschaften der gefundenen Seite über den Endpoint Update page properties.

PATCH https://api.notion.com/v1/pages/{pageId}

Beispiel:

def find_page(token, data_source_id, name):
    resp = requests.post(
        f"https://api.notion.com/v1/data_sources/{data_source_id}/query",
        headers=notion_headers(token),
        json={
            "filter": {"property": "Experiment Name", "title": {"equals": name}},
            "page_size": 1,
        },
    )
    resp.raise_for_status()
    results = resp.json().get("results", [])
    return results[0]["id"] if results else None


def upsert_page(token, data_source_id, properties):
    title = properties.get("Experiment Name", {}).get("title")
    name = title[0]["text"]["content"] if title else None

    page_id = find_page(token, data_source_id, name) if name else None
    if page_id:
        resp = requests.patch(
            f"https://api.notion.com/v1/pages/{page_id}",
            headers=notion_headers(token),
            json={"properties": properties},
        )
        action = "Updated"
    else:
        resp = requests.post(
            "https://api.notion.com/v1/pages",
            headers=notion_headers(token),
            json={
                "parent": {"type": "data_source_id", "data_source_id": data_source_id},
                "properties": properties,
            },
        )
        action = "Created"
    resp.raise_for_status()
    return resp.json(), action

Antwort (gekürzt):

{
  "object": "page",
  "id": "1a2b3c4d-5e6f-7081-9abc-def012345678",
  "properties": {
    "Experiment Name": { "title": [{ "plain_text": "Product Page Redesign" }] },
    "Status": { "select": { "name": "Completed" } },
    "Start date": { "date": { "start": "2025-01-15" } },
    "End date": { "date": { "start": "2025-02-12" } },
    "Actual": { "number": 211.48 },
    "Probability": { "select": { "name": "80% - High" } },
    "Result": { "select": { "name": "Success" } }
  }
}

9. Das Skript ausführen

Übergeben Sie die Experiment-ID und die Notion-Datenbank-ID als Argumente:

python kameleoon_to_notion.py \
  --experiment-id 188308 \
  --database-id 255104cd477e808cb279d39ab803a7d2

Das Skript gibt jeden Schritt aus: die Authentifizierung, das abgerufene Experiment, die leistungsstärkste Variation, die aufgelöste Data Source, die zugeordneten Eigenschaften sowie, ob die Notion-Seite erstellt oder aktualisiert wurde.

Anpassungshinweise

Status-Mapping befindet sich in der Konstante STATUS_MAP, die anhand der von der API zurückgegebenen Status-Token indiziert ist und ohne Berücksichtigung der Groß-/Kleinschreibung abgeglichen wird. Passen Sie die Zielwerte an, wenn Ihre Status-Optionen von Running / Implementing / Completed / Defunct abweichen, und bestätigen Sie die Token, die Ihr Konto zurückgibt, mit einer einzelnen GET /experiments/{experimentId}-Anfrage.
Probability wird aus der gemessenen Bayesianischen Erfolgswahrscheinlichkeit abgebildet, wofür bayesian: true in der Ergebnisanfrage erforderlich ist. Wenn Ihre Eigenschaft Probability stattdessen eine manuell eingetragene Schätzung vor dem Experiment ist, entfernen Sie den Probability-Block aus build_notion_properties.
Zielauswahl verwendet die mainGoalId des Experiments. Um über ein anderes Ziel zu berichten, übergeben Sie dessen ID an request_results und pick_best_variation.
Upsert-Schlüssel. Der Titelabgleich erfolgt exakt, sodass Unterschiede bei Groß-/Kleinschreibung oder Leerzeichen in Experiment Name eine neue Seite erstellen, statt die bestehende zu aktualisieren. Da der Ablauf aus Suchen und anschließendem Schreiben nicht atomar ist, vermeiden Sie es, zwei Exporte für dasselbe Experiment gleichzeitig auszuführen.
API-Version. Das Skript legt Notion-Version: 2025-09-03 fest. Wenn Sie der Datenbank später eine zweite Data Source hinzufügen, aktualisieren Sie get_data_source_id, damit die richtige anhand ihres Namens ausgewählt wird.
Rate Limits. Die Automation API erlaubt bis zu 50 Anfragen pro 10 Sekunden und 1.000 pro Stunde; die Notion API erlaubt im Durchschnitt etwa 3 Anfragen pro Sekunde. Wenn Sie viele Experimente in Batches verarbeiten, cachen Sie Tokens und fügen Sie eine Drosselung hinzu.

​Ziel

​Voraussetzungen

​1. Bei der Automation API authentifizieren

​2. Das Experiment abrufen

​3. Die Ergebnisse des Experiments anfordern

​4. Die Ergebnisse abfragen

​5. Die leistungsstärkste Variation auswählen

​6. Die Notion-Data-Source auflösen

​7. Die Daten auf Notion-Eigenschaften abbilden

​8. Die Seite per Upsert in Notion schreiben

​9. Das Skript ausführen

​Anpassungshinweise

Ziel

Voraussetzungen

1. Bei der Automation API authentifizieren

2. Das Experiment abrufen

3. Die Ergebnisse des Experiments anfordern

4. Die Ergebnisse abfragen

5. Die leistungsstärkste Variation auswählen

6. Die Notion-Data-Source auflösen

7. Die Daten auf Notion-Eigenschaften abbilden

8. Die Seite per Upsert in Notion schreiben

9. Das Skript ausführen

Anpassungshinweise