Coûts, facturation et exploitation22 septembre 2026Flatkey Team

Mise en cache des prompts OpenAI (octobre 2026) : fonctionnement, tarifs et ROI

La mise en cache des prompts OpenAI est automatique et facture l'entrée en cache à environ 0,1 fois le tarif normal. Découvrez les tarifs d'écriture et de lecture d'octobre 2026, les TTL de 30 minutes et 12 heures, les breakpoints explicites, un exemple de ROI chiffré et la comparaison avec Claude et Gemini.

Mise en cache des prompts OpenAI (octobre 2026) : fonctionnement, tarifs et ROI

La mise en cache des prompts OpenAI est activée par défaut : lorsqu'une requête commence par le même préfixe (au moins 1 024 tokens sur GPT-5.6 et versions ultérieures) qu'une requête récente, OpenAI réutilise le calcul enregistré et facture ces tokens au tarif d'entrée en cache, environ 90 à 95 % moins cher que l'entrée normale. Sur GPT-5.6 et versions ultérieures, vous payez aussi une écriture en cache unique : 1,25 fois le tarif d'entrée pour la durée par défaut de 30 minutes, ou 2,5 fois pour 12 heures, au 25 octobre 2026. Si un préfixe est réutilisé ne serait-ce qu'une fois pendant sa durée de vie, le cache coûte déjà moins cher que de l'envoyer deux fois.

Ce guide explique le fonctionnement du cache d'OpenAI, son coût sur les modèles actuels, comment le contrôler avec des breakpoints et des TTL, comment mesurer les économies et comment il se compare aux caches d'Anthropic et de Gemini. Tous les tarifs proviennent du guide de mise en cache des prompts d'OpenAI et de la page de tarifs de l'API OpenAI, vérifiés le 25 octobre 2026.

Tarifs de la mise en cache des prompts OpenAI

Tarifs du niveau standard pour 1 M de tokens :

Modèle	Entrée	Entrée en cache (lecture)	Écriture 30 min	Écriture 12 h	Sortie
gpt-6-astra	10,00 $	1,00 $	12,50 $	25,00 $	50,00 $
gpt-6.1-sol	2,00 $	0,10 $	2,50 $	5,00 $	10,00 $
gpt-6-luna	0,10 $	0,01 $	0,125 $	0,25 $	0,50 $
gpt-5.6-sol	4,00 $	0,40 $	5,00 $	10,00 $	20,00 $

Une lecture en cache coûte 0,1 fois le tarif d'entrée hors cache sur la plupart des modèles et 0,05 fois sur GPT-6.1 Sol. Le niveau Batch divise par deux tous les montants de ce tableau, et le mode Fast les double. Les endpoints régionaux de résidence des données appliquent une majoration de 10 % aux modèles publiés à partir du 5 mars 2026.

Un point souvent mal compris : le tarif d'écriture en cache ne s'ajoute pas au tarif d'entrée. Chaque token d'entrée n'est facturé qu'une fois, au tarif hors cache, de lecture en cache ou d'écriture en cache. Une écriture de 30 minutes coûte 25 % de plus que l'entrée ordinaire pour ces tokens, et chaque accès ultérieur en coûte 10 % (ou 5 %).

Comment fonctionne la mise en cache des prompts OpenAI

Lorsqu'un modèle lit votre prompt, il calcule des états clé-valeur (KV) pour chaque token. La mise en cache conserve ces états pour un préfixe réutilisable, c'est-à-dire le début inchangé du prompt. Si une requête ultérieure commence exactement par le même préfixe et trouve une entrée de cache correspondante, le modèle évite de le recalculer, ce qui réduit à la fois le coût et le délai avant le premier token.

Le préfixe mis en cache couvre tout ce qu'OpenAI génère avant que votre contenu ne change : le contenu système masqué, les messages developer, les définitions d'outils et l'historique de conversation, y compris le texte, les images, les documents et l'audio pris en charge. La correspondance doit être exacte. Si quoi que ce soit change avant un breakpoint, comme un horodatage dans le prompt système, une liste d'outils réordonnée ou une image différente, tout ce qui suit ce changement est un échec de cache.

Règles clés sur GPT-5.6 et versions ultérieures :

Longueur minimale : un préfixe doit compter au moins 1 024 tokens pour être mis en cache. Les tokens système masqués d'OpenAI ne sont pas comptés.
Breakpoints : un breakpoint marque la fin d'un préfixe pouvant être écrit dans le cache. En mode implicite (par défaut), OpenAI en place un à la fin du dernier message éligible. En mode explicite, vous choisissez leur emplacement avec prompt_cache_breakpoint.
Jusqu'à quatre écritures par requête : chaque requête peut créer jusqu'à quatre écritures en cache, ce qui permet de mettre en cache des couches qui évoluent à des rythmes différents.
Durées de vie : définissez prompt_cache_options.ttl sur "30m" (par défaut) ou "12h" dans la Responses API. Les lectures coûtent le même prix dans les deux cas.

Sur les modèles antérieurs à GPT-5.6, seul le cache implicite est disponible. La rétention se règle avec prompt_cache_retention : in_memory conserve les entrées pendant environ 5 à 10 minutes d'inactivité (jusqu'à une heure), et 24h porte cette durée jusqu'à 24 heures. Les organisations sans Zero Data Retention utilisent 24h par défaut ; les organisations ZDR, in_memory. Sur ces anciens modèles, un prompt_cache_key stable aide à diriger les requêtes liées vers le même cache. OpenAI conseille de limiter chaque clé à environ 15 requêtes par minute et de répartir un trafic plus important sur plusieurs clés.

Quand le cache devient rentable

Le guide d'OpenAI donne le calcul de base. Avec une lecture à 0,1x et une écriture à 1,25x, écrire un préfixe une fois puis le réutiliser une fois coûte 1,35 fois son prix d'entrée normal, contre 2 fois pour l'envoyer deux fois. Dix requêtes avec une écriture et neuf lectures coûtent 2,15x, contre 10x sans cache.

Requêtes partageant le préfixe	Sans cache	Cache 30 minutes	Cache 12 heures	Économie avec le cache 30 minutes
1	1,00×	1,25×	2,50×	−25 %
2	2,00×	1,35×	2,60×	33 %
10	10,00×	2,15×	3,40×	79 %
100	100,00×	11,15×	12,40×	89 %

La durée de 12 heures n'a d'intérêt que si l'intervalle entre les requêtes dépasse 30 minutes tout en gardant plusieurs réutilisations du préfixe, par exemple un long manuel produit interrogé tout au long de la journée par un outil interne peu sollicité.

OpenAI explique aussi quand compléter un préfixe court jusqu'au minimum. Avec un minimum de 1 024 tokens, une lecture à 0,1x et une écriture à 1,25x, le remplissage est moins coûteux lorsque votre préfixe d'origine dépasse 102,4 + 1 177,6 / N tokens, N étant le nombre de requêtes. Sur 10 requêtes, étendre à 1 024 tokens un préfixe de 221 tokens ou plus est rentable.

Exemple chiffré

Prenons un assistant de support sous gpt-6.1-sol qui traite 50 000 requêtes par jour. Chaque requête envoie un préfixe stable de 8 000 tokens (instructions, définitions d'outils et documents de politique) et un message utilisateur de 500 tokens, et reçoit une réponse de 400 tokens. Le trafic est régulier, donc le cache de 30 minutes est réécrit environ 48 fois par jour.

Poste de coût quotidien	Sans cache	Avec cache explicite
Préfixe stable	400 M × 2,00 $ = 800,00 $	écritures : 0,38 M × 2,50 $ = 0,96 $ ; lectures : 399,6 M × 0,10 $ = 39,96 $
Message utilisateur	25 M × 2,00 $ = 50,00 $	25 M × 2,00 $ = 50,00 $
Sortie	20 M × 10,00 $ = 200,00 $	20 M × 10,00 $ = 200,00 $
Total	1 050,00 $	≈ 290,92 $

Cela représente une baisse d'environ 72 % de la facture quotidienne. Le poste de sortie est identique dans les deux colonnes : une fois le cache en place, raccourcir les réponses est le levier suivant.

Pourquoi le mode explicite ici ? En mode implicite, le breakpoint se trouve à la fin du dernier message, donc les 500 tokens variables de l'utilisateur seraient eux aussi écrits dans le cache à 1,25x à chaque fois. Dans cet exemple, cela ajoute environ 12,50 $ par jour. Le mode explicite permet d'arrêter l'écriture juste après le préfixe stable, et le message utilisateur est facturé au tarif d'entrée normal.

Comment le configurer

Aucun code n'est nécessaire pour profiter du cache implicite. Pour le contrôler, utilisez la Responses API. Cette requête met en cache les instructions partagées pendant 12 heures et le contexte de session pendant 30 minutes, sans mettre en cache la question en cours :

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.1-sol",
    "prompt_cache_options": { "mode": "explicit", "ttl": "30m" },
    "input": [
      { "role": "developer", "content": [
        { "type": "input_text", "text": "<shared instructions and policy docs>",
          "prompt_cache_breakpoint": { "mode": "explicit", "ttl": "12h" } } ] },
      { "role": "user", "content": [
        { "type": "input_text", "text": "<session context>",
          "prompt_cache_breakpoint": { "mode": "explicit" } },
        { "type": "input_text", "text": "What is the refund window for annual plans?" } ] }
    ]
  }'

Lisez les champs de cache de chaque réponse et journalisez-les :

from openai import OpenAI

client = OpenAI()
resp = client.responses.create(model="gpt-6.1-sol", input=[...])  # same input as above

d = resp.usage.input_tokens_details
print("input:", resp.usage.input_tokens)
print("cache reads:", d.cached_tokens)
print("cache writes:", d.cache_write_tokens)
hit_rate = d.cached_tokens / max(resp.usage.input_tokens, 1)
print(f"token cache-hit rate: {hit_rate:.0%}")

Pour les modèles qui prennent en charge prompt_cache_options, cache_write_tokens_details répartit les écritures entre ttl_30m_tokens et ttl_12h_tokens. La valeur cached_tokens est arrondie à l'inférieur au multiple de 128. OpenAI propose aussi un Prompt Caching Dashboard pour suivre les taux de succès et un outil Prompt Cache Diagnostics qui explique les échecs.

Règles de conception des prompts pour augmenter les succès

Le statique d'abord, le dynamique à la fin. Placez en tête les instructions, les schémas d'outils, les exemples few-shot et les documents de référence. Placez à la fin le message de l'utilisateur, les extraits récupérés et tout ce qui contient une date ou un identifiant.
Figez la liste d'outils. Modifier les définitions d'outils casse le préfixe. Si différentes requêtes ont besoin d'outils différents, gardez les définitions stables et changez seulement ceux qui sont appelables.
Ajoutez, ne réécrivez pas. Dans les conversations multi-tours, ajoutez les nouveaux tours à la fin. Résumer ou modifier les tours précédents invalide le cache.
Gardez des paramètres stables. Le modèle, les réglages de raisonnement et d'autres options de requête peuvent modifier le préfixe généré. Fixez-les pour le trafic mis en cache.
Surveillez les bascules. Si vous basculez vers un autre modèle ou fournisseur, vous repartez d'un cache vide. Notre guide des stratégies de fallback de modèles explique comment basculer sans perdre toute la localité du cache.

Cache de prompts : OpenAI vs Anthropic vs Gemini

Le cache n'est pas transférable d'un fournisseur à l'autre. Les mécanismes et les prix diffèrent :

	OpenAI (GPT-5.6+)	Anthropic Claude	Google Gemini
Par défaut	Automatique	Sur activation avec `cache_control` (automatique ou par bloc)	Cache implicite automatique sur Gemini 2.5 et versions ultérieures
Préfixe minimal	1 024 tokens	512 tokens sur les modèles actuels	4 096 tokens sur Gemini 4 Argon et 3.8 Flash
Coût d'écriture	1,25× (30 min) ou 2,5× (12 h)	1,25× (5 min) ou 2× (1 h)	Pas de frais d'écriture en implicite ; l'explicite ajoute un stockage horaire
Coût de lecture	0,1× (0,05× sur GPT-6.1 Sol)	0,1× (0,05× sur Opus 5.5 et Sonnet 5.5)	ex. 0,10 $ contre 2,00 $ en entrée sur Gemini 4 Argon
Champ d'usage	`cached_tokens`, `cache_write_tokens`	`cache_read_input_tokens`, `cache_creation_input_tokens`	`total_cached_tokens`

Sources : la documentation de mise en cache des prompts d'Anthropic, les tarifs de l'API Claude, la mise en cache du contexte Gemini et les tarifs de l'API Gemini, toutes vérifiées le 25 octobre 2026. Gemini 4 Argon ne prend en charge que le cache implicite. Les objets de cache explicite fonctionnent sur les modèles Gemini 3 et 2.5 compatibles via generateContent, avec un stockage facturé par million de tokens et par heure (par exemple 0,50 $ sur Gemini 3.8 Flash jusqu'au 31 décembre 2026). DeepSeek met aussi en cache automatiquement ; consultez le guide de mise en cache de DeepSeek.

Vérification du ROI du cache en sept jours

Avant de considérer le cache comme un succès, mesurez-le sur du trafic réel :

Jour 1 : choisissez un workflow à fort volume avec un long préfixe partagé. Journalisez par requête les tokens d'entrée, cached_tokens, cache_write_tokens, les tokens de sortie et la latence.
Jours 2–3 : placez tout le contenu statique en tête et retirez-en les valeurs dynamiques. Comparez le taux de succès par token (tokens en cache ÷ tokens d'entrée) avant et après.
Jours 4–5 : si les écritures sont nombreuses et les lectures rares, votre trafic est trop clairsemé pour des entrées de 30 minutes. Essayez "12h" sur la couche stable, ou regroupez le préfixe pour que davantage de requêtes le partagent.
Jours 6–7 : calculez le coût réel par réponse acceptée, pas seulement par token. Une requête moins chère que les utilisateurs rejettent n'est pas une économie.

Pour une charge stable de chat ou d'agents, de bons objectifs sont un taux de succès par token supérieur à 60 % et au moins 10 lectures pour une écriture. Notre guide d'observabilité des API LLM et notre guide des tableaux de bord d'usage des tokens montrent comment construire ces vues.

La place de Flatkey

Flatkey est un routeur compatible OpenAI avec une seule clé et un seul solde pour OpenAI, Claude, Gemini, DeepSeek, Qwen et d'autres modèles. Le cache de chaque fournisseur suit toujours ses propres règles : gardez des prompts stables par modèle et évitez de changer de modèle à chaque requête si vous voulez des succès de cache. Commencez par le guide de démarrage rapide du routeur, consultez les tarifs en vigueur sur la page de tarifs Flatkey et lisez notre guide d'optimisation des coûts des API d'IA pour d'autres moyens de réduire vos dépenses.

FAQ

La mise en cache des prompts OpenAI est-elle automatique ?

Oui. La mise en cache des prompts est activée par défaut sur les modèles OpenAI compatibles, sans modification de code pour obtenir des succès de cache. Sur GPT-5.6 et versions ultérieures, vous pouvez passer en mode explicite et choisir les breakpoints avec prompt_cache_breakpoint.

Combien fait économiser la mise en cache des prompts OpenAI ?

L'entrée en cache coûte 0,1 fois le tarif d'entrée normal sur la plupart des modèles actuels et 0,05 fois sur GPT-6.1 Sol, soit une remise de 90 à 95 % sur la partie en cache. L'économie totale dépend de la part de chaque prompt qui constitue un préfixe partagé et de la fréquence de réutilisation.

Quelle est la longueur minimale d'un prompt pour le cache ?

1 024 tokens pour GPT-5.6 et versions ultérieures. Pour les modèles antérieurs, elle varie selon les paramètres de la requête. Les préfixes plus courts sont traités normalement, sans erreur.

Combien de temps dure le cache de prompts OpenAI ?

Sur GPT-5.6 et versions ultérieures, les entrées durent au moins 30 minutes par défaut, ou au moins 12 heures si vous définissez ttl sur "12h". Sur les modèles antérieurs, in_memory les conserve environ 5 à 10 minutes d'inactivité, jusqu'à une heure, et 24h peut les garder jusqu'à 24 heures.

La mise en cache des prompts réduit-elle la latence ?

Oui. Réutiliser un préfixe en cache évite de le recalculer, ce qui réduit le délai avant le premier token, surtout pour les longs prompts.

Dois-je payer pour écrire dans le cache ?

Sur GPT-5.6 et versions ultérieures, oui : 1,25 fois le tarif d'entrée pour une écriture de 30 minutes, ou 2,5 fois pour 12 heures. Ce montant remplace le tarif d'entrée normal de ces tokens ; il ne s'y ajoute pas.

Qu'est-ce que prompt_cache_key ?

Un paramètre facultatif qui regroupe les requêtes liées afin qu'elles soient dirigées vers le même cache. Sur les modèles antérieurs à GPT-5.6, il améliore le taux de succès ; OpenAI recommande environ 15 requêtes par minute et par clé.