> ## Documentation Index
> Fetch the complete documentation index at: https://documentation.deepmask.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Limits und faire Nutzung

> Erfahren Sie, welche Raten-, Token-, Budget- und Anfragelimits für die DeepMask API gelten, wie Tokens pro Minute gezählt werden und wie die faire Nutzung zwischen Organisationen funktioniert.

Diese Seite fasst die wichtigsten Limits der DeepMask API zusammen. Sie erfahren, wie viel Datenverkehr Ihre Organisation senden kann, wie groß jede Anfrage sein darf und wie viel Ihre Schlüssel ausgeben können. Eine Anfrage, die DeepMask wegen eines Limits ablehnt, wird nicht abgerechnet. Wie DeepMask die gemeinsam genutzte Kapazität fair auf alle verteilt, erfahren Sie unter [Faire Nutzung](#faire-nutzung).

Alle Schlüssel Ihrer Organisation teilen sich die meisten Limits. Nachdem Sie die API-Abrechnung aktiviert haben, sehen Administratoren der Organisation die aktuellen Limits für den Datenverkehr in der Karte **API-Limits** auf der Registerkarte **Nutzung**. Siehe [API-Limits](https://documentation.deepmask.io/de/api/usage-and-logs.md#api-limits). Was jeder Fehlercode bedeutet und wie Sie damit umgehen, erfahren Sie unter [Fehler und Wiederholungen](https://documentation.deepmask.io/de/api/errors.md).

## Limits im Überblick

| Limit | Wert oder Standardwert | Gilt für | Bei Überschreitung |
| - | - | - | - |
| [**Anfragen pro Minute**](#anfragen-pro-minute) | 60 | Alle Schlüssel Ihrer Organisation zusammen | `429` mit `API_RPM_LIMIT` oder `API_RATE_LIMIT` |
| [**Tokens pro Minute**](#token-durchsatz) | 5.000.000 | Alle Schlüssel Ihrer Organisation zusammen | `429` mit `API_TPM_LIMIT` oder `API_RATE_LIMIT` |
| [**Gleichzeitige Anfragen**](#gleichzeitige-anfragen) | 2 | Alle Schlüssel Ihrer Organisation zusammen | `429` mit `API_CONCURRENCY_LIMIT` |
| [Flood Guard](#flood-guard-pro-schlüssel) | 120 Anfragen pro Minute | Jeder Schlüssel einzeln | `429` mit `API_RATE_LIMIT` |
| [Anfragen in Bearbeitung](#anfragen-in-bearbeitung-pro-schlüssel) | 8 | Jeder Schlüssel einzeln | `429` mit `API_CONCURRENCY_LIMIT` |
| [Anfragetexte in Bearbeitung](#anfragen-in-bearbeitung-pro-schlüssel) | 64 MiB | Jeder Schlüssel einzeln | `429` mit `API_CONCURRENCY_LIMIT` |
| [Modellkapazität](#modellkapazität) | Von DeepMask festgelegt | Jedes Modell, von allen Organisationen gemeinsam genutzt | `429` mit `API_MODEL_CAPACITY` |
| [Kontextfenster](#kontextfenster) | Das Kontextfenster des Modells | Jede Anfrage | `4xx` mit `API_UPSTREAM_REJECTED` vom Anbieter. Wird nicht abgerechnet. |
| [`max_tokens`](#maximale-ausgabe-tokens) | Von 1 bis zur maximalen Ausgabe des Modells | Jede Anfrage | `400` mit `API_REQUEST_UNBOUNDED` |
| [Anfragetext](#größe-von-anfragetext-und-payload) | 32 MiB | Jede Anfrage | `413` mit `API_REQUEST_INVALID` |
| [Bilder](#bilder) | 20 Bilder und 20 MB decodierte Bilddaten | Jede Anfrage | `400` mit `API_IMAGE_INVALID` |
| [Anfragedauer](#anfragedauer) | 15 Minuten | Jede Anfrage | `504` mit `API_INFERENCE_UNAVAILABLE` oder ein Stream, der ohne Fehler-Event geschlossen wird |
| [**Gateway-Ausgabenlimit**](#budgetlimits) | 100 €, bis zum maximalen Limit (standardmäßig 500 €) | Alle Schlüssel Ihrer Organisation zusammen, pro Monat | `400` oder `429` mit `API_SPENDING_CAP` |
| [Ausgabenlimit des Schlüssels](#budgetlimits) | Kein Limit, bis zum **Gateway-Ausgabenlimit** | Ein Schlüssel, pro Monat | `400` oder `429` mit `API_KEY_SPENDING_CAP` |
| [Automatisch freigegebene unklare Ergebnisse](#unklare-ergebnisse) | 20 innerhalb von 24 Stunden | Alle Schlüssel Ihrer Organisation zusammen | Weitere unklare Ergebnisse pausieren die Anfragen Ihrer Organisation. Anfragen geben dann `503` mit `API_ADMISSION_UNAVAILABLE` zurück. |

**Tokens pro Minute** rechnet jede laufende Anfrage unabhängig von ihrer Größe mit etwa 2,0 bis 2,3 Millionen Tokens an. Der Standardwert erlaubt daher zwei Anfragen gleichzeitig. Siehe [Wie Tokens pro Minute gezählt werden](#wie-tokens-pro-minute-gezählt-werden).

Die Werte für **Anfragen pro Minute**, **Tokens pro Minute** und **Gleichzeitige Anfragen** sind Standardwerte. Hat DeepMask sie für Ihre Organisation erhöht, zeigt die Karte **API-Limits** Ihre Werte. Die Limits für Schlüssel, Protokolle und Exporte finden Sie unter [Kontolimits](#kontolimits).

## Token-Durchsatz

**Tokens pro Minute** begrenzt den Token-Durchsatz Ihrer Organisation. Alle Ihre Schlüssel teilen sich dieses Limit, und der Standardwert ist 5.000.000. DeepMask wendet es auf zwei Arten an:

* **Laufende Anfragen:** Die Anfragen aller Ihrer Schlüssel, die gerade laufen, dürfen zusammen nicht mehr als Ihren Wert für **Tokens pro Minute** ausmachen. Eine neue Anfrage, die ihn überschreiten würde, gibt `429` mit `API_TPM_LIMIT` zurück.
* **Tatsächliche Tokens:** Auch der tatsächliche Tokenverbrauch Ihrer Organisation pro Minute ist auf den Wert von **Tokens pro Minute** begrenzt. Eine Anfrage, die aus diesem Grund abgelehnt wird, erhält `429` mit `API_RATE_LIMIT`.

### Wie Tokens pro Minute gezählt werden

Solange eine Anfrage läuft, rechnet DeepMask sie mit einer festen Größe für ihr Modell auf **Tokens pro Minute** an, nicht mit ihrer tatsächlichen Größe. Diese Größe beträgt je nach maximaler Ausgabe des Modells etwa 2,0 bis 2,3 Millionen Tokens. Sobald eine Anfrage abgeschlossen ist, zählt sie nicht mehr. Ein kurzer Prompt zählt daher genauso viel wie ein langer, und ein niedrigerer `max_tokens`-Wert senkt den angerechneten Wert nicht.

In der Praxis wirkt **Tokens pro Minute** dadurch wie ein zweites Limit für parallele Anfragen. Mit dem Standardlimit von 5.000.000 können zwei Anfragen gleichzeitig laufen, unabhängig davon, welche Modelle sie verwenden. Eine dritte Anfrage passt erst hinein, wenn eine der beiden abgeschlossen ist. Das entspricht dem Standardlimit für **Gleichzeitige Anfragen**, daher erreichen Sie meist zuerst `API_CONCURRENCY_LIMIT`. Hat Ihre Organisation ein höheres Limit für gleichzeitige Anfragen, erreichen Sie möglicherweise stattdessen `API_TPM_LIMIT`.

So nutzen Sie Ihren Durchsatz optimal:

* Führen Sie höchstens so viele Anfragen parallel aus, wie Ihr Wert für **Gleichzeitige Anfragen** erlaubt. Siehe [Parallele Anfragen in Ihrer Anwendung begrenzen](#parallele-anfragen-in-ihrer-anwendung-begrenzen).
* Fordern Sie nach Möglichkeit kürzere Antworten an. Eine Anfrage, die früher abgeschlossen ist, gibt ihren Anteil an **Tokens pro Minute** früher frei.
* Starten Sie keine Anfragen, die Sie womöglich wieder abbrechen. Sobald DeepMask eine Anfrage an das Modell gesendet hat, stoppt ein Verbindungsabbruch sie nicht. DeepMask führt sie zu Ende, und sie wird weiter auf **Tokens pro Minute** angerechnet, bis sie abgeschlossen ist.

## Ratenlimits

DeepMask begrenzt, wie viele Anfragen Ihre Organisation, jeder Schlüssel und jedes Modell verarbeiten können. Überschreitet eine Anfrage eines dieser Limits, wird sie sofort mit einem `429`-Fehler abgelehnt. Sie wird nicht in eine Warteschlange gestellt. Die einzelnen Codes finden Sie unter [429: Raten- und Kapazitätslimits](https://documentation.deepmask.io/de/api/errors.md#429-raten-und-kapazitätslimits).

### Anfragen pro Minute

**Anfragen pro Minute** zählt die Anfragen aller Ihrer Schlüssel in den letzten 60 Sekunden. Der Standardwert ist 60.

* Anfragen, die DeepMask vor der Verarbeitung ablehnt, zählen nicht mit, zum Beispiel bei ungültigen Anmeldedaten, einer ungültigen Anfrage, einem erreichten Limit oder einem erreichten Ausgabenlimit.
* Anfragen, die erst später abgelehnt werden, zum Beispiel vom Modellanbieter, zählen trotzdem.
* Anfragen, die ein Ausgabenlimit blockiert hat, erscheinen dennoch im [Anfrageprotokoll](https://documentation.deepmask.io/de/api/usage-and-logs.md#statuswerte), obwohl sie hier nicht zählen.

Eine Anfrage über dem Limit gibt `429` mit `API_RPM_LIMIT` zurück. Einige Anfragen über dem Anfragevolumen Ihrer Organisation erhalten stattdessen `API_RATE_LIMIT`. Behandeln Sie beide gleich: Senden Sie Anfragen in größeren Abständen und wiederholen Sie sie mit Backoff.

### Gleichzeitige Anfragen

**Gleichzeitige Anfragen** zählt die Anfragen aller Ihrer Schlüssel, die gerade laufen. Der Standardwert ist 2.

* Eine gestreamte Anfrage zählt, bis ihr Stream endet.
* Eine Anfrage zählt weiter, nachdem Ihre Anwendung die Verbindung getrennt hat oder in ein Timeout gelaufen ist, denn DeepMask führt sie trotzdem zu Ende. Eine Wiederholung direkt nach einem Timeout kann daher `429` mit `API_CONCURRENCY_LIMIT` zurückgeben.
* Eine neue Anfrage über dem Limit gibt `429` mit `API_CONCURRENCY_LIMIT` zurück.
* Viele Anfragen, die im selben Moment eintreffen, können auch unterhalb Ihrer Limits `429` mit `API_CONCURRENCY_LIMIT` oder `409` mit `API_ACCOUNT_BUSY` zurückgeben. Verteilen Sie sie über einen kurzen Zeitraum.

#### Parallele Anfragen in Ihrer Anwendung begrenzen

Um `429`-Fehler zu vermeiden, führen Sie in Ihrer Anwendung höchstens so viele Anfragen parallel aus, wie Ihr Wert für **Gleichzeitige Anfragen** erlaubt. Nutzen mehrere Anwendungen die Schlüssel Ihrer Organisation, teilen sie sich dieses Limit. Teilen Sie es daher zwischen ihnen auf.

Die folgenden Beispiele senden drei Prompts, führen aber höchstens zwei Anfragen gleichzeitig aus. Das Node.js-Beispiel verwendet Top-Level-`await`. Führen Sie es daher als ES-Modul aus, zum Beispiel als `.mjs`-Datei.

```bash cURL theme={null}
# xargs -P 2 führt höchstens zwei Anfragen gleichzeitig aus, eine pro Eingabezeile.
printf '%s\n' "Summarize report A" "Summarize report B" "Summarize report C" |
  xargs -P 2 -I {} curl -sS --max-time 960 https://api.deepmask.io/v1/chat/completions \
    -H "Authorization: Bearer $DEEPMASK_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"model": "gpt-4o", "messages": [{"role": "user", "content": "{}"}]}'
```

```python Python theme={null}
import asyncio
import os
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://api.deepmask.io/v1",
    api_key=os.environ["DEEPMASK_API_KEY"],
    timeout=960,  # Sekunden; über dem 15-Minuten-Limit von DeepMask
)
slots = asyncio.Semaphore(2)  # Wert für Gleichzeitige Anfragen Ihrer Organisation


async def ask(prompt: str) -> str:
    async with slots:
        response = await client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}],
        )
        return response.choices[0].message.content


async def main() -> None:
    prompts = ["Summarize report A", "Summarize report B", "Summarize report C"]
    for answer in await asyncio.gather(*(ask(prompt) for prompt in prompts)):
        print(answer)


asyncio.run(main())
```

```javascript Node.js theme={null}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.deepmask.io/v1",
  apiKey: process.env.DEEPMASK_API_KEY,
  timeout: 960_000, // Millisekunden; über dem 15-Minuten-Limit von DeepMask
});
const slots = 2; // Wert für Gleichzeitige Anfragen Ihrer Organisation
const prompts = ["Summarize report A", "Summarize report B", "Summarize report C"];
const answers = [];
let next = 0;

async function worker() {
  while (next < prompts.length) {
    const index = next++;
    const response = await client.chat.completions.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: prompts[index] }],
    });
    answers[index] = response.choices[0].message.content;
  }
}

await Promise.all(Array.from({ length: slots }, worker));
console.log(answers.join("\n\n"));
```

### Flood Guard pro Schlüssel

Jeder Schlüssel hat außerdem einen Flood Guard von 120 Anfragen pro Minute. Das ist das Doppelte des Standardlimits für **Anfragen pro Minute**. Mit den Standardlimits erreichen Sie daher normalerweise zuerst das Limit Ihrer Organisation. Mit höheren Limits kann ein einzelner Schlüssel zuerst seinen Flood Guard erreichen. Siehe [Höhere Limits anfordern](#höhere-limits-anfordern).

Der Flood Guard zählt jede Anfrage, die der Schlüssel sendet, einschließlich abgelehnter Anfragen und Aufrufe von `GET /v1/models`. Ein Client, der Anfragen zu schnell wiederholt, kann ihn daher auch dann erreichen, wenn die Limits Ihrer Organisation seine Anfragen bereits ablehnen. Eine Anfrage über dem Flood Guard gibt `429` mit `API_RATE_LIMIT` zurück.

Eine `429`-Antwort des Flood Guards enthält einen Header `Retry-After`. Andere `429`-Antworten enthalten ihn nicht. Antworten enthalten außerdem die Header `RateLimit` und `RateLimit-Policy`, zum Beispiel `RateLimit-Policy: 120;w=60`. Sie beschreiben nur diesen Flood Guard pro Schlüssel, nicht die Limits **Anfragen pro Minute**, **Tokens pro Minute** oder **Gleichzeitige Anfragen** Ihrer Organisation.

### Anfragen in Bearbeitung pro Schlüssel

Jeder Schlüssel kann bis zu 8 Anfragen gleichzeitig in Bearbeitung haben. Die Anfragetexte, die ein Schlüssel in Bearbeitung hat, dürfen zusammen bis zu 64 MiB groß sein.

* Die Zahl der Anfragen in Bearbeitung umfasst auch Aufrufe von `GET /v1/models`.
* Ein Anfragetext, der ohne Header `Content-Length` gesendet wird, zählt als 32 MiB.
* Eine Anfrage zählt so lange mit, bis DeepMask sie abgeschlossen hat, auch wenn Ihr Client die Verbindung trennt oder in ein Timeout läuft.
* Eine Anfrage über einem der beiden Limits gibt `429` mit `API_CONCURRENCY_LIMIT` zurück. Diese Ablehnungen erscheinen nicht im [Anfrageprotokoll](https://documentation.deepmask.io/de/api/usage-and-logs.md#anfragen-die-nicht-im-protokoll-erscheinen).

Das Limit von 8 Anfragen ist das Vierfache des Standardlimits für **Gleichzeitige Anfragen**. Mit den Standardlimits erreichen Sie daher normalerweise zuerst das Limit Ihrer Organisation. Bei großen Anfragen, etwa Anfragen mit Bildern, kann das Limit von 64 MiB zuerst greifen. Zwei Anfragen mit jeweils 20 MB Bildern kommen zum Beispiel zusammen auf etwa 54 MB. Eine dritte solche Anfrage gibt `429` zurück, bis eine der beiden abgeschlossen ist.

### Modellkapazität

Jedes Modell hat ein Kapazitätslimit, das sich alle Organisationen teilen, die das Modell über die API nutzen. DeepMask legt dieses Limit fest, und die App zeigt es nicht an.

Hat ein Modell sein Kapazitätslimit erreicht, geben Anfragen für dieses Modell `429` mit `API_MODEL_CAPACITY` zurück. Das kann auch passieren, wenn Ihre Organisation unter ihren eigenen Limits liegt. Ihre anderen Modelle funktionieren weiter. Wiederholen Sie die Anfrage mit Backoff oder wechseln Sie zu einem anderen Modell, das Ihr Schlüssel nutzen darf.

Auch der Modellanbieter kann Anfragen begrenzen. Sie erhalten dann `429` mit `API_RATE_LIMIT`, und es fallen keine Kosten an. Wiederholen Sie die Anfrage mit Backoff.

## Token-Limits

Token-Limits gelten für jede einzelne Anfrage. Die Werte der einzelnen Modelle finden Sie unter [Verfügbare Modelle](https://documentation.deepmask.io/de/api/models.md#verfügbare-modelle).

### Kontextfenster

Ihr Prompt und die Ausgabe des Modells teilen sich das Kontextfenster des Modells. Ein langer Prompt lässt daher weniger Platz für die Ausgabe. DeepMask prüft die Länge Ihres Prompts nicht selbst. Einen Prompt, der nicht hineinpasst, lehnt der Modellanbieter mit einem `4xx`-Status und `API_UPSTREAM_REJECTED` ab, und diese Ablehnung wird nicht abgerechnet. Das Kontextfenster jedes Modells finden Sie unter [Verfügbare Modelle](https://documentation.deepmask.io/de/api/models.md#verfügbare-modelle).

### Maximale Ausgabe-Tokens

`max_tokens` legt die maximale Anzahl an Ausgabe-Tokens für eine Antwort fest. `max_completion_tokens` funktioniert genauso.

* **Wertebereich:** Der Wert liegt zwischen 1 und dem Wert **Max. Ausgabe-Tokens** des Modells, der unter [Verfügbare Modelle](https://documentation.deepmask.io/de/api/models.md#verfügbare-modelle) aufgeführt ist. Ein größerer Wert gibt `400` mit `API_REQUEST_UNBOUNDED` zurück.
* **Standardwert:** Wenn Sie `max_tokens` weglassen, setzt DeepMask bei den meisten Modellen kein eigenes Limit. Es gilt die Standard-Ausgabelänge des Modells, und diese kann unter dem Maximum des Modells liegen. `glm-4.7` und `glm-4.7-flash` stoppen bei 65.536 Ausgabe-Tokens, sofern Sie `max_tokens` nicht setzen.
* **Reasoning-Tokens:** Verborgene Reasoning-Tokens werden auf `max_tokens` angerechnet und als Ausgabe abgerechnet. Siehe [Reasoning- und Thinking-Tokens](https://documentation.deepmask.io/de/api/models.md#reasoning-und-thinking-tokens).

Weitere Details finden Sie unter [Ausgabelänge](https://documentation.deepmask.io/de/api/chat-completions.md#ausgabelänge).

## Größe und Dauer von Anfragen

Auch diese Limits gelten für jede einzelne Anfrage.

### Größe von Anfragetext und Payload

* **Anfragetext:** Ein Anfragetext darf bis zu 32 MiB groß sein. Bei einem größeren Anfragetext erhalten Sie `413` mit `API_REQUEST_INVALID`.
* **Nur unkomprimierte Anfragetexte:** Ein Anfragetext mit einem `Content-Encoding`-Header wie `gzip` gibt `400` mit `API_REQUEST_INVALID` zurück. Die OpenAI-SDKs senden unkomprimierte Anfragetexte.
* **Payload:** Nachrichten, Tool-Definitionen, `tool_choice` und `stop` dürfen zusammen bis zu 32 MiB als UTF-8-JSON umfassen. Darüber gibt die Anfrage `400` mit `API_REQUEST_UNBOUNDED` zurück. Der Base64-Text Ihrer Bilder wird auf beide Limits angerechnet.

Wie viel Platz Bilder für den Rest einer Anfrage lassen, erfahren Sie unter [Anfragegröße](https://documentation.deepmask.io/de/api/chat-completions.md#anfragegröße). Limits für einzelne Felder, etwa bis zu 128 Tools oder 4 Stoppsequenzen in `stop`, finden Sie unter [Anfragetext](https://documentation.deepmask.io/de/api/chat-completions.md#anfragetext).

### Bilder

Bei Modellen mit Bildeingabe kann jede Anfrage bis zu 20 Bilder und 20 MB decodierte Bilddaten enthalten. Anzahl und Größe umfassen die Bilder in allen Nachrichten, auch in früheren Runden der Unterhaltung. Jede Seite eines Bildes darf bis zu 8.000 Pixel lang sein. Das Größenlimit pro Bild hängt vom Modell ab.

Eine Anfrage über einem Bildlimit gibt `400` mit `API_IMAGE_INVALID` zurück. Die Limits der einzelnen Modelle finden Sie unter [Bildlimits](https://documentation.deepmask.io/de/api/chat-completions.md#bildlimits).

### Anfragedauer

Eine Anfrage kann bis zu 15 Minuten laufen. Was beim Erreichen des Limits passiert, hängt davon ab, ob die Antwort bereits begonnen hat:

* **Bevor die Antwort beginnt:** Die Anfrage gibt `504` mit `API_INFERENCE_UNAVAILABLE` zurück.
* **Während eines Streams:** DeepMask schließt den Stream ohne Fehler-Event. Behandeln Sie einen Stream ohne Chunk mit `finish_reason` als unvollständig. Siehe [Fehler in gestreamten Antworten](https://documentation.deepmask.io/de/api/errors.md#fehler-in-gestreamten-antworten).

Eine Anfrage, die das Limit erreicht, hat ein unklares Ergebnis. Wie DeepMask damit umgeht, erfahren Sie unter [Unklare Ergebnisse](#unklare-ergebnisse).

Die OpenAI-SDKs brechen standardmäßig nach 10 Minuten mit einem Timeout ab und wiederholen die Anfrage dann. DeepMask rechnet beide Anfragen ab. Setzen Sie den Client-Timeout etwas höher als 15 Minuten: `timeout=960` in Python (Sekunden) oder `timeout: 960_000` in Node.js (Millisekunden). Siehe [Wiederholungen in den OpenAI-SDKs](https://documentation.deepmask.io/de/api/errors.md#wiederholungen-in-den-openai-sdks).

Für Aufgaben, die länger dauern, fordern Sie eine kürzere Antwort an oder teilen Sie die Aufgabe in kleinere Anfragen auf.

## Budgetlimits

Zwei Ausgabenlimits begrenzen, was Ihre Schlüssel jeden Monat für Modellkosten ausgeben können:

* Das **Gateway-Ausgabenlimit** gilt für alle Schlüssel Ihrer Organisation zusammen. Der Standardwert ist 100 €, und Sie können es bis zum maximalen Limit erhöhen (standardmäßig 500 €).
* Ein optionales Ausgabenlimit des Schlüssels gilt für einen einzelnen Schlüssel, bis zur Höhe Ihres **Gateway-Ausgabenlimits**.

Beide Limits zählen die Modellkosten vor der Gebühr von 3 % und vor Steuern. Beide werden um 00:00 UTC am 1. eines Monats zurückgesetzt. Eine Anfrage über einem Limit wird abgelehnt, bevor ein Modell läuft. Sie wird daher nicht abgerechnet. Bereits laufende Anfragen können die Ausgaben trotzdem leicht über ein Limit bringen.

Eine Ablehnung wegen eines Ausgabenlimits gibt `400` oder `429` mit `API_SPENDING_CAP` oder `API_KEY_SPENDING_CAP` zurück. Wiederholen Sie sie nicht, denn sie schlägt so lange fehl, bis das Limit geändert oder zurückgesetzt wird. Wie Sie beide Limits festlegen, erfahren Sie unter [Ausgabenlimits](https://documentation.deepmask.io/de/api/spending-caps.md). Die Statuscodes finden Sie unter [Ausgabenlimits: 400 oder 429](https://documentation.deepmask.io/de/api/errors.md#ausgabenlimits-400-oder-429).

## Kontolimits

| Limit | Wert | Weitere Informationen |
| - | - | - |
| Schlüssel pro Organisation | 50 Schlüssel, die nicht widerrufen sind. Schlüssel mit dem Status **Ausstehend** oder **Wird widerrufen** zählen mit. | [API-Schlüssel](https://documentation.deepmask.io/de/api/keys.md#fehlerbehebung) |
| Modelle pro Schlüssel | 1 bis 100 | [Modelle auswählen](https://documentation.deepmask.io/de/api/keys.md#modelle-auswählen) |
| Schlüsselname | 1 bis 80 Zeichen | [Einen Schlüssel erstellen](https://documentation.deepmask.io/de/api/keys.md#einen-schlüssel-erstellen) |
| Aufgelistete widerrufene Schlüssel | Bis zu 150, die neuesten zuerst | [Widerrufene Schlüssel](https://documentation.deepmask.io/de/api/keys.md#widerrufene-schlüssel) |
| Änderungen auf der Seite **API** | 20 pro Minute für Ihre Organisation, gemeinsam für alle Administratoren | [API-Schlüssel](https://documentation.deepmask.io/de/api/keys.md#fehlerbehebung) |
| Zeitraum des Anfrageprotokolls | Bis zu 62 Tage, innerhalb der letzten 62 Tage | [Zeitraum auswählen](https://documentation.deepmask.io/de/api/usage-and-logs.md#zeitraum-auswählen) |
| Aufbewahrung des Anfrageprotokolls | 60 Tage | [Wie lange Anfrageprotokolle gespeichert werden](https://documentation.deepmask.io/de/api/usage-and-logs.md#wie-lange-anfrageprotokolle-gespeichert-werden) |
| CSV-Export | Bis zu 50.000 Anfragen pro Export und jeweils nur ein laufender Export für Ihre Organisation | [Grenzen für den Export](https://documentation.deepmask.io/de/api/usage-and-logs.md#grenzen-für-den-export) |

Wenn das Limit für Änderungen überschritten ist, zeigt die Seite **API** die Meldung „Too many API management changes. Retry shortly.“ (sinngemäß: Zu viele Änderungen an der API-Verwaltung. Versuchen Sie es in Kürze erneut.)

## Faire Nutzung

Alle Organisationen teilen sich die Kapazität hinter der DeepMask API. Mit den Limits auf dieser Seite sorgt DeepMask dafür, dass diese Kapazität fair verteilt wird, und setzt diese Limits automatisch durch:

* **Limits gelten pro Organisation.** **Anfragen pro Minute**, **Tokens pro Minute**, **Gleichzeitige Anfragen** und das **Gateway-Ausgabenlimit** gelten für alle Schlüssel Ihrer Organisation zusammen. Zusätzliche Schlüssel erhöhen die Limits Ihrer Organisation nicht.
* **Auch jeder Schlüssel hat eigene Limits.** Der [Flood Guard](#flood-guard-pro-schlüssel) und die [Limits für Anfragen in Bearbeitung](#anfragen-in-bearbeitung-pro-schlüssel) sind für jeden Schlüssel gleich. Sie verhindern, dass ein einzelner Schlüssel mehr sendet, als die API verarbeiten kann.
* **Die Modellkapazität wird geteilt.** Alle Organisationen teilen sich die [Kapazität](#modellkapazität) jedes Modells. Ein ausgelastetes Modell kann Ihre Anfragen ablehnen, auch wenn Sie unter Ihren eigenen Limits liegen.
* **Für unklare Ergebnisse gibt es ein 24-Stunden-Kontingent.** Bis zu 20 Anfragen innerhalb von 24 Stunden, die ohne eindeutiges Ergebnis enden, werden kostenlos freigegeben. Für sich allein pausieren sie Ihre Anfragen nicht. Darüber hinaus pausiert jedes weitere unklare Ergebnis Ihre Anfragen, bis DeepMask es geprüft hat. Siehe [Unklare Ergebnisse](#unklare-ergebnisse).
* **Wiederholungen brauchen Backoff.** Wiederholen Sie abgelehnte Anfragen mit Backoff, statt sie sofort erneut zu senden. Siehe [Mit Backoff wiederholen](#mit-backoff-wiederholen).
* **Chat- und API-Limits sind getrennt.** API-Anfragen werden nicht auf Ihre Nachrichtenlimits in DeepMask Chat angerechnet, und Chat-Nachrichten werden nicht auf Ihre API-Limits angerechnet.

Wenn Ihre Arbeitslast mehr erfordert, als Ihre Limits erlauben, fordern Sie höhere Limits an. Siehe [Höhere Limits anfordern](#höhere-limits-anfordern).

### Unklare Ergebnisse

Eine Anfrage hat ein unklares Ergebnis, wenn sie ohne eindeutiges Ergebnis endet. Beispiele sind ein Serverfehler oder ein Timeout beim Modellanbieter, ein Stream, der mittendrin abbricht, und eine Anfrage, die das 15-Minuten-Limit erreicht.

* **Keine Kosten:** DeepMask gibt eine Anfrage mit unklarem Ergebnis kostenlos frei. Für sich allein pausiert ein unklares Ergebnis die Anfragen Ihrer Organisation nicht.
* **Nachträgliche Nutzung:** Trifft die Nutzung für diese Anfrage später doch noch ein, rechnet DeepMask sie wie jede andere Nutzung ab. Das kann passieren, wenn der Anbieter die Antwort nach dem Fehler noch fertiggestellt hat.
* **Nutzung, die geprüft werden muss:** Kann DeepMask diese Nutzung nicht verifizieren, zum Beispiel weil sie als fehlgeschlagener Versuch erfasst ist, prüft DeepMask sie zuerst. Während der Prüfung sind Ihre Anfragen pausiert. Siehe [Wann Anfragen pausiert werden](https://documentation.deepmask.io/de/api/errors.md#wann-anfragen-pausiert-werden).
* **24-Stunden-Kontingent:** Bis zu 20 unklare Ergebnisse Ihrer Organisation innerhalb von 24 Stunden werden auf diese Weise freigegeben. Alle Ihre Schlüssel zählen zusammen. Unklare Ergebnisse, die älter als 24 Stunden sind, zählen nicht mehr. Die App zeigt diese Zahl nicht an.
* **Über dem Kontingent:** Ab dem 21. unklaren Ergebnis innerhalb von 24 Stunden prüft DeepMask jedes weitere, bevor es entscheidet, was berechnet wird. Die API-Anfragen Ihrer Organisation sind pausiert, bis DeepMask diese Ergebnisse geklärt hat.
* **Nach einer Pause:** Wenn DeepMask eine Pause aufhebt, wird die Zahl nicht zurückgesetzt. Jedes weitere unklare Ergebnis pausiert Ihre Anfragen erneut, bis weniger als 20 innerhalb der letzten 24 Stunden liegen.

Während einer Pause geben Anfragen aller Ihrer Schlüssel `503` zurück, und die Seite **API** zeigt einen Hinweis. Wiederholen Sie Anfragen nicht in einer Schleife. [Wenden Sie sich an den Support](https://documentation.deepmask.io/de/support/contact.md), damit DeepMask die Anfragen klären kann. Welche Codes Ihre Anwendungen erhalten und welche anderen Gründe eine Pause haben kann, erfahren Sie unter [Wann Anfragen pausiert werden](https://documentation.deepmask.io/de/api/errors.md#wann-anfragen-pausiert-werden).

Ein Verbindungsabbruch oder Timeout in Ihrer eigenen Anwendung ist kein unklares Ergebnis. Hat DeepMask die Anfrage bereits an das Modell gesendet, wird sie trotzdem abgeschlossen und abgerechnet. Trennt Ihre Anwendung die Verbindung vorher, wird die Anfrage weder gesendet noch abgerechnet.

> [!TIP]
>
> Damit Sie deutlich innerhalb des Kontingents bleiben, senden Sie eine Anfrage nicht in einer Schleife erneut, wenn sie immer wieder mit `502` oder `504` fehlschlägt oder ihr Stream immer wieder abbricht. Warten Sie und wiederholen Sie die Anfrage mit Backoff, wechseln Sie zu einem anderen Modell oder fordern Sie eine kürzere Antwort an. Die OpenAI-SDKs wiederholen `502` und `504` automatisch, standardmäßig zweimal. Jede Wiederholung, die auf dieselbe Weise fehlschlägt, zählt als weiteres unklares Ergebnis. Ein einzelner fehlschlagender Aufruf kann daher bis zu dreimal zählen. Setzen Sie für lange oder wiederholt fehlschlagende Anfragen einen niedrigeren Wert für `max_retries` (Python) bzw. `maxRetries` (Node.js).

### Mit Backoff wiederholen

Eine Anfrage über einem Limit wird sofort abgelehnt. Eine sofortige Wiederholung schlägt daher meist erneut fehl. Außerdem wird sie auf den Flood Guard Ihres Schlüssels angerechnet. Wiederholen Sie Anfragen mit exponentiellem Backoff und Jitter, und warten Sie mindestens so lange, wie ein Header `Retry-After` angibt. Wiederholen Sie Anfragen mit Codes für Ausgabenlimits nicht, denn sie schlagen so lange fehl, bis das Limit geändert oder zurückgesetzt wird. Geben alle Ihre Schlüssel `503` mit `API_ADMISSION_UNAVAILABLE` zurück, prüfen Sie vor einer Wiederholung, ob die Seite **API** einen Hinweis zeigt.

Unter [Fehlgeschlagene Anfragen wiederholen](https://documentation.deepmask.io/de/api/errors.md#fehlgeschlagene-anfragen-wiederholen) erfahren Sie, welche Fehler Sie wiederholen sollten, und finden ein Beispiel für eigene Wiederholungslogik.

## Höhere Limits anfordern

Wenn Sie für Ihre Organisation höhere Limits wünschen, [wenden Sie sich an den Support](https://documentation.deepmask.io/de/support/contact.md). Sie können höhere Werte für **Anfragen pro Minute**, **Tokens pro Minute** und **Gleichzeitige Anfragen** sowie ein höheres maximales **Gateway-Ausgabenlimit** anfordern.

* Geben Sie an, welche Limits erhöht werden sollen, und beschreiben Sie Ihren erwarteten Datenverkehr, zum Beispiel wie viele Anfragen Sie pro Minute senden und wie viele davon gleichzeitig laufen.
* Ein höherer Wert für **Gleichzeitige Anfragen** hilft nur, wenn auch **Tokens pro Minute** so viele gleichzeitig laufende Anfragen zulässt. Jede laufende Anfrage zählt mit etwa 2,0 bis 2,3 Millionen Tokens. Nennen Sie daher beide Limits, wenn Sie sich an den Support wenden. Siehe [Wie Tokens pro Minute gezählt werden](#wie-tokens-pro-minute-gezählt-werden).
* Höhere Limits für Ihre Organisation ändern die Limits pro Schlüssel nicht. Ein Schlüssel kann weiterhin bis zu 120 Anfragen pro Minute senden und 8 Anfragen in Bearbeitung haben. Um höhere Limits zu nutzen, verteilen Sie Ihren Datenverkehr auf mehrere Schlüssel.
* Ein höheres Limit erhöht nicht die gemeinsam genutzte Kapazität eines Modells, die DeepMask für jedes Modell festlegt. Wenn Sie viele gleichzeitige Anfragen an ein einzelnes Modell benötigen, geben Sie das an, wenn Sie sich an den Support wenden.

Sobald DeepMask Ihre Limits geändert hat, zeigt die Karte **API-Limits** auf der Registerkarte **Nutzung** die neuen Werte. Klicken Sie auf **Aktualisieren**, um sie zu sehen.

## Verwandte Seiten

> [card] [Fehler und Wiederholungen](https://documentation.deepmask.io/de/api/errors.md)
>
> Schlagen Sie Fehlercodes nach und erfahren Sie, welche Fehler Sie wiederholen sollten.

> [card] [Ausgabenlimits](https://documentation.deepmask.io/de/api/spending-caps.md)
>
> Begrenzen Sie die monatlichen Ausgaben Ihrer Organisation und jedes einzelnen Schlüssels.

> [card] [Nutzung und Protokolle](https://documentation.deepmask.io/de/api/usage-and-logs.md)
>
> Sehen Sie Ihre API-Limits ein, prüfen Sie Anfragen und exportieren Sie eine CSV-Datei.

> [card] [Modelle](https://documentation.deepmask.io/de/api/models.md)
>
> Vergleichen Sie Kontextfenster, maximale Ausgabe-Tokens und Bildeingabe der einzelnen Modelle.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.