Rate limits RPM/TPM de la console

Deux métriques à surveiller

L’API xAI impose deux types de limites de débit, mesurées par minute et par modèle :

• RPM (Requests Per Minute) : le nombre de requêtes API que vous pouvez envoyer par minute, quel que soit leur contenu.
• TPM (Tokens Per Minute) : le nombre total de tokens (entrée + sortie) que vous pouvez consommer par minute.

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

Système de tiers

Les limites évoluent automatiquement en fonction de vos dépenses cumulées. Le tier ne redescend jamais une fois débloqué :

Les dépenses cumulées incluent tout l’historique de votre compte. Pas besoin de dépenser $50 en un mois : si vous avez dépensé $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 modèle. Chaque modèle a ses propres plafonds RPM et TPM. Les modèles de raisonnement ont généralement des limites plus basses que les modèles standards.

Calculer votre débit effectif

Pour dimensionner votre sémaphore 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 requête
semaphore_value = int(effective_rpm * avg_duration / 60)  # 120 * 8 / 60 = 16

Dans cet exemple, un sémaphore de 16 est le maximum théorique. En pratique, utilisez une valeur inférieure (12-14) pour conserver une marge de sécurité.

Suivre vos coûts en temps réel

Chaque réponse de l’API contient un champ usage qui indique le coût :

response = await client.chat.completions.create(
    model="grok-4.5",
    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 coûts en dollars, le champ cost_in_usd_ticks est disponible dans certaines réponses. La conversion est : 10 milliards de ticks = 1 dollar USD.

Tokenizer pour estimer avant d’envoyer

Avant d’envoyer une requête coûteuse, 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 vérifier qu’un prompt volumineux ne dépassera pas vos limites TPM avant de l’envoyer.

Points clés à retenir

• RPM et TPM sont deux limites indépendantes : la plus restrictive s’applique
• Les tiers augmentent automatiquement avec vos dépenses cumulées et ne redescendent jamais
• Consultez console.x.ai pour connaître vos limites exactes par modèle
• Dimensionnez votre sémaphore en fonction du minimum entre RPM et TPM
• Utilisez le champ usage des réponses pour suivre votre consommation en temps réel
• L’endpoint /v1/tokenize-text permet d’estimer les tokens avant envoi