Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

RPM/TPM-Ratenbegrenzungen in der Konsole

Lektion 7 von 12 Aktualisiert am 30. Juli 2026 Fortgeschritten
Auf dieser Seite
  1. Zwei zu überwachende Metriken
  2. Stufensystem
  3. Ihre Begrenzungen prüfen
  4. Berechnung Ihres effektiven Durchsatzes
  5. Verfolgung Ihrer Kosten in Echtzeit
  6. Tokenizer zur Schätzung vor dem Senden
  7. Kernaussagen

Zwei zu überwachende Metriken

Die xAI-API unterwirft zwei Arten von Ratenbegrenzungen, die pro Minute und pro Modell gemessen werden:

  • RPM (Requests Per Minute): Die Anzahl der API-Anfragen, die Sie pro Minute senden können, unabhängig von deren Inhalt.
  • TPM (Tokens Per Minute): Die Gesamtzahl der Tokens (Eingabe + Ausgabe), die Sie pro Minute verbrauchen können.

Sie können eine Begrenzung erreichen, ohne die andere zu überschreiten. Zum Beispiel verbrauchen 10 kurze Anfragen mit jeweils 100 Tokens wenig TPM, zählen aber als 10 RPM. Umgekehrt verbraucht eine einzelne Anfrage mit 50.000 Kontexttokens viel TPM, zählt aber nur 1 RPM.

Stufensystem

Die Begrenzungen passen sich automatisch an Ihre kumulative Ausgabeeinlage an. Sobald eine Stufe freigeschaltet ist, sinkt diese nie wieder:

Stufe Ausgabeeinlage-Schwelle Zugriff
Stufe 0 $0 (Standard) Basisbegrenzungen
Stufe 1 $50 Ausgabeeinlage Erhöhte Begrenzungen
Stufe 2 $250 Ausgabeeinlage Erweiterte Begrenzungen
Stufe 3 $1.000 Ausgabeeinlage Hohe Begrenzungen
Stufe 4 $5.000 Ausgabeeinlage Premium-Begrenzungen
Enterprise Auf Anfrage Verhandelte Begrenzungen

Die kumulative Ausgabeeinlage umfasst Ihre gesamte Kontohistorie. Sie müssen nicht innerhalb eines Monats 50 $ ausgeben: Wenn Sie 10 $ pro Monat über fünf Monate ausgeben, erreichen Sie Stufe 1.

Ihre Begrenzungen prüfen

Gehen Sie zur xAI-Konsole (console.x.ai), um Ihre aktuellen Begrenzungen pro Modell einzusehen. Jedes Modell verfügt über eigene RPM- und TPM-Obergrenzen. Denkmodelle haben im Allgemeinen niedrigere Begrenzungen als Standardmodelle.

Berechnung Ihres effektiven Durchsatzes

Um Ihr Semaphore basierend auf Ihren Begrenzungen zu dimensionieren:

# Ihre Begrenzungen (Beispiel Stufe 2)
rpm_limit = 120   # Anfragen pro Minute
tpm_limit = 200_000  # Tokens pro Minute

# Schätzung Ihrer Anfragen
avg_input_tokens = 500
avg_output_tokens = 1000
tokens_per_request = avg_input_tokens + avg_output_tokens

# Token-Begrenzung
max_rpm_by_tokens = tpm_limit / tokens_per_request  # 200000 / 1500 = 133

# Effektive Begrenzung = Minimum der beiden
effective_rpm = min(rpm_limit, max_rpm_by_tokens)  # min(120, 133) = 120

# Optimales Semaphore
avg_duration = 8  # Sekunden pro Anfrage
semaphore_value = int(effective_rpm * avg_duration / 60)  # 120 * 8 / 60 = 16

In diesem Beispiel ist ein Semaphore mit 16 der theoretische Maximumswert. In der Praxis verwenden Sie einen niedrigeren Wert (12–14), um einen Sicherheitspuffer zu behalten.

Verfolgung Ihrer Kosten in Echtzeit

Jede API-Antwort enthält ein usage-Feld, das die Kosten angibt:

response = await client.chat.completions.create(
    model="grok-4.5",
    messages=[{"role": "user", "content": prompt}]
)

# Verbrauchte Tokens
usage = response.usage
print(f"Eingabetokens: {usage.prompt_tokens}")
print(f"Ausgabetokens: {usage.completion_tokens}")
print(f"Gesamt: {usage.total_tokens}")

Für Kosten in US-Dollar ist das Feld cost_in_usd_ticks in manchen Antworten verfügbar. Die Umrechnung lautet: 10 Milliarden Ticks entsprechen 1 USD.

Tokenizer zur Schätzung vor dem Senden

Bevor Sie eine kostspielige Anfrage senden, können Sie die Tokenanzahl mit dem Tokenisierungsendpunkt schätzen:

# Über die REST-API
import httpx

async def count_tokens(text: str) -> int:
    async with httpx.AsyncClient() as http:
        response = await http.post(
            "https://api.x.ai/v1/tokenize-text",
            headers={"Authorization": f"Bearer {api_key}"},
            json={"text": text}
        )
        return response.json()["token_count"]

Dies ermöglicht es Ihnen zu überprüfen, ob ein großer Prompt Ihre TPM-Begrenzungen überschreiten wird, bevor Sie ihn senden.

Kernaussagen

  • RPM und TPM sind zwei unabhängige Begrenzungen: Die strengere gilt.
  • Stufen steigen automatisch mit Ihrer kumulativen Ausgabeeinlage an und sinken nie wieder.
  • Prüfen Sie console.x.ai für Ihre genauen Begrenzungen pro Modell.
  • Dimensionieren Sie Ihr Semaphore basierend auf dem Minimum zwischen RPM und TPM.
  • Verwenden Sie das usage-Feld in Antworten, um den Verbrauch in Echtzeit zu verfolgen.
  • Der Endpunkt /v1/tokenize-text ermöglicht die Schätzung von Tokens vor dem Senden.