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

# Supprimer plusieurs comptes

> Apprenez à supprimer plusieurs comptes à l'aide de l'Automation API tout en gérant efficacement les limites de débit.

Ce guide explique comment supprimer plusieurs comptes à l'aide de l'Automation API tout en respectant les [limites de débit de l'API](/developer-docs/apis/automation-api-rest/get-started/get-started#rate-limiting). Il utilise l'endpoint [Delete account](/api-reference/account/delete-an-account).

## Prérequis

<Info>
  Avant d'utiliser l'Automation API, vous devez obtenir un access token. Pour les instructions, consultez le [guide d'authentification](/developer-docs/apis/automation-api-rest/get-started/get-started#1-obtain-an-access-token).
</Info>

Incluez votre token dans l'en-tête `Authorization` de chaque requête :

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

## Gérer les limites de débit

L'Automation API applique deux fenêtres de limitation de débit pour contrôler le trafic des requêtes :

| Fenêtre de temps | Nombre maximum de requêtes |
| :--------------- | :------------------------- |
| 10 secondes      | 50 requêtes                |
| 1 heure          | 1 000 requêtes             |

<Warning>
  Si vous envoyez des requêtes trop rapidement, l'API renvoie un code de statut `HTTP 429 Too Many Requests`.
</Warning>

Pour éviter ces limites, traitez vos requêtes par lots contrôlés :

* Envoyez un maximum de 50 requêtes toutes les 10 secondes.
* Envoyez un maximum de 1 000 requêtes par heure.

### Exemple : Suppression de 230 comptes

Pour supprimer 230 comptes, divisez vos requêtes en lots comme suit :

| Lot | Requêtes | Temps d'attente |
| :-- | :------- | :-------------- |
| 1   | 50       | Attendre 10 s   |
| 2   | 50       | Attendre 10 s   |
| 3   | 50       | Attendre 10 s   |
| 4   | 50       | Attendre 10 s   |
| 5   | 30       | Terminé         |

## Supprimer des comptes avec Python

Utilisez le script Python suivant pour envoyer les requêtes de suppression séquentiellement et gérer automatiquement les limites de débit :

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

Le script gère la suppression des comptes tout en respectant les limites de débit de l'Automation API en :

* Envoyant les requêtes séquentiellement.
* Traitant les comptes par lots de 50.
* Attendant entre les lots pour respecter la limite de 10 secondes.
* Faisant une pause si le processus atteint la limite horaire de 1 000 requêtes.

Cette approche évite les erreurs de limitation de débit et garantit une suppression de comptes fiable lors d'opérations de nettoyage importantes ou d'offboarding.