Utiliser Groq GPT-OSS 120B avec le SDK OpenAI : URL de base, tarifs et mise en cache

L’endpoint compatible OpenAI de Groq est vraiment un remplacement en une seule ligne : définissez base_url sur https://api.groq.com/openai/v1 et continuez à utiliser le SDK OpenAI. Au 17 juin 2026, Groq affiche openai/gpt-oss-120b à 0,15 $ par 1 M de tokens d’entrée non mis en cache, 0,075 $ par 1 M de tokens d’entrée mis en cache et 0,60 $ par 1 M de tokens de sortie sur sa page de tarifs (Tarifs Groq).

C’est la partie utile. Le piège consiste à supposer que « compatible OpenAI » signifie « comportement identique et facturation identique ». Ce n’est pas le cas. Vous devez toujours choisir l’ID de modèle Groq, surveiller les succès de cache, éviter les paramètres OpenAI non pris en charge et comptabiliser séparément les appels aux outils intégrés.

Ce que vous changez réellement

La documentation de Groq indique que son API est « principalement compatible avec les bibliothèques clientes d’OpenAI » et montre la configuration exacte du client OpenAI : transmettez votre clé Groq et définissez base_url="https://api.groq.com/openai/v1" (Compatibilité OpenAI de Groq).

Installez le SDK Python OpenAI :

pip install openai
export GROQ_API_KEY="gsk_..."

Appelez ensuite GPT-OSS 120B via Groq :

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["GROQ_API_KEY"],
    base_url="https://api.groq.com/openai/v1",
)

response = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    messages=[
        {"role": "system", "content": "You are a concise senior backend engineer."},
        {"role": "user", "content": "Write a PostgreSQL index plan for a slow user_events query."},
    ],
)

print(response.choices[0].message.content)
print(response.usage)

La différence importante est le model. Sur la plateforme d’OpenAI, vous pourriez utiliser le nom d’un modèle hébergé par OpenAI. Sur Groq, GPT-OSS est référencé sous la forme openai/gpt-oss-120b ou openai/gpt-oss-20b.

OpenAI a publié gpt-oss-120b et gpt-oss-20b le 5 août 2025 en tant que modèles de raisonnement à poids ouverts sous licence Apache 2.0 (OpenAI). OpenAI indique que gpt-oss-120b compte 117 Md de paramètres au total, 5,1 Md de paramètres actifs par token, 128 experts, 4 experts actifs par token et une prise en charge native de longueurs de contexte allant jusqu’à 128k (OpenAI). La page modèle de Groq indique que la fenêtre de contexte du modèle hébergé openai/gpt-oss-120b est de 131 072 tokens et que le nombre maximal de tokens de sortie est de 65 536 (fiche modèle Groq).

Choisir 120B ou 20B

Utilisez 120B lorsque la qualité compte plus que le coût brut : planification d’agents, tâches de code plus difficiles, extraction complexe ou raisonnement en plusieurs étapes. Utilisez 20B lorsque vous avez besoin d’un débit moins cher pour le routage, la synthèse, la classification, des assistants courts ou des traitements de fond à fort volume.

ID de modèle Groq	Vitesse indiquée	Entrée non mise en cache	Entrée mise en cache	Sortie
openai/gpt-oss-120b	500 TPS	$0.15 / 1M	$0.075 / 1M	$0.60 / 1M
openai/gpt-oss-20b	1,000 TPS	$0.075 / 1M	$0.0375 / 1M	$0.30 / 1M

Ces prix proviennent du tableau tarifaire actuel de Groq et du tableau de mise en cache des prompts (Tarifs Groq). Le modèle 20B coûte exactement la moitié du prix par token indiqué pour 120B. Cela en fait un bon choix par défaut pour les workflows de type « essayer d’abord ». Si la qualité de la réponse n’est pas suffisante, faites passer ce chemin en 120B.

Voici un petit interrupteur que vous pouvez garder dans la configuration :

import os
from openai import OpenAI

MODEL = os.getenv("GROQ_MODEL", "openai/gpt-oss-20b")

client = OpenAI(
    api_key=os.environ["GROQ_API_KEY"],
    base_url="https://api.groq.com/openai/v1",
)

def ask(prompt: str) -> str:
    response = client.chat.completions.create(
        model=MODEL,
        messages=[
            {"role": "system", "content": "Answer with practical developer steps."},
            {"role": "user", "content": prompt},
        ],
    )
    return response.choices[0].message.content

print(ask("Give me a minimal Redis rate limiter design."))

Exécutez-le avec 20B :

GROQ_MODEL=openai/gpt-oss-20b python app.py

Exécutez-le avec 120B :

GROQ_MODEL=openai/gpt-oss-120b python app.py

Tarifer les requêtes avec des succès de cache

La mise en cache des prompts Groq est automatique pour les modèles pris en charge, notamment openai/gpt-oss-20b et openai/gpt-oss-120b. Groq indique qu’aucune modification du code n’est nécessaire, que les succès de cache utilisent une correspondance exacte de préfixe, que les parties mises en cache bénéficient d’une remise de 50 % sur les tokens d’entrée et que les données mises en cache expirent automatiquement après 2 heures sans utilisation (Mise en cache des prompts Groq).

La règle pratique : placez le texte stable en premier.

Bon ordre :

1. Prompt système
2. Définitions d’outils
3. Exemples few-shot
4. Documents ou schémas partagés
5. Entrée spécifique à l’utilisateur
6. Horodatages, ID, données propres à la requête

Mauvais ordre : placer un horodatage, un ID de requête ou un champ propre à l’utilisateur avant un prompt partagé de 20 000 tokens. Cela casse le préfixe.

Voici un utilitaire de coût pour GPT-OSS 120B :

def groq_gpt_oss_120b_cost(prompt_tokens, cached_tokens, completion_tokens):
    uncached_tokens = max(prompt_tokens - cached_tokens, 0)

    return (
        uncached_tokens / 1_000_000 * 0.15
        + cached_tokens / 1_000_000 * 0.075
        + completion_tokens / 1_000_000 * 0.60
    )

Et voici un appel exécutable qui affiche l’utilisation du cache si Groq la renvoie :

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["GROQ_API_KEY"],
    base_url="https://api.groq.com/openai/v1",
)

STATIC_POLICY = """
You are an internal code review assistant.
Always check correctness, security, performance, and migration risk.
Return JSON with keys: summary, risks, suggested_patch.
"""

def review(diff: str):
    response = client.chat.completions.create(
        model="openai/gpt-oss-120b",
        messages=[
            {"role": "system", "content": STATIC_POLICY},
            {"role": "user", "content": diff},
        ],
        response_format={"type": "json_object"},
    )

    usage = response.usage
    details = getattr(usage, "prompt_tokens_details", None)
    cached = getattr(details, "cached_tokens", 0) if details else 0

    print("prompt_tokens:", usage.prompt_tokens)
    print("cached_tokens:", cached)
    print("completion_tokens:", usage.completion_tokens)
    print("estimated_cost_usd:", groq_gpt_oss_120b_cost(
        usage.prompt_tokens,
        cached,
        usage.completion_tokens,
    ))

    return response.choices[0].message.content

La documentation de mise en cache de Groq montre cached_tokens sous usage.prompt_tokens_details et définit le taux de succès du cache comme cached_tokens / prompt_tokens × 100% (Mise en cache des prompts Groq). Ne partez pas du principe que chaque deuxième requête est moins chère. Les préfixes exacts comptent.

Compter les appels aux outils séparément

Les prix des tokens ne représentent pas toute la facture si vous activez des outils intégrés. La page de tarifs de Groq liste séparément les outils intégrés pour GPT-OSS : Browser Search basic search coûte 5 $ / 1000 requêtes, Browser Search visit website coûte 1 $ / 1000 requêtes et Code Execution Python coûte 0,18 $ / heure (Tarifs Groq).

Cela change la façon dont vous concevez les agents. Un bot de support qui appelle la recherche une fois par message utilisateur a un profil de coût différent d’un outil de synthèse qui n’utilise que des tokens de prompt. Le cache aide pour les schémas d’outils répétés, mais il ne rend pas gratuits les appels à des outils externes.

Vérifiez aussi la compatibilité avant de copier-coller du code OpenAI. La documentation de compatibilité OpenAI de Groq liste des champs non pris en charge qui peuvent renvoyer 400, notamment logprobs, logit_bias, top_logprobs, messages[].name et les valeurs de n autres que 1 (Compatibilité OpenAI de Groq). Groq indique également que temperature=0 est converti en 1e-8.

Une requête minimale sûre ressemble à ceci :

response = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    temperature=0.2,
    messages=[
        {"role": "system", "content": "Be precise. If unsure, say so."},
        {"role": "user", "content": "Explain this stack trace and suggest a fix: ..."},
    ],
)

Évitez de migrer toute votre application dans un seul commit. Placez les paramètres du fournisseur derrière des variables d’environnement :

LLM_BASE_URL=https://api.groq.com/openai/v1
LLM_API_KEY=$GROQ_API_KEY
LLM_MODEL=openai/gpt-oss-120b

Puis branchez-les dans le SDK :

client = OpenAI(
    api_key=os.environ["LLM_API_KEY"],
    base_url=os.environ["LLM_BASE_URL"],
)

response = client.chat.completions.create(
    model=os.environ["LLM_MODEL"],
    messages=[{"role": "user", "content": "Summarize this incident report."}],
)

Une porte de sortie multi-fournisseur pratique

Si vous intégrez cela en production, ne codez pas en dur des hypothèses sur le fournisseur partout dans votre codebase. Gardez base_url, api_key et model dans la configuration. Cela rend Groq facile à tester et rend également le routage entre fournisseurs banal.

Pour les équipes qui veulent un endpoint unique compatible OpenAI pour Claude, GPT et Gemini, onehop est la voie simple : changez l’URL de base pour https://api.onehop.ai/v1. Il est compatible OpenAI/Anthropic, moins cher que les fournisseurs directs, et les nouveaux comptes obtiennent 10 $ gratuits sans carte bancaire.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["ONEHOP_API_KEY"],
    base_url="https://api.onehop.ai/v1",
)

response = client.chat.completions.create(
    model=os.environ["ONEHOP_MODEL"],
    messages=[
        {"role": "user", "content": "Compare this API design against common REST mistakes."}
    ],
)

print(response.choices[0].message.content)

Utilisez Groq lorsque vous voulez spécifiquement une inférence GPT-OSS rapide et la pile d’outils/cache de Groq. Utilisez onehop lorsque vous voulez une surface d’intégration unique pour Claude, GPT, Gemini et d’autres modèles hébergés sans réécrire le code client. Vous pouvez appeler Claude et d’autres modèles sur onehop ou vous inscrire pour obtenir 10 $ de crédit gratuit.

Checklist de production

Avant de déployer, passez cette checklist en revue :

• Épinglez l’ID du modèle : openai/gpt-oss-120b pour la qualité, openai/gpt-oss-20b pour un coût plus faible.
• Gardez les sections de prompt stables en premier afin que Groq puisse réutiliser les préfixes mis en cache.
• Journalisez prompt_tokens, cached_tokens et completion_tokens pour chaque requête.
• Ajoutez une comptabilité séparée pour Browser Search, Visit Website et Code Execution.
• Supprimez les paramètres OpenAI non pris en charge avant de router le trafic vers Groq.
• Gardez base_url configurable afin de pouvoir tester Groq, les API propriétaires ou onehop sans toucher à la logique métier.

Toute la migration peut tenir en une ligne. La migration fiable, ce sont trois lignes plus la comptabilité : URL de base, ID de modèle et télémétrie des coûts. Commencez par là, puis décidez si la qualité de 120B justifie la dépense en tokens de sortie pour chaque chemin de votre application. Si vous voulez le même modèle d’URL de base pour accéder à davantage de modèles, appelez Claude et d’autres modèles sur onehop et inscrivez-vous pour obtenir 10 $ de crédit gratuit.