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

# Crear varias cuentas a la vez

> Cree cuentas de Kameleoon de forma masiva usando la Automation API, gestionando los límites de velocidad con solicitudes por lotes y un script de Python.

Esta guía explica cómo crear automáticamente varias cuentas usando la Automation API cumpliendo con los [límites de velocidad de la API](/developer-docs/apis/automation-api-rest/get-started/get-started#rate-limiting). Utiliza el [endpoint `/accounts`](/api-reference/account/create-a-new-account).

## Requisitos previos

Antes de usar la Automation API, asegúrese de disponer de un token de acceso.

Para obtener un token, consulte la [guía de autenticación](/developer-docs/apis/automation-api-rest/get-started/get-started#1-obtain-an-access-token). Incluya el token en el encabezado `Authorization` de su solicitud:

```http theme={null}
Authorization: Bearer YOUR_ACCESS_TOKEN
```

## Gestionar los límites de velocidad

La Automation API aplica dos ventanas de limitación de velocidad para controlar el tráfico de solicitudes:

| Ventana de tiempo | Solicitudes máximas |
| ----------------- | ------------------- |
| 10 segundos       | 50 solicitudes      |
| 1 hora            | 1.000 solicitudes   |

Si envía solicitudes con demasiada rapidez al crear muchas cuentas, la API devuelve una respuesta `HTTP 429 (Too Many Requests)`.

Para evitar estos límites, procese sus solicitudes en lotes controlados:

* Envíe un máximo de 50 solicitudes cada 10 segundos.
* Envíe un máximo de 1.000 solicitudes por hora.

Por ejemplo, para crear 230 cuentas, divida sus solicitudes de la siguiente manera:

| Lote | Solicitudes | Tiempo de espera    |
| ---- | ----------- | ------------------- |
| 1    | 50          | Esperar 10 segundos |
| 2    | 50          | Esperar 10 segundos |
| 3    | 50          | Esperar 10 segundos |
| 4    | 50          | Esperar 10 segundos |
| 5    | 30          | Completado          |

### Formatear los datos de entrada

Defina sus cuentas en un archivo JSON. Cada objeto del array representa el cuerpo de la solicitud para una sola cuenta.

```json theme={null}
[
  {
    "firstName": "Elton",
    "lastName": "John",
    "email": "elton@john.com",
    "preferredLocale": "en",
    "password": "pwd",
    "passwordConfirm": "pwd",
    "status": "ACTIVATED",
    "roles": [
      {
        "name": "ROLE_CUSTOMER_ADMIN",
        "sites": [],
        "customers": [99999],
        "privileges": []
      }
    ],
    "isProductRecoAllowed": true,
    "solutions": ["WEB_EXPERIMENTATION", "FEATURE_EXPERIMENTATION"]
  },
  {
    "firstName": "Poussiere",
    "lastName": "Etoile",
    "email": "poussiere@etoile.com",
    "password": "pwd",
    "passwordConfirm": "pwd",
    "preferredLocale": "en",
    "status": "ACTIVATED",
    "roles": [
      {
        "name": "ROLE_CUSTOMER_ADMIN",
        "sites": [],
        "customers": [99999],
        "privileges": []
      }
    ],
    "isProductRecoAllowed": false,
    "solutions": ["WEB_EXPERIMENTATION", "FEATURE_EXPERIMENTATION"]
  }
]
```

### Crear cuentas usando Python

El siguiente script de Python lee las cuentas de su archivo JSON, envía las solicitudes secuencialmente y gestiona automáticamente los límites de velocidad:

```python theme={null}
import json
import time
import requests

API_URL = "https://api.kameleoon.com/accounts"
ACCESS_TOKEN = "YOUR_ACCESS_TOKEN"

INPUT_FILE = "accounts.json"

MAX_PER_10_SECONDS = 50
MAX_PER_HOUR = 1000

TEN_SECONDS = 10
ONE_HOUR = 3600


def load_accounts(file_path):
    with open(file_path, "r") as f:
        return json.load(f)


def create_account(session, payload):
    headers = {
        "Authorization": f"Bearer {ACCESS_TOKEN}",
        "Content-Type": "application/json",
    }

    response = session.post(API_URL, json=payload, headers=headers)

    if response.status_code == 429:
        print("Rate limit reached. Waiting 10 seconds...")
        time.sleep(10)
        response = session.post(API_URL, json=payload, headers=headers)
        

    if response.status_code in (200, 201):
        return True, response.json()

    return False, response.text


def process_accounts(accounts):

    session = requests.Session()

    start_hour = time.time()
    hour_count = 0

    for i in range(0, len(accounts), MAX_PER_10_SECONDS):

        batch = accounts[i:i + MAX_PER_10_SECONDS]

        if hour_count + len(batch) > MAX_PER_HOUR:

            elapsed = time.time() - start_hour
            sleep_time = max(0, ONE_HOUR - elapsed)

            print(f"Hourly limit reached. Sleeping {sleep_time:.2f} seconds")
            time.sleep(sleep_time)

            start_hour = time.time()
            hour_count = 0

        batch_start = time.time()

        for account in batch:

            success, result = create_account(session, account)

            if success:
                print("Account created:", result)
            else:
                print("Request failed:", result)

            hour_count += 1

        elapsed = time.time() - batch_start

        if elapsed < TEN_SECONDS:
            sleep_time = TEN_SECONDS - elapsed
            print(f"Waiting {sleep_time:.2f} seconds before next batch")
            time.sleep(sleep_time)


def main():

    accounts = load_accounts(INPUT_FILE)

    print(f"Loaded {len(accounts)} accounts")

    process_accounts(accounts)


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

***

El script proporcionado crea de forma segura un gran número de cuentas cumpliendo con los límites de velocidad de la Automation API. Realiza las siguientes acciones:

* Lee las cuentas desde un archivo JSON.
* Envía las solicitudes secuencialmente.
* Procesa las cuentas en lotes de 50.
* Espera entre lotes para cumplir con el límite de 10 segundos.
* Hace una pausa cuando el proceso alcanza el límite por hora de 1.000 solicitudes.

Este enfoque previene los errores de límite de velocidad y garantiza una creación de cuentas fiable durante grandes migraciones u operaciones de onboarding masivo.