API Cerebras gratuite : ce que vous obtenez et comment la tester

Cerebras ne vend qu'un seul chiffre : la vitesse. Le discours commercial est que ses puces à l'échelle du wafer débitent des tokens plus vite qu'une grappe de GPU ne pourra jamais le faire, et le niveau gratuit est la façon dont l'entreprise attire votre attention. Mais « rapide » n'est pas quelque chose que vous devriez accepter sur parole d'un fournisseur. C'est quelque chose que vous mesurez, sur votre propre connexion, avec votre propre prompt, puis que vous conservez comme un enregistrement que vous pouvez rejouer chaque fois que Cerebras publie un nouveau modèle ou modifie une limite.

Essayez Apidog dès aujourd'hui

Ce guide réalise cette mesure avec vous. Vous obtiendrez une clé API Cerebras, effectuerez un véritable appel de complétion de chat sur le point de terminaison compatible OpenAI, chronométrerez le premier token et la réponse complète, et demanderez à votre agent de codage de transformer toute la requête en un test Apidog CLI afin qu'il survive au prochain changement de modèle.

TL;DR

Cerebras offre aux nouveaux comptes un niveau Essai gratuit : 5 $ de crédits qui expirent 30 jours après leur attribution, limités à deux modèles (gpt-oss-120b et qwen-3.8-27b) à 5 requêtes par minute et 30K tokens non mis en cache par minute chacun, selon les limites de débit publiées par Cerebras. L'API est compatible OpenAI à l'adresse https://api.cerebras.ai/v1, vous pouvez donc pointer un client OpenAI existant vers elle et modifier trois lignes. Ci-dessous, vous construirez une requête qui mesure vous-même le temps jusqu'au premier token et les tokens par seconde, au lieu de faire confiance à une page marketing.

Ce que le niveau gratuit documente, et ce qu'il ne documente pas

La page de tarification de Cerebras affiche ses chiffres côté client, ce qui signifie que le tarif exact au dollar par million de tokens pour l'usage payant n'est pas quelque chose que vous pouvez extraire d'une récupération statique de la page. Ne devinez pas ce chiffre. Quand vous en avez besoin, ouvrez vous-même l'onglet de facturation de la console Cerebras Cloud, car c'est le seul endroit où le tarif actuel est garanti exact.

Ce que la documentation indique clairement, dans la page d'assistance sur les limites de débit, c'est la forme du niveau Essai gratuit :

Niveau	Modèles	RPM	TPM non mis en cache	TPM total	TPH	TPD
Essai gratuit	gpt-oss-120b, qwen-3.8-27b	5	30K	90K	1M	1M
Développeur (gpt-oss-120b)	paiement à l'usage	1,000	1M	3M	aucun	aucun
Développeur (qwen-3.8-27b)	paiement à l'usage	300	150K	450K	aucun	aucun

Deux choses comptent ici. Premièrement, « TPM non mis en cache » est le véritable plafond : ce sont les tokens qui nécessitent un calcul complet, et votre allocation totale de TPM est environ trois fois supérieure une fois les hits de cache comptés. Deuxièmement, le compte Essai gratuit est limité en crédits et en temps, pas en requêtes pour toujours : une fois les 5 $ épuisés ou les 30 jours écoulés, vous retombez à ce que le niveau de compte autorise jusqu'à ce que vous ajoutiez un moyen de paiement. Tout ce qui va au-delà de ce tableau (tarification par token, tarification par siège, conditions entreprise) se trouve derrière la page de tarification rendue en JavaScript et la console, pas dans la documentation statique, alors vérifiez-le là-bas avant d'établir un budget en fonction.

Si vous avez déjà heurté un mur comme celui-ci chez un autre fournisseur, le schéma est le même que celui couvert dans notre guide sur quoi faire lorsque vous recevez une réponse 429 rate-limit-exceeded : lisez le corps de l'erreur, ralentissez, et consultez le tableau de bord avant de supposer que l'API est cassée.

Obtenez une clé et effectuez un véritable appel

Inscrivez-vous sur cloud.cerebras.ai, ouvrez API Keys, et générez-en une. Le propre guide de démarrage rapide de Cerebras vous indique de la définir comme variable d'environnement afin qu'elle ne se retrouve jamais à la main dans un corps de requête :

export CEREBRAS_API_KEY="your-key-here"

L'URL de base est https://api.cerebras.ai/v1, et le point de terminaison de complétion de chat correspond directement à la forme d'OpenAI : POST /v1/chat/completions avec un model et un tableau messages. Cette compatibilité est documentée dans la référence API, et c'est la raison pour laquelle vous pouvez intégrer Cerebras dans du code écrit pour la bibliothèque cliente d'OpenAI en changeant l'URL de base et la clé. Un appel curl brut ressemble à ceci :

curl https://api.cerebras.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${CEREBRAS_API_KEY}" \
  -d '{
    "model": "qwen-3.8-27b",
    "messages": [
      {"role": "user", "content": "Explain time-to-first-token in two sentences."}
    ]
  }'

Exécutez-le, et la réponse contient plus que le texte de complétion. Elle inclut un bloc usage (prompt_tokens, completion_tokens, total_tokens) et un bloc time_info (queue_time, total_time) que Cerebras renvoie à chaque appel.

Si votre équipe teste plus d'un modèle ou fournisseur, c'est le bon moment pour arrêter de dépendre de commandes curl ponctuelles. La section sur Apidog CLI ci-dessous amène votre agent de codage à transformer cet appel en un test qu'il rejoue chaque fois que Cerebras ajoute un modèle ou modifie une limite.

Mesurez l'allégation de vitesse : temps jusqu'au premier token et tokens par seconde

Deux chiffres vous disent si « rapide » est réel pour votre charge de travail : le temps jusqu'au premier token (TTFT) et les tokens générés par seconde. Aucun des deux n'apparaît comme métrique principale dans la réponse de l'API, vous les calculez donc à partir de ce que l'appel vous donne.

Pour le TTFT, diffusez la réponse en streaming et enregistrez l'écart de temps réel entre l'envoi de la requête et la réception du premier morceau :

import time
from cerebras.cloud.sdk import Cerebras

client = Cerebras()
start = time.perf_counter()
first_token_at = None

stream = client.chat.completions.create(
    model="qwen-3.8-27b",
    messages=[{"role": "user", "content": "Write a haiku about wafer-scale chips."}],
    stream=True,
)

for chunk in stream:
    if first_token_at is None and chunk.choices[0].delta.content:
        first_token_at = time.perf_counter() - start
        print(f"Time to first [REDACTED CREDENTIAL]

Pour les tokens par seconde, utilisez un appel non-streaming et divisez les tokens de complétion par le total_time que Cerebras indique dans time_info :

response = client.chat.completions.create(
    model="qwen-3.8-27b",
    messages=[{"role": "user", "content": "Explain the CS-3 wafer-scale engine in 100 words."}],
)

tokens = response.usage.completion_tokens
seconds = response.time_info.total_time
print(f"{tokens / seconds:.1f} tokens/sec")

Exécutez ceci plusieurs fois, à différentes heures, avec un prompt proche de ce que votre produit envoie. Conservez les deux scripts et rejouez-les chaque fois que Cerebras ajoute un modèle au niveau gratuit, car le chiffre de tokens par seconde change selon le modèle, pas seulement selon le fournisseur.

Lisez les limites avant qu'elles ne vous lisent

La conception des limites de débit de Cerebras comporte une subtilité qui vaut la peine d'être connue avant de scripter quoi que ce soit : elle suit deux compartiments de tokens distincts par organisation, le TPM non mis en cache et le TPM total, et applique les deux en même temps. Une rafale de prompts courts et répétitifs peut atteindre le plafond de requêtes par minute avant même d'approcher le plafond de tokens, exactement le piège décrit dans notre article plus large sur comment fonctionne la limitation de débit des API.

Une lacune honnête dans la documentation : Cerebras ne publie pas un ensemble d'en-têtes de réponse x-ratelimit-* comme le font certains fournisseurs. La référence API n'en liste aucun, et la page des limites de débit non plus. C'est différent de l'API de complétion de chat d'OpenAI, qui renvoie des en-têtes de quota restant à chaque appel, un schéma que notre guide des limites de débit d'OpenAI couvre plus en détail. Avec Cerebras, les deux endroits pour vérifier votre situation réelle sont la section Limites de la console Cloud et le corps d'une réponse 429, qui indique si vous avez dépassé le plafond de tokens non mis en cache ou le plafond total. Construisez votre logique de nouvelle tentative autour de ce corps d'erreur au lieu de supposer qu'un en-tête vous préviendra en premier.

Laissez votre agent de codage le rejouer avec Apidog CLI

Une mesure dans un fichier brouillon ne prouve rien le mois suivant. Demandez à votre agent de codage de transformer l'appel en un test qu'il peut rejouer via Apidog CLI. Configurez-le une fois :

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted

Le token provient d'Apidog sous Paramètres du compte, API Access Token. Ensuite, donnez à l'agent un [REDACTED PROMPT]
Use Apidog CLI on project . Create a Cerebras environment with base URL
https://api.cerebras.ai/v1 and add POST /chat/completions with Bearer [REDACTED] from
{{CEREBRAS_API_KEY}} and model set to {{MODEL}}. Create a test case asserting
status 200 and time_info.total_time under {{MAX_TOTAL_TIME}}, run it for
gpt-oss-120b and qwen-3.8-27b, and report completion tokens per second for each.

Les commandes qu'il exécute, vérifiées par rapport à Apidog CLI 2.2.7 :

bash
apidog environment create Cerebras --project --base-url https://api.cerebras.ai/v1
apidog endpoint create --project --file cerebras-chat.json
apidog cli-schema validate test-case-create --file speed-case.json
apidog test-case create --project --file speed-case.json
apidog run --test-case --project -e -d models.csv \
--delay-request 12000 --env-var "CEREBRAS_API_KEY=$CEREBRAS_API_KEY" -r cli,json

`models.csv` contient une colonne `MODEL`, donc une seule exécution couvre les deux modèles, et tout ce que Cerebras publiera ensuite est une ligne de plus. `--delay-request 12000` espace les appels de 12 secondes pour rester sous les 5 requêtes par minute de l'Essai gratuit. Pour le chemin 429, demandez un second cas qui dépasse délibérément cette limite et vérifie le corps de l'erreur, afin qu'il soit capturé et versionné au lieu d'être redécouvert en production. C'est un flux de travail, pas un benchmark ponctuel ; consultez notre sélection d'[outils de test d'API conçus pour les charges de travail d'agents et de LLM](https://apidog.com/fr/blog/best-api-testing-tools-ai-agents?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) si vous comparez les options, et [Apidog CLI dans Claude Code](https://apidog.com/fr/blog/apidog-cli-in-claude-code?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) pour le côté agent.

## Niveau gratuit ou niveau Développeur : quand changer

Le niveau Essai gratuit est conçu exactement pour ce que ce guide parcourt : confirmer l'allégation de vitesse et la forme de la requête avant d'engager une carte. Une fois que vous construisez réellement contre Cerebras, le saut du niveau Développeur, de 5 RPM à 1 000 RPM sur `gpt-oss-120b`, est le chiffre qui force généralement la décision, pas le prix par token. Si votre volume de prompts est en rafales plutôt que régulier, comparez les chiffres de Cerebras aux alternatives avant de vous engager ; notre liste d'[alternatives à OpenRouter](https://apidog.com/fr/blog/best-openrouter-alternatives?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) et notre présentation du [niveau gratuit de l'API de Groq](https://apidog.com/fr/blog/groq-api-free?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) valent toutes deux la peine d'être lues côte à côte avec le tableau ci-dessus, car la vitesse d'inférence et les plafonds des niveaux gratuits varient plus entre fournisseurs que la plupart des articles de comparaison ne l'admettent. Une différence à connaître avant de choisir : [Groq documente directement les limites du plan gratuit par modèle](https://console.groq.com/docs/rate-limits), par exemple `openai/gpt-oss-120b` à 30 RPM, 1 000 RPD, 8K TPM et 200K TPD, et renvoie des en-têtes de réponse `x-ratelimit-*` à chaque appel, vous connaissez donc toujours votre budget restant à partir de la réponse elle-même. Cerebras ne vous donne ni l'un ni l'autre ; vous lisez votre situation depuis la console Cloud ou vous la déduisez d'un corps 429, comme expliqué ci-dessus.

## FAQ

**Le niveau gratuit de Cerebras nécessite-t-il une carte de crédit ?**

Le niveau Essai gratuit est basé sur des crédits (5 $, expirant après 30 jours) plutôt qu'un plan gratuit récurrent, et la documentation de Cerebras vous dirige vers la console Cloud pour les exigences d'inscription actuelles, car ce détail peut changer indépendamment de la documentation statique.

**Quels modèles sont disponibles sur le niveau gratuit ?**

D'après la [documentation actuelle sur les limites de débit](https://inference-docs.cerebras.ai/support/rate-limits), deux : `gpt-oss-120b` et `qwen-3.8-27b`. Les deux partagent les mêmes limites d'Essai gratuit (5 RPM, 30K TPM non mis en cache).

**Puis-je utiliser mon code existant du SDK OpenAI avec Cerebras ?**

Oui. Pointez l'URL de base du client vers `https://api.cerebras.ai/v1` et remplacez par votre clé Cerebras ; la forme de `/v1/chat/completions` correspond, selon la [référence API](https://inference-docs.cerebras.ai/api-reference/chat-completions).

**Pourquoi ai-je reçu un 429 alors que je suis sous mon budget de tokens ?**

Cerebras applique le TPM non mis en cache, le TPM total et le RPM comme des plafonds séparés. Une volée de petites requêtes peut déclencher la limite de RPM bien avant qu'un compartiment de tokens ne se remplisse, ce qui est le même mode de défaillance que celui couvert dans notre [guide de dépannage des dépassements de limite de débit](https://apidog.com/fr/blog/rate-limit-exceeded-guide?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation).

**Comment puis-je vérifier mon utilisation actuelle sans d'abord heurter un mur ?**

Cerebras ne renvoie pas d'en-têtes de réponse de quota restant, alors vérifiez directement la section Limites dans la [console Cloud](https://cloud.cerebras.ai) au lieu de la déduire des réponses de l'API. Le plan gratuit de Groq adopte l'approche opposée et renvoie des en-têtes `x-ratelimit-*` à chaque appel, alors pesez cette différence si la surveillance basée sur les en-têtes compte pour votre configuration.

Le véritable avantage de Cerebras apparaît dans le bloc `time_info` de vos propres appels, pas dans un titre marketing.