Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Gränser för RPM/TPM i konsolen

Lektion 7 av 12 Uppdaterad 30 juli 2026 Avancerad
På denna sida
  1. Två nyckeltal att övervaka
  2. Nivåsystem
  3. Kontrollera dina gränser
  4. Beräkna din effektiva genomströmning
  5. Spåra dina kostnader i realtid
  6. Tokenizer för uppskattning innan sändning
  7. Viktiga punkter

Två nyckeltal att övervaka

xAI API tillämpar två typer av hastighetsbegränsningar, mätta per minut och per modell:

  • RPM (Requests Per Minute): Antalet API-förfrågningar du kan skicka per minut, oavsett innehåll.
  • TPM (Tokens Per Minute): Det totala antalet token (inmatning + utmatning) du kan förbruka per minut.

Du kan nå den ena gränsen utan att nå den andra. Till exempel förbrukar 10 korta förfrågningar på 100 token vardera lite TPM men räknas som 10 RPM. Omvänt förbrukar en enda förfrågan med 50 000 kontexttoken mycket TPM men bara 1 RPM.

Nivåsystem

Gränserna justeras automatiskt baserat på dina kumulativa utgifter. Nivån sänks aldrig när den väl har låsts upp:

Nivå Utgiftströskel Åtkomst
Nivå 0 0 USD (standard) Basgränser
Nivå 1 50 USD i utgifter Ökade gränser
Nivå 2 250 USD i utgifter Utökade gränser
Nivå 3 1 000 USD i utgifter Höga gränser
Nivå 4 5 000 USD i utgifter Premiumgränser
Enterprise På begäran Förhandlade gränser

Kumulativa utgifter inkluderar hela ditt kontohistorik. Du behöver inte spendera 50 USD på en månad: om du spenderar 10 USD per månad i 5 månader når du Nivå 1.

Kontrollera dina gränser

Gå till xAI-konsolen (console.x.ai) för att se dina aktuella gränser per modell. Varje modell har sina egna tak för RPM och TPM. Resonemangsmodeller har generellt lägre gränser än standardmodeller.

Beräkna din effektiva genomströmning

För att dimensionera din semafor baserat på dina gränser:

# Dina gränser (exempel Nivå 2)
rpm_limit = 120   # förfrågningar per minut
tpm_limit = 200_000  # token per minut

# Uppskatta dina förfrågningar
avg_input_tokens = 500
avg_output_tokens = 1000
tokens_per_request = avg_input_tokens + avg_output_tokens

# Tokengräns
max_rpm_by_tokens = tpm_limit / tokens_per_request  # 200000 / 1500 = 133

# Effektiv gräns = minimum av de två
effective_rpm = min(rpm_limit, max_rpm_by_tokens)  # min(120, 133) = 120

# Optimal semafor
avg_duration = 8  # sekunder per förfrågan
semaphore_value = int(effective_rpm * avg_duration / 60)  # 120 * 8 / 60 = 16

I detta exempel är en semafor på 16 det teoretiska maximumet. I praktiken bör du använda ett lägre värde (12–14) för att behålla en säkerhetsmarginal.

Spåra dina kostnader i realtid

Varje API-svar innehåller ett fält usage som indikerar kostnaden:

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

# Förbrukade token
usage = response.usage
print(f"Input tokens: {usage.prompt_tokens}")
print(f"Output tokens: {usage.completion_tokens}")
print(f"Total: {usage.total_tokens}")

För kostnader i dollar finns fältet cost_in_usd_ticks tillgängligt i vissa svar. Omvandlingen är: 10 miljarder ticks = 1 USD.

Tokenizer för uppskattning innan sändning

Innan du skickar en dyrbar förfrågan kan du uppskatta antalet token med tokeniseringsendpointen:

# 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"]

Detta låter dig verifiera att en stor prompt inte kommer att överskrida dina TPM-gränser innan du skickar den.

Viktiga punkter

  • RPM och TPM är två oberoende gränser: den strängaste gäller
  • Nivåer ökar automatiskt med dina kumulativa utgifter och sänks aldrig
  • Kontrollera console.x.ai för dina exakta gränser per modell
  • Dimensionera din semafor baserat på minimum mellan RPM och TPM
  • Använd fältet usage i svar för att spåra förbrukning i realtid
  • Endpointen /v1/tokenize-text låter dig uppskatta token innan sändning