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

# Eliminar varias cuentas

> Aprenda a eliminar varias cuentas usando la Automation API mientras gestiona los límites de velocidad de manera eficaz.

Esta guía explica cómo eliminar 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 [Delete account](/api-reference/account/delete-an-account).

## Requisitos previos

<Info>
  Antes de usar la Automation API, debe obtener un token de acceso. Para obtener instrucciones, consulte la [guía de autenticación](/developer-docs/apis/automation-api-rest/get-started/get-started#1-obtain-an-access-token).
</Info>

Incluya su token en el encabezado `Authorization` de cada 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   |

<Warning>
  Si envía solicitudes con demasiada rapidez, la API devuelve un código de estado `HTTP 429 Too Many Requests`.
</Warning>

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.

### Ejemplo: Eliminar 230 cuentas

Para eliminar 230 cuentas, divida sus solicitudes en los siguientes lotes:

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

## Eliminar cuentas usando Python

Utilice el siguiente script de Python para enviar solicitudes de eliminación secuencialmente y gestionar los límites de velocidad automáticamente:

```python delete_accounts.py theme={null}
import time
import requests

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

ACCOUNT_IDS = [12345, 54321]

MAX_PER_10_SECONDS = 50
MAX_PER_HOUR = 1000

TEN_SECONDS = 10
ONE_HOUR = 3600


def delete_account(session, account_id):
    headers = {
        "Authorization": f"Bearer {ACCESS_TOKEN}",
    }

    url = f"{API_URL}{account_id}"

    try:
        response = session.delete(url, headers=headers)

        if response.status_code == 429:
            return "rate_limited", None

        if response.status_code in (200, 204):
            return True, response.json() if response.content else {}

        return False, response.text

    except requests.exceptions.RequestException as e:
        return False, str(e)


def process_accounts(account_ids):

    session = requests.Session()

    start_hour = time.monotonic()
    hour_count = 0

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

        batch = account_ids[i:i + MAX_PER_10_SECONDS]

        # Enforce hourly limit BEFORE sending requests
        if hour_count + len(batch) > MAX_PER_HOUR:
            elapsed = time.monotonic() - 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.monotonic()
            hour_count = 0

        batch_start = time.monotonic()

        for account_id in batch:

            while True:
                # Check hourly limit before EACH request
                if hour_count >= MAX_PER_HOUR:
                    elapsed = time.monotonic() - 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.monotonic()
                    hour_count = 0

                result, data = delete_account(session, account_id)

                # Count every attempt as a request
                hour_count += 1

                if result == True:
                    print(f"Account {account_id} deleted")
                    break

                elif result == "rate_limited":
                    elapsed = time.monotonic() - start_hour

                    # If close to hourly limit, wait for full reset
                    if hour_count >= MAX_PER_HOUR or elapsed >= ONE_HOUR:
                        sleep_time = max(0, ONE_HOUR - elapsed)
                        print(f"429 likely due to hourly limit. Sleeping {sleep_time:.2f} seconds")
                        time.sleep(sleep_time)

                        start_hour = time.monotonic()
                        hour_count = 0
                    else:
                        print("429 received. Waiting 10 seconds...")
                        time.sleep(TEN_SECONDS)

                    continue

                else:
                    print(f"Failed to delete {account_id}: {data}")
                    break

        # Enforce 10-second window
        elapsed = time.monotonic() - 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():
    process_accounts(ACCOUNT_IDS)


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

El script gestiona la eliminación de cuentas cumpliendo con los límites de velocidad de la Automation API mediante:

* El envío secuencial de solicitudes.
* El procesamiento de cuentas en lotes de 50.
* La espera entre lotes para cumplir con el límite de 10 segundos.
* La 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 eliminación de cuentas fiable durante operaciones de limpieza u offboarding a gran escala.