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

# Mehrere Konten gleichzeitig erstellen

> Erstellen Sie Kameleoon-Konten in großen Mengen mithilfe der Automation API und behandeln Sie Ratenlimits mit gestapelten Anfragen und einem Python-Skript.

Dieser Leitfaden erklärt, wie Sie automatisch mehrere Konten mithilfe der Automation API erstellen und dabei die [API-Ratenlimits](/developer-docs/apis/automation-api-rest/get-started/get-started#rate-limiting) einhalten. Es verwendet den [`/accounts`-Endpoint](/api-reference/account/create-a-new-account).

## Voraussetzungen

Bevor Sie die Automation API verwenden, stellen Sie sicher, dass Sie ein Access Token haben.

Um ein Token zu erhalten, lesen Sie den [Authentifizierungsleitfaden](/developer-docs/apis/automation-api-rest/get-started/get-started#1-obtain-an-access-token). Fügen Sie das Token in den `Authorization`-Header Ihrer Anfrage ein:

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

## Ratenlimits behandeln

Die Automation API setzt zwei Ratenbegrenzungsfenster durch, um den Anfrage-Traffic zu steuern:

| Zeitfenster | Maximale Anfragen |
| ----------- | ----------------- |
| 10 Sekunden | 50 Anfragen       |
| 1 Stunde    | 1.000 Anfragen    |

Wenn Sie beim Erstellen vieler Konten Anfragen zu schnell senden, gibt die API eine `HTTP 429 (Too Many Requests)`-Antwort zurück.

Um diese Limits zu vermeiden, verarbeiten Sie Ihre Anfragen in kontrollierten Stapeln:

* Senden Sie maximal 50 Anfragen alle 10 Sekunden.
* Senden Sie maximal 1.000 Anfragen pro Stunde.

Um beispielsweise 230 Konten zu erstellen, teilen Sie Ihre Anfragen wie folgt auf:

| Stapel | Anfragen | Wartezeit          |
| ------ | -------- | ------------------ |
| 1      | 50       | 10 Sekunden warten |
| 2      | 50       | 10 Sekunden warten |
| 3      | 50       | 10 Sekunden warten |
| 4      | 50       | 10 Sekunden warten |
| 5      | 30       | Abgeschlossen      |

### Eingabedaten formatieren

Definieren Sie Ihre Konten in einer JSON-Datei. Jedes Objekt im Array stellt den Anfragetext für ein einzelnes Konto dar.

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

### Konten mit Python erstellen

Das folgende Python-Skript liest die Konten aus Ihrer JSON-Datei, sendet die Anfragen sequenziell und verwaltet die Ratenlimits automatisch:

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

***

Das bereitgestellte Skript erstellt sicher eine große Anzahl von Konten und hält dabei die Ratenlimits der Automation API ein. Es führt die folgenden Aktionen aus:

* Liest Konten aus einer JSON-Datei.
* Sendet Anfragen sequenziell.
* Verarbeitet Konten in Stapeln von 50.
* Wartet zwischen den Stapeln, um das 10-Sekunden-Limit einzuhalten.
* Pausiert, wenn der Prozess das Stundenlimit von 1.000 Anfragen erreicht.

Dieser Ansatz verhindert Ratenbegrenzungsfehler und gewährleistet eine zuverlässige Kontoerstellung bei großen Migrationen oder Bulk-Onboarding-Vorgängen.