Begrænsninger for RPM/TPM i konsollen
På denne side
To målinger, du skal holde øje med
xAI API håndhæver to typer hastighedsbegrænsninger, målt per minut og per model:
- RPM (Requests Per Minute): Antallet af API-anmodninger, du kan sende per minut, uanset deres indhold.
- TPM (Tokens Per Minute): Det samlede antal tokens (input + output), du kan forbruge per minut.
Du kan ramme den ene grænse uden at ramme den anden. F.eks. vil 10 korte anmodninger på 100 tokens hver forbruge lidt TPM, men tælle som 10 RPM. Omvendt vil en enkelt anmodning med 50.000 kontekst-tokens forbruge meget TPM, men kun tælle som 1 RPM.
Niveausystem
Grænserne justeres automatisk baseret på dit samlede forbrug. Niveauet falder aldrig, når det først er låst op:
| Niveau | Forbrugsgrænse | Adgang |
|---|---|---|
| Niveau 0 | $0 (standard) | Basisgrænser |
| Niveau 1 | $50 forbrug | Øgede grænser |
| Niveau 2 | $250 forbrug | Udvidede grænser |
| Niveau 3 | $1.000 forbrug | Høje grænser |
| Niveau 4 | $5.000 forbrug | Premium-grænser |
| Enterprise | Efter anmodning | Forhandlede grænser |
Samlet forbrug inkluderer hele din kontohistorik. Du behøver ikke bruge $50 på én måned: Hvis du bruger $10 om måneden i 5 måneder, når du Niveau 1.
Tjek dine grænser
Gå til xAI-konsollen (console.x.ai) for at se dine aktuelle grænser per model. Hver model har sine egne RPM- og TPM-lofter. Ræsonnementsmodeller har generelt lavere grænser end standardmodeller.
Beregn din effektive gennemstrømning
For at dimensionere din semaphore baseret på dine grænser:
# Dine grænser (eksempel Niveau 2)
rpm_limit = 120 # anmodninger per minut
tpm_limit = 200_000 # tokens per minut
# Estimer dine anmodninger
avg_input_tokens = 500
avg_output_tokens = 1000
tokens_per_request = avg_input_tokens + avg_output_tokens
# Token-grænse
max_rpm_by_tokens = tpm_limit / tokens_per_request # 200000 / 1500 = 133
# Effektiv grænse = minimum af de to
effective_rpm = min(rpm_limit, max_rpm_by_tokens) # min(120, 133) = 120
# Optimal semaphore
avg_duration = 8 # sekunder per anmodning
semaphore_value = int(effective_rpm * avg_duration / 60) # 120 * 8 / 60 = 16
I dette eksempel er en semaphore på 16 det teoretiske maksimum. I praksis bør du bruge en lavere værdi (12–14) for at beholde en sikkerhedsmargin.
Følg dine omkostninger i realtid
Hvert API-svar indeholder et usage-felt, der angiver omkostningerne:
response = await client.chat.completions.create(
model="grok-4.5",
messages=[{"role": "user", "content": prompt}]
)
# Forbrugte tokens
usage = response.usage
print(f"Input tokens: {usage.prompt_tokens}")
print(f"Output tokens: {usage.completion_tokens}")
print(f"Total: {usage.total_tokens}")
For omkostninger i dollars er feltet cost_in_usd_ticks tilgængeligt i nogle svar. Omregningen er: 10 milliarder ticks = 1 USD.
Tokenizer til estimering før afsendelse
Før du sender en dyr anmodning, kan du estimere antallet af tokens med tokeniserings-endpointet:
# Via 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"]
Dette giver dig mulighed for at verificere, at en stor prompt ikke vil overskride dine TPM-grænser, før du sender den.
Vigtige pointer
- RPM og TPM er to uafhængige grænser: den strengeste gælder
- Niveauer stiger automatisk med dit samlede forbrug og falder aldrig
- Tjek
console.x.aifor dine nøjagtige grænser per model - Dimensionér din semaphore baseret på minimumsværdien mellem RPM og TPM
- Brug
usage-feltet i svar til at spore forbruget i realtid - Endpointet
/v1/tokenize-textlader dig estimere tokens før afsendelse