Rate limits RPM/TPM de la console

Deux metriques a surveiller

L’API xAI impose deux types de limites de debit, mesurees par minute et par modele :

• RPM (Requests Per Minute) : le nombre de requetes API que vous pouvez envoyer par minute, quel que soit leur contenu.
• TPM (Tokens Per Minute) : le nombre total de tokens (entree + sortie) que vous pouvez consommer par minute.

Vous pouvez atteindre l’une sans atteindre l’autre. Par exemple, 10 requetes courtes de 100 tokens chacune consomment peu de TPM mais comptent pour 10 RPM. A l’inverse, une seule requete avec 50 000 tokens de contexte consomme beaucoup de TPM mais seulement 1 RPM.

Systeme de tiers

Les limites evoluent automatiquement en fonction de vos depenses cumulees. Le tier ne redescend jamais une fois debloque :

Les depenses cumulees incluent tout l’historique de votre compte. Pas besoin de depenser $50 en un mois : si vous avez depense $10 par mois pendant 5 mois, vous atteignez le Tier 1.

Consulter vos limites

Rendez-vous sur la console xAI (console.x.ai) pour voir vos limites actuelles par modele. Chaque modele a ses propres plafonds RPM et TPM. Les modeles de raisonnement ont generalement des limites plus basses que les modeles standards.

Calculer votre debit effectif

Pour dimensionner votre semaphore en fonction de vos limites :

# Vos limites (exemple Tier 2)
rpm_limit = 120   # requetes par minute
tpm_limit = 200_000  # tokens par minute

# Estimation de vos requetes
avg_input_tokens = 500
avg_output_tokens = 1000
tokens_per_request = avg_input_tokens + avg_output_tokens

# Limite par les tokens
max_rpm_by_tokens = tpm_limit / tokens_per_request  # 200000 / 1500 = 133

# Limite effective = min des deux
effective_rpm = min(rpm_limit, max_rpm_by_tokens)  # min(120, 133) = 120

# Semaphore optimal
avg_duration = 8  # secondes par requete
semaphore_value = int(effective_rpm * avg_duration / 60)  # 120 * 8 / 60 = 16

Dans cet exemple, un semaphore de 16 est le maximum theorique. En pratique, utilisez une valeur inferieure (12-14) pour conserver une marge de securite.

Suivre vos couts en temps reel

Chaque reponse de l’API contient un champ usage qui indique le cout :

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

# Tokens consommes
usage = response.usage
print(f"Tokens entree : {usage.prompt_tokens}")
print(f"Tokens sortie : {usage.completion_tokens}")
print(f"Total : {usage.total_tokens}")

Pour les couts en dollars, le champ cost_in_usd_ticks est disponible dans certaines reponses. La conversion est : 10 milliards de ticks = 1 dollar USD.

Tokenizer pour estimer avant d’envoyer

Avant d’envoyer une requete couteuse, vous pouvez estimer le nombre de tokens avec l’endpoint de tokenisation :

# Via l'API REST
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"]

Cela vous permet de verifier qu’un prompt volumineux ne depassera pas vos limites TPM avant de l’envoyer.

Points cles a retenir

• RPM et TPM sont deux limites independantes : la plus restrictive s’applique
• Les tiers augmentent automatiquement avec vos depenses cumulees et ne redescendent jamais
• Consultez console.x.ai pour connaitre vos limites exactes par modele
• Dimensionnez votre semaphore en fonction du minimum entre RPM et TPM
• Utilisez le champ usage des reponses pour suivre votre consommation en temps reel
• L’endpoint /v1/tokenize-text permet d’estimer les tokens avant envoi