Exportar los resultados de experimentos a Airtable

Objetivo

Este tutorial describe cómo funciona el script kameleoon_to_airtable.py, paso a paso. Dado un ID de experimento de Kameleoon, un ID de base de Airtable y un ID de tabla de Airtable, el script recupera los metadatos y los resultados estadísticos del experimento, determina la variación con mejor rendimiento, asigna los datos al esquema Experiments de Airtable y escribe el registro en Airtable. Volver a ejecutar el script para el mismo experimento actualiza la fila existente en lugar de crear un duplicado. Este tutorial continúa el tutorial anterior sobre cómo recuperar los resultados de experimentos usando la Automation API y reutiliza el mismo flujo de solicitud y consulta.

Requisitos

Credenciales de la API de Kameleoon. La Automation API requiere un token de acceso. El script obtiene uno de forma programática a partir de un client_id y un client_secret mediante el grant client_credentials. Consulte Obtener un token de acceso.
Un token de acceso personal de Airtable con el alcance data.records:write en la base de destino.
El ID de base y el ID de tabla de Airtable. Ambos aparecen en la URL de la tabla o en la documentación de la API de la base. El ID de base comienza con app, y el ID de tabla, con tbl.
Una tabla de Airtable con el esquema Experiments ya creado. El script escribe en los siguientes campos: Experiment Name, Status, Start date, End date, Notes, Actual, Probability y Result. También espera que existan los campos de entrada manual Assignee, Category, Prediction, Mkt Est, Eng Est y Attachments, aunque nunca los establece. Airtable rechaza la escritura en un nombre de campo que no exista ya en la tabla, y typecast solo convierte los tipos de valor de los campos existentes (no crea campos ni opciones de selección faltantes). Cree la tabla con estos campos, y con las opciones de selección de Status correspondientes, antes de ejecutar el script. Consulte el paso 6 para conocer el valor que recibe cada campo.
Python 3.9 o superior con la biblioteca requests (pip install requests).

Almacene todas las credenciales en variables de entorno. Nunca codifique secretos directamente en el script.

export KAMELEOON_CLIENT_ID="..."
export KAMELEOON_CLIENT_SECRET="..."
export AIRTABLE_TOKEN="..."

El tutorial utiliza el experimento de ejemplo Product Page Redesign (ID 188308), con dos variaciones además de la original: Redesign 1 (ID 828220) y Redesign 2 (ID 828221).

1. Autenticarse con la Automation API

Endpoint: Obtenga un token de acceso enviando una solicitud POST al endpoint de token.

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

Campo	Tipo	Descripción
grant_type	String	Establézcalo en `client_credentials`.
client_id	String	Su ID de cliente de la Automation API.
client_secret	String	Su secreto de cliente de la Automation API.

Ejemplo:

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"]

Respuesta:

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

Envíe el access_token devuelto como token Bearer en cada solicitud posterior a la Automation API. Los tokens de acceso son válidos durante 2 horas de forma predeterminada.

2. Recuperar el experimento

Endpoint: Obtenga los metadatos del experimento enviando una solicitud GET al endpoint Get an experiment.

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

Campo	Tipo	Descripción
experimentId	Integer	Parámetro de ruta obligatorio. El ID del experimento que se va a recuperar.

Ejemplo:

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()

Respuesta (truncada):

{
  "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]
}

El script lee name, status, dateStarted, dateEnded y description para el registro de Airtable, y mainGoalId para acotar la solicitud de resultados en el siguiente paso.

La API devuelve mainGoalId de forma predeterminada, por lo que no necesita un parámetro optionalFields para leerlo. La Automation API no publica una enumeración fija para el campo status, pero otros campos de tipo estado en toda la API usan sistemáticamente tokens en mayúsculas (por ejemplo, STOPPED, ACTIVE, DRAFT). El paso 6 asigna el campo status partiendo de ese supuesto. Confirme los tokens exactos que devuelve su cuenta con una solicitud real antes de confiar en la asignación.

3. Solicitar los resultados del experimento

Endpoint: Active la generación del informe de resultados enviando una solicitud POST al endpoint Request experiment’s results.

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

Campo	Tipo	Descripción
experimentId	Integer	Parámetro de ruta obligatorio.
goalsIds	Array	Restringe el informe a los IDs de objetivo indicados. El script pasa el `mainGoalId` del experimento.
referenceVariationId	String	La variación utilizada como referencia para la comparación. `"0"` utiliza la página original.
visitorData	Boolean	`false` para datos basados en visitas, `true` para datos basados en visitantes.
sequentialTesting	Boolean	Establézcalo en `true` para usar pruebas secuenciales en los intervalos de confianza.
bayesian	Boolean	Establézcalo en `true` para incluir la probabilidad de éxito bayesiana en el informe. El script lee este valor para completar el campo Probability.
conversionType	String	`ALL_CONVERSION` o `CONVERTED_VISITS`.

Ejemplo:

def request_results(token, experiment_id, goal_id):
    body = {
        "visitorData": False,
        "sequentialTesting": True,
        "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"]

Respuesta:

{ "dataCode": "14443931880924098266207585267983330260134079899081739889989435434342588016765" }

Kameleoon genera el informe de forma asíncrona. El endpoint devuelve un dataCode, que el paso 4 utiliza para consultar el resultado.

Este script requiere bayesian: true. Con Bayesian habilitado, el valor reliability del informe representa la probabilidad de éxito bayesiana (la probabilidad de que una variación supere a la referencia), que el script asigna al campo Probability. Confirme el valor con el mismo informe en la aplicación Kameleoon si su cuenta utiliza un método estadístico predeterminado diferente. La especificación de la Automation API marca dateIntervals como obligatorio, pero el ejemplo anterior lo omite y aun así devuelve un informe válido. La especificación no documenta qué valor predeterminado toma un dateIntervals omitido; este tutorial asume que cubre la ejecución completa del experimento, así que confirme ese comportamiento con su propia cuenta antes de confiar en él. Pase un array dateIntervals para acotar el informe a un período específico.

4. Consultar los resultados

Endpoint: Recupere el informe enviando solicitudes GET al endpoint Poll results hasta que esté listo.

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

Campo	Tipo	Descripción
dataCode	String	Parámetro de consulta obligatorio. Use el hash que devolvió `POST /experiments/{experimentId}/results` en el paso 3.

El status de la respuesta es WAITING mientras Kameleoon calcula el informe, READY cuando los datos están disponibles, o ERROR / TIMEOUT en caso de fallo. Cuando el estado es ERROR o TIMEOUT, la respuesta incluye un errorDescription de nivel superior. El script consulta a intervalos fijos hasta que el estado es READY. Ejemplo:

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.")

Respuesta (truncada):

{
  "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. Seleccionar la variación con mejor rendimiento

Los resultados contienen una entrada por variación bajo variationData, además de la línea _reference para la página original. Para cada variación, las métricas del objetivo solicitado se encuentran bajo breakdownData._reference.generalData.goalsData[goalId]. El script omite la entrada _reference, lee el improvementRate y el reliability (la probabilidad de éxito bayesiana) de cada variación, y selecciona como mejor variación la que tiene la tasa de mejora más alta. El campo Result, asignado en el siguiente paso, registra si esa variación realmente ganó: si alcanzó una probabilidad de éxito suficientemente alta con una mejora positiva. Ejemplo:

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

En el ejemplo, ambas variaciones alcanzan una probabilidad de éxito bayesiana del 100%, pero Redesign 1 (828220) muestra una mejora del +211,48% frente al -43,33% de Redesign 2. Por lo tanto, Redesign 1 es la variación con mejor rendimiento y, con una probabilidad superior al 95% y una mejora positiva, una ganadora genuina.

6. Asignar los datos a los campos de Airtable

El script transforma los metadatos del experimento y las métricas de la variación con mejor rendimiento en el esquema Experiments de Airtable.

Campo de Airtable	Origen	Transformación
Experiment Name	`experiment.name`	Directo. Se utiliza como clave de upsert.
Status	`experiment.status`	Asignado sin distinguir mayúsculas y minúsculas: `ACTIVE → Running`, `DRAFT`/`PLANNED → Implementing`, `STOPPED`/`DIVERTED → Completed`, `PAUSED → Defunct`.
Start date	`experiment.dateStarted`	Fecha y hora truncadas a una fecha ISO (`YYYY-MM-DD`).
End date	`experiment.dateEnded`	Fecha y hora truncadas a una fecha ISO.
Notes	`experiment.description`	Directo.
Actual	`improvementRate` de la mejor variación	Directo (mejora medida, %).
Probability	probabilidad de éxito bayesiana de la mejor variación	Agrupado por rangos: `≥95 → 80% - High`, `≥80 → 50% - Medium`, en otro caso `20% - Low`.
Result	probabilidad de éxito bayesiana + `improvementRate`	probabilidad `≥ 95` y mejora > 0 → `Success`; `≥ 95` y mejora < 0 → `Failure`; en cualquier otro caso → `Inconclusive`.

El script no establece los campos que no tienen origen en Kameleoon: Assignee, Category, Prediction, Mkt Est, Eng Est y Attachments. Estos campos permanecen disponibles para introducirlos manualmente en Airtable. El script también omite los valores vacíos, por lo que nunca sobrescribe una celda existente con un valor en blanco. Ejemplo:

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_airtable_fields(experiment, best):
    probability = best.get("bayesian_probability")
    improvement = best.get("improvement_rate")
    fields = {
        "Experiment Name": experiment.get("name"),
        "Status": map_status(experiment.get("status")),
        "Start date": to_iso_date(experiment.get("dateStarted")),
        "End date": to_iso_date(experiment.get("dateEnded")),
        "Notes": experiment.get("description"),
        "Actual": improvement,
        "Probability": bayesian_to_probability(probability),
        "Result": derive_result(probability, improvement),
    }
    return {k: v for k, v in fields.items() if v is not None}

La Automation API no publica una enumeración fija para el campo status del experimento, y los tokens pueden evolucionar. map_status compara sin distinguir mayúsculas y minúsculas, y devuelve None para un estado no reconocido, lo que omite la celda Status en lugar de escribir un valor incorrecto. Confirme los tokens que devuelve su cuenta con una única solicitud GET /experiments/{experimentId} y amplíe STATUS_MAP si es necesario.

7. Insertar o actualizar el registro en Airtable

El endpoint Update table de Airtable (PATCH /v0/meta/bases/{baseId}/tables/{tableId}) solo cambia el nombre y la descripción de una tabla; no puede escribir datos en las filas. Para completar un registro, use el endpoint records con la opción performUpsert.

Endpoint: Cree o actualice el registro enviando una solicitud PATCH al endpoint de registros.

PATCH https://api.airtable.com/v0/{baseId}/{tableId}

Campo	Tipo	Descripción
performUpsert.fieldsToMergeOn	Array	Campo(s) utilizado(s) para hacer coincidir un registro existente. El script combina por `Experiment Name`.
records	Array	Una lista de registros (máximo 10 por solicitud), cada uno con un objeto `fields`.
typecast	Boolean	`true` permite que Airtable convierta cadenas en opciones de selección y analice fechas.

Ejemplo:

def upsert_record(airtable_token, base_id, table_id, fields):
    resp = requests.patch(
        f"https://api.airtable.com/v0/{base_id}/{table_id}",
        headers={
            "Authorization": f"Bearer {airtable_token}",
            "Content-Type": "application/json",
        },
        json={
            "performUpsert": {"fieldsToMergeOn": ["Experiment Name"]},
            "typecast": True,
            "records": [{"fields": fields}],
        },
    )
    resp.raise_for_status()
    return resp.json()

Respuesta (truncada):

{
  "records": [
    {
      "id": "rec0Vh8KLmNoPqRsT",
      "fields": {
        "Experiment Name": "Product Page Redesign",
        "Status": "Completed",
        "Start date": "2025-01-15",
        "End date": "2025-02-12",
        "Actual": 211.48,
        "Probability": "80% - High",
        "Result": "Success"
      }
    }
  ],
  "createdRecords": [],
  "updatedRecords": ["rec0Vh8KLmNoPqRsT"]
}

La respuesta informa el resultado por registro: un ID devuelto bajo createdRecords significa que Airtable creó una fila nueva, mientras que un ID bajo updatedRecords significa que Airtable actualizó una fila existente.

8. Ejecutar el script

Pase el ID del experimento y los ID de base y tabla de Airtable como argumentos:

python kameleoon_to_airtable.py \
  --experiment-id 188308 \
  --base-id appXXXXXXXXXXXXXX \
  --table-id tbll9adSjdedH5t3f

El script imprime cada paso: la autenticación, el experimento obtenido, la variación con mejor rendimiento, los campos asignados y si creó o actualizó el registro de Airtable.

Script completo

El script completo a continuación coincide función por función con kameleoon_to_airtable.py. Cópielo directamente o descargue el archivo desde ese enlace.

#!/usr/bin/env python3
"""Export a Kameleoon experiment's results to an Airtable *Experiments* table.

Given a Kameleoon experiment ID, an Airtable base ID, and an Airtable table ID,
this script:

  1. Authenticates with the Automation API (client_credentials grant).
  2. Retrieves the experiment metadata.
  3. Requests the experiment's results (with the Bayesian success probability).
  4. Polls until the report is ready.
  5. Selects the best-performing variation.
  6. Maps the data onto the Airtable *Experiments* schema.
  7. Upserts the record into Airtable, keyed on "Experiment Name".

Credentials are read from environment variables (never hard-code secrets):

    export KAMELEOON_CLIENT_ID="..."
    export KAMELEOON_CLIENT_SECRET="..."
    export AIRTABLE_TOKEN="..."

Usage:

    python kameleoon_to_airtable.py \
        --experiment-id 188308 \
        --base-id appXXXXXXXXXXXXXX \
        --table-id tbll9adSjdedH5t3f
"""

import argparse
import os
import sys
import time

import requests

# Maps the uppercase status tokens returned by the Automation API to the
# options of the Airtable *Status* field. Adjust the target values if your
# *Status* options differ, and confirm the tokens your account returns with a
# single GET /experiments/{experimentId}.
STATUS_MAP = {
    "ACTIVE": "Running",
    "DRAFT": "Implementing",
    "PLANNED": "Implementing",
    "PAUSED": "Defunct",
    "STOPPED": "Completed",
    "DIVERTED": "Completed",
}


# --------------------------------------------------------------------------- #
# 1. Authenticate with the Automation API
# --------------------------------------------------------------------------- #
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"]


# --------------------------------------------------------------------------- #
# 2. Retrieve the experiment
# --------------------------------------------------------------------------- #
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()


# --------------------------------------------------------------------------- #
# 3. Request the experiment's results
# --------------------------------------------------------------------------- #
def request_results(token, experiment_id, goal_id):
    body = {
        "visitorData": False,
        "sequentialTesting": True,
        "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"]


# --------------------------------------------------------------------------- #
# 4. Poll for the results
# --------------------------------------------------------------------------- #
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.")


# --------------------------------------------------------------------------- #
# 5. Select the best-performing variation
# --------------------------------------------------------------------------- #
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


# --------------------------------------------------------------------------- #
# 6. Map the data to Airtable fields
# --------------------------------------------------------------------------- #
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_airtable_fields(experiment, best):
    probability = best.get("bayesian_probability")
    improvement = best.get("improvement_rate")
    fields = {
        "Experiment Name": experiment.get("name"),
        "Status": map_status(experiment.get("status")),
        "Start date": to_iso_date(experiment.get("dateStarted")),
        "End date": to_iso_date(experiment.get("dateEnded")),
        "Notes": experiment.get("description"),
        "Actual": improvement,
        "Probability": bayesian_to_probability(probability),
        "Result": derive_result(probability, improvement),
    }
    return {k: v for k, v in fields.items() if v is not None}


# --------------------------------------------------------------------------- #
# 7. Upsert the record into Airtable
# --------------------------------------------------------------------------- #
def upsert_record(airtable_token, base_id, table_id, fields):
    resp = requests.patch(
        f"https://api.airtable.com/v0/{base_id}/{table_id}",
        headers={
            "Authorization": f"Bearer {airtable_token}",
            "Content-Type": "application/json",
        },
        json={
            "performUpsert": {"fieldsToMergeOn": ["Experiment Name"]},
            "typecast": True,
            "records": [{"fields": fields}],
        },
    )
    resp.raise_for_status()
    return resp.json()


# --------------------------------------------------------------------------- #
# 8. Orchestration
# --------------------------------------------------------------------------- #
def run(experiment_id, base_id, table_id):
    client_id = os.environ.get("KAMELEOON_CLIENT_ID")
    client_secret = os.environ.get("KAMELEOON_CLIENT_SECRET")
    airtable_token = os.environ.get("AIRTABLE_TOKEN")

    missing = [
        name
        for name, value in (
            ("KAMELEOON_CLIENT_ID", client_id),
            ("KAMELEOON_CLIENT_SECRET", client_secret),
            ("AIRTABLE_TOKEN", airtable_token),
        )
        if not value
    ]
    if missing:
        raise SystemExit(
            "Missing required environment variable(s): " + ", ".join(missing)
        )

    # 1. Authenticate.
    token = kameleoon_token(client_id, client_secret)
    print("Authenticated with the Automation API.")

    # 2. Retrieve the experiment.
    experiment = get_experiment(token, experiment_id)
    goal_id = experiment.get("mainGoalId")
    print(
        f"Fetched experiment {experiment.get('id')}: "
        f"{experiment.get('name')!r} (status: {experiment.get('status')})."
    )

    # 3-4. Request and poll for the results.
    data_code = request_results(token, experiment_id, goal_id)
    result_data = poll_results(token, data_code)

    # 5. Select the best-performing variation.
    best = pick_best_variation(result_data, goal_id)
    if best:
        print(
            f"Best-performing variation: {best['variation_id']} "
            f"(uplift {best['improvement_rate']}%, "
            f"Bayesian probability {best.get('bayesian_probability')}%)."
        )
    else:
        print("No variation data available for the requested goal.")

    # 6. Map the data to Airtable fields.
    fields = build_airtable_fields(experiment, best)
    print("Mapped Airtable fields:")
    for key, value in fields.items():
        print(f"  {key}: {value}")

    # 7. Upsert the record.
    response = upsert_record(airtable_token, base_id, table_id, fields)
    created = response.get("createdRecords") or []
    record_id = response["records"][0]["id"] if response.get("records") else None
    action = "Created" if record_id in created else "Updated"
    print(f"{action} Airtable record {record_id}.")

    return response


def main():
    parser = argparse.ArgumentParser(
        description="Export a Kameleoon experiment's results to Airtable."
    )
    parser.add_argument(
        "--experiment-id",
        required=True,
        help="ID of the Kameleoon experiment to export.",
    )
    parser.add_argument(
        "--base-id",
        required=True,
        help="Airtable base ID (starts with 'app').",
    )
    parser.add_argument(
        "--table-id",
        required=True,
        help="Airtable table ID (starts with 'tbl') or table name.",
    )
    args = parser.parse_args()

    try:
        run(args.experiment_id, args.base_id, args.table_id)
    except requests.HTTPError as exc:
        detail = ""
        if exc.response is not None:
            detail = f" — {exc.response.status_code}: {exc.response.text}"
        print(f"HTTP error: {exc}{detail}", file=sys.stderr)
        sys.exit(1)
    except (RuntimeError, TimeoutError) as exc:
        print(f"Error: {exc}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

Notas de personalización

La asignación de estado vive en la constante STATUS_MAP, indexada por los tokens de estado en mayúsculas que devuelve la API. Ajuste los valores de destino si sus opciones de Status difieren de Running / Implementing / Completed / Defunct, y confirme los tokens que devuelve su cuenta con una solicitud real GET /experiments/{experimentId} antes de confiar en la asignación.
Probability procede de la probabilidad de éxito bayesiana medida, que requiere bayesian: true en la solicitud de resultados. Si su campo Probability es en cambio una estimación previa al experimento que introduce manualmente, elimine la línea Probability de build_airtable_fields.
La selección de objetivo usa el mainGoalId del experimento. Para generar el informe sobre un objetivo diferente, pase su ID a request_results y pick_best_variation.
Clave de upsert. Airtable hace coincidir el campo de combinación de forma exacta, por lo que las diferencias de mayúsculas/minúsculas o de espacios en Experiment Name crean una fila nueva en lugar de actualizar la existente. Mantenga estables los nombres de los experimentos, o combine por un campo identificador estable dedicado.
Formato del campo Actual. El script escribe el valor bruto de improvementRate (por ejemplo, 211.48) en Actual. Si Actual es un campo Percent de Airtable, configúrelo para que espere un número simple en lugar de una fracción, o divida el valor entre 100 en build_airtable_fields para que coincida con un campo Percent basado en fracciones.
Límites de frecuencia. La Automation API permite hasta 50 solicitudes cada 10 segundos y 1000 por hora, pero Kameleoon recomienda mantenerse por debajo de 12 llamadas por minuto y cuenta, y desaconseja usar la Automation API para el seguimiento de alta frecuencia. Si procesa muchos experimentos por lotes, almacene en caché los tokens, limite la frecuencia de las solicitudes y considere la Data API para necesidades de gran volumen.

​Objetivo

​Requisitos

​1. Autenticarse con la Automation API

​2. Recuperar el experimento

​3. Solicitar los resultados del experimento

​4. Consultar los resultados

​5. Seleccionar la variación con mejor rendimiento

​6. Asignar los datos a los campos de Airtable

​7. Insertar o actualizar el registro en Airtable

​8. Ejecutar el script

​Script completo

​Notas de personalización

Objetivo

Requisitos

1. Autenticarse con la Automation API

2. Recuperar el experimento

3. Solicitar los resultados del experimento

4. Consultar los resultados

5. Seleccionar la variación con mejor rendimiento

6. Asignar los datos a los campos de Airtable

7. Insertar o actualizar el registro en Airtable

8. Ejecutar el script

Script completo

Notas de personalización