La mémoire de Claude coûte-t-elle plus cher ?

Les fonctionnalités de mémoire de Claude entraînent-elles des frais supplémentaires ?

Les fonctionnalités de mémoire de Claude n’ont pas de coût propre. Les tarifs publiés par Anthropic sont calculés par million de tokens d’entrée et par million de tokens de sortie, avec des tarifs supplémentaires pour le prompt caching. Aucun de ces tarifs ne correspond à des memory tokens. Le stockage de la mémoire elle-même est gratuit sur l’API Claude (application programming interface), car le memory tool s’exécute côté client et le fichier est stocké sur un espace dont vous êtes propriétaire.

La mémoire peut tout de même augmenter votre facture, car un fait mémorisé ne modifie une réponse que s’il figure dans la requête que Claude lit. Mémoriser signifie renvoyer le contenu. Ce texte arrive sous forme de tokens d’entrée et est facturé au tarif normal des tokens d’entrée du modèle. Deux éléments déterminent le coût : le nombre de tokens du texte mémorisé que vous renvoyez à chaque tour, et la possibilité de servir ce texte depuis le prompt cache.

Avec un abonnement Pro ou Max, vous ne payez pas du tout par token. La mémoire consomme donc votre quota d’utilisation, pas votre argent. Le mécanisme reste identique. Seule l’unité change. Ce quota est limité. Il est donc utile de savoir combien coûte Claude Pro et à partir de quand ses limites vous bloquent avant de décider quelle quantité de mémoire chaque tour doit transporter. Claude Enterprise fonctionne encore différemment : chaque token y est facturé aux tarifs de l’API en plus du prix des sièges, de sorte qu’un bloc de mémoire trop volumineux redevient une dépense plutôt qu’une consommation de quota. Si l’élagage de la mémoire ramène confortablement votre utilisation sous le plafond d’un forfait moins cher, passer de Max à Pro est l’étape suivante à envisager. Le changement prend effet à la fin de la période déjà payée. Si la comparaison que vous envisagez porte réellement sur plusieurs fournisseurs plutôt que sur les forfaits d’Anthropic, comparer les forfaits de Claude et de ChatGPT aux tarifs actuels est le bon point de départ.

Ce que signifie « mémoire » sur chaque interface Claude

Trois produits distincts utilisent ce terme. Leur confusion explique en grande partie pourquoi cette question paraît difficile.

L’outil de mémoire de l’API Claude. Vous ajoutez une entrée au tableau tools et vous implémentez les opérations sur les fichiers dans votre propre code.

{"type": "memory_20250818", "name": "memory"}

En août 2026, cet outil est généralement disponible dans la Messages API, sans en-tête beta, avec les modèles Claude 4 et versions ultérieures. Il s’exécute côté client : Claude demande une opération telle que view /memories, votre handler l’exécute sur le stockage que vous contrôlez, puis vous renvoyez le résultat dans un bloc tool_result. Anthropic ne conserve jamais le fichier. Il n’y a donc pas de frais de stockage à vous refacturer. Vous payez en revanche l’aller-retour. La définition de l’outil est envoyée dans chaque requête, et le contenu du fichier renvoyé reste dans la conversation à partir de ce moment.

Anthropic publie la partie fixe de cette surcharge. Avec Claude Opus 5 et un choix d’outil défini sur auto, le prompt système d’utilisation des outils contient 286 tokens, selon la documentation d’août 2026. Ce coût s’applique une fois par requête dès qu’un outil est présent, qu’il s’agisse de la mémoire ou d’un autre outil.

Claude Code. Deux mécanismes sont chargés au début de chaque session. Les fichiers CLAUDE.md contiennent les instructions que vous rédigez. L’auto-mémoire contient les notes que Claude rédige pour lui-même, sous ~/.claude/projects/<project>/memory/. Seules les 200 premières lignes ou les 25KB premiers octets de MEMORY.md sont chargés, selon la première limite atteinte. Les fichiers thématiques situés à côté sont lus à la demande, et non au démarrage. Tout ce qui est chargé au démarrage fait partie du préfixe transmis dans chaque requête ultérieure de la session. Comment Claude Code récupère la mémoire entre les sessions détaille l’ordre de chargement, fichier par fichier.

Claude sur le web. Sur claude.ai, la mémoire est un ensemble d’entrées que Claude rédige et met à jour pendant vos échanges, avec un espace mémoire distinct pour chaque projet. Settings > Memory répertorie les éléments stockés. Le bouton d’activation situé à cet endroit propose les options Pause memory et Reset memory. Cette interface est facturée par abonnement. La mémoire y consomme donc les limites d’utilisation.

Pourquoi le texte mémorisé est facturé comme des tokens d’entrée

L’API Messages est sans état. Elle ne conserve rien entre les appels. Votre client envoie donc toute la conversation à chaque tour, et le modèle la relit entièrement. La mémoire ne fait pas exception à cette règle. Elle constitue un bloc de texte supplémentaire dans la même requête.

La répartition est visible dans l’objet usage de chaque réponse.

"usage": {
  "input_tokens": 412,
  "cache_creation_input_tokens": 0,
  "cache_read_input_tokens": 18240,
  "output_tokens": 236
}

input_tokens compte uniquement les tokens qui n’ont été ni lus depuis le cache ni utilisés pour le créer. En pratique, il s’agit des tokens situés après le dernier point de cache. Le nombre total de tokens d’entrée de la requête correspond à cache_read_input_tokens plus cache_creation_input_tokens plus input_tokens. Un fichier mémoire ouvert par Claude trois tours plus tôt est inclus dans ce total à chaque tour suivant. Il est comptabilisé dans cache_read_input_tokens tant que le préfixe est mis en cache, puis dans input_tokens lorsque ce n’est plus le cas. Le texte est identique, mais le prix peut être très différent. Les tokens d’entrée et de sortie ont des prix différents, et la mémoire est toujours comptabilisée du côté des tokens d’entrée.

Où voir ces chiffres dans votre propre utilisation

Ne prenez pas un chiffre dans un article de blog, y compris celui-ci. Mesurez votre propre bloc de mémoire. Le comptage des tokens est gratuit et dispose de sa propre limite de débit. La mesure ne vous coûte donc rien.

curl https://api.anthropic.com/v1/messages/count_tokens \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "content-type: application/json" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-opus-5",
    "system": "You are a scientist",
    "messages": [{"role": "user", "content": "Hello, Claude"}]
  }'

La réponse est un seul nombre, par exemple { "input_tokens": 14 }. Exécutez-la une fois en collant votre texte de mémoire dans le champ system, puis une fois sans ce texte. La différence correspond au coût de cette mémoire à chaque tour. Deux précisions s’imposent. Le comptage est une estimation, et les tokens supplémentaires qu’Anthropic ajoute pour ses propres optimisations système ne vous sont pas facturés. Effectuez aussi le comptage avec le modèle que vous utiliserez réellement, car Claude 4.7 et les versions ultérieures utilisent un tokenizer plus récent qui produit environ 30 pour cent de tokens supplémentaires pour un même texte.

Dans Claude Code, vous pouvez obtenir la même information sans utiliser curl.

• /context affiche ce qui est chargé actuellement, y compris les fichiers de mémoire. Vous voyez ainsi leur part de la fenêtre avant toute saisie.
• /memory répertorie vos fichiers CLAUDE.md et ouvre le dossier de mémoire automatique.
• /usage affiche notamment les totaux de la session, les lectures du cache et les écritures dans le cache.
• La ligne d’état peut afficher en continu l’utilisation de la fenêtre de contexte. Vous voyez ainsi sa progression en temps réel.

Le bloc de session /usage se présente comme suit :

Total cost:            $0.55
Total duration (API):  6m 20s
Total duration (wall): 6h 33m 10s
Total code changes:    0 lines added, 0 lines removed
Usage by model:
   claude-sonnet-4-6:  1.2k input, 5.3k output, 940.0k cache read, 50.0k cache write ($0.55)

Lisez attentivement la dernière ligne. La valeur de 940.0k pour les lectures du cache correspond à la conversation complète, mémoire comprise, renvoyée à chaque tour au tarif du cache. La valeur de 1.2k pour les entrées correspond uniquement à la partie nouvelle. Claude Code calcule localement ce montant en dollars à partir des tarifs catalogue. Il ne tient donc pas compte des remises dont vous bénéficiez et le montant peut différer de celui de votre facture. La page Usage de la Claude Console fait foi.

Effectuez ensuite la comparaison directement. Posez la même question d’ouverture dans deux nouvelles sessions, l’une normalement et l’autre avec la mémoire automatique désactivée.

CLAUDE_CODE_DISABLE_AUTO_MEMORY=1 claude

Exécutez /context dans chacune des sessions et comparez l’entrée relative aux fichiers de mémoire. L’écart correspond au coût de votre mémoire accumulée au début de chaque session, avant toute opération. Une analyse complète de l’utilisation des tokens de Claude Code mérite d’être consultée à côté de ces deux chiffres.

Quel est le coût de la relecture de la mémoire par million de tokens ?

Le prompt caching explique pourquoi le même bloc de mémoire peut coûter dix fois plus cher lors d’un tour que lors d’un autre. Anthropic publie les tarifs du cache comme des multiples du prix d’entrée de base de chaque modèle. La relation reste donc valable même lorsque les prix en dollars évoluent.

[
  {
    "label": "Base input",
    "price_multiple": 1
  },
  {
    "label": "5 minute cache write",
    "price_multiple": 1.25
  },
  {
    "label": "1 hour cache write",
    "price_multiple": 2
  },
  {
    "label": "Cache read",
    "price_multiple": 0.1
  }
]

La lecture du cache coûte 0.1 fois le prix d’entrée de base. L’écriture d’une entrée avec une durée de vie de 5 minutes coûte 1.25 fois le tarif de base. Avec une durée de vie de 1 heure, elle coûte 2 fois ce tarif. Anthropic indique clairement le seuil de rentabilité : le caching devient rentable après une lecture du cache avec une durée de 5 minutes, ou après deux lectures du cache avec une durée de 1 heure. Le seuil de rentabilité du prompt caching correspond au calcul à effectuer avant de décider où placer la mémoire.

Ces multiples permettent de convertir le nombre de relectures en calcul. Le bloc suivant applique les multiples publiés ci-dessus. Il ne mesure pas une charge de travail réelle. Il évalue le coût d’un bloc de mémoire de trois façons sur une session de 100 tours, sous la forme d’un nombre équivalent de tokens facturés au tarif d’entrée de base.

[
  {
    "label": "4,000 tokens, never cached",
    "base_rate_equivalent_tokens": "400,000"
  },
  {
    "label": "4,000 tokens, 1 write and 99 reads",
    "base_rate_equivalent_tokens": "44,600"
  },
  {
    "label": "1,000 tokens, 1 write and 99 reads",
    "base_rate_equivalent_tokens": "11,150"
  }
]

Un bloc de mémoire de 4,000 tokens qui ignore le cache lors des 100 tours est facturé comme 400,000 tokens au tarif de base. Le même bloc, après une écriture dans le cache de 5 minutes et 99 lectures du cache, est facturé comme 44,600. Si vous le réduisez au quart de sa taille tout en conservant le caching, il est facturé comme 11,150. La fonctionnalité n’a pas changé entre ces 3 lignes. Seul le comportement de relecture a changé. Il s’agit toujours de nombres de tokens, pas de montants. Convertir un nombre de tokens en montant sur votre facture mensuelle revient à le multiplier par le tarif par million de tokens de votre modèle. Ce tarif dépend du modèle utilisé. Si l’agent doit fonctionner avec Claude Fable 5, commencez par ses tarifs publiés par million de tokens et les tâches auxquelles il convient. Si le fournisseur reste à choisir, indépendamment du modèle, le coût des mêmes tâches avec l’API de Claude et avec ChatGPT montre où cette multiplication produit un résultat différent. Un agent qui utilise beaucoup de mémoire dépend fortement de cette composante d’entrée.

La deuxième ligne suppose que chacune des 99 requêtes suivantes arrive alors qu’une entrée du cache est encore valide. C’est cette hypothèse qui explique la plupart des écarts entre les factures réelles et les estimations.

Pourquoi la même question coûte-t-elle plus cher après une pause ?

Une entrée de cache a une durée de vie. Le compteur démarre à la requête qui l’écrit ou la lit. La valeur par défaut est de 5 minutes. L’option de 1 heure coûte le double de l’écriture indiquée plus haut. Dans Claude Code, la durée de vie est d’une heure avec un abonnement. Elle repasse à 5 minutes lorsque vous utilisez des crédits de consommation. Avec une clé API ou un cloud provider, elle est de 5 minutes par défaut. Le paramètre ENABLE_PROMPT_CACHING_1H=1 conserve la durée de vie d’une heure lorsque vous utilisez des crédits de consommation.

Ainsi, une question d’une seule ligne saisie dans une session laissée ouverte pendant votre pause déjeuner peut coûter cher, car l’entrée de cache a expiré pendant votre absence. Tout le préfixe, mémoire comprise, est de nouveau traité au tarif d’entrée de base, puis réécrit dans le cache. C’est la durée de la pause qui a déterminé ce prix.

Vous pouvez le vérifier au lieu de vous contenter de nous croire. Avec un forfait Pro, Max, Team ou Enterprise, le détail /usage signale tout comportement responsable d’au moins 10 pour cent de la consommation récente. Le contexte long et les cache misses y apparaissent tous deux sous leur nom. Avec l’API, surveillez cache_creation_input_tokens : après une période d’inactivité, il remonte à la taille complète de votre préfixe dès la première requête.

Ce qui invalide discrètement le cache

Le préfixe mis en cache est ordonné : outils, puis système, puis messages. Une modification à un niveau invalide ce niveau et tous les niveaux suivants. Modifier une définition d’outil supprime l’intégralité du cache. Modifier le prompt système supprime le cache du système et des messages.

C’est le piège pour quiconque conserve la mémoire dans le prompt système et le réécrit à mesure que l’agent apprend. Chaque réécriture supprime la copie en cache de tout ce qui se trouve après ce niveau. La requête suivante doit donc réécrire l’ensemble du contenu. Placez le contenu stable au début et ne le modifiez pas. Placez le contenu volatile à la fin de la liste des messages, où son invalidation coûte moins cher.

Il existe un second problème, plus discret. Chaque modèle possède un préfixe minimal pouvant être mis en cache : 512 tokens sur Claude Opus 5, 1,024 sur Claude Sonnet 5 et 4,096 sur Claude Haiku 4.5, selon les informations publiées en août 2026. La documentation d’Anthropic précise ce qui se passe en dessous de ce seuil : « Toute requête visant à mettre en cache moins de tokens que ce nombre est traitée sans mise en cache, et aucune erreur n’est renvoyée. » Un petit fichier de mémoire marqué avec cache_control ne produit donc absolument aucun effet, sans aucun message. Le symptôme observable est que cache_creation_input_tokens reste à 0 alors que votre prompt contient clairement un breakpoint.

Élaguez la mémoire qui n’est plus utile

Chaque ligne de mémoire consomme des tokens à chaque tour où elle est chargée. Pour chaque ligne, demandez-vous donc si elle a récemment modifié une réponse. Claude Code rend ces limites concrètes. Essayez de conserver un fichier CLAUDE.md de moins de 200 lignes, car les fichiers plus longs consomment davantage de contexte et sont moins bien suivis par Claude. MEMORY.md est limité aux 200 premières lignes ou à 25KB lors du chargement. Tout ce qui dépasse cette limite est supprimé au démarrage de la session suivante. Un index trop volumineux consomme donc des tokens sans rien apporter.

Deux habitudes permettent de conserver un fichier court. Déplacez les détails de l’index vers des fichiers thématiques, que Claude lit à la demande plutôt qu’au démarrage. Déplacez les instructions de workflow de CLAUDE.md vers des skills, qui ne sont chargés que lorsqu’ils sont invoqués. Pour les fichiers de mémoire qui commencent déjà par un frontmatter, Claude Code enregistre l’heure d’écriture dans un champ modified sous la forme d’un timestamp ISO 8601, à partir de la version 2.1.214. Ce timestamp permet d’identifier rapidement un fait devenu obsolète. Élaguer la mémoire obsolète décrit plus en détail le processus de révision.

Quand la récupération est préférable au chargement de tout le contenu dans le contexte

L’outil de mémoire sert à récupérer les informations au moment opportun. Au lieu de tout charger au départ, l’agent enregistre ce qu’il apprend et ne relit un fichier que lorsqu’une tâche en a besoin. Cela modifie le calcul : la lecture d’un fichier coûte ses tokens une seule fois, puis le fichier reste dans le préfixe mis en cache, tandis qu’un bloc chargé en permanence coûte des tokens à chaque tour.

Une règle simple découle des deux graphiques ci-dessus. Le texte utilisé presque à chaque tour doit rester dans le préfixe stable mis en cache. Le texte utilisé un tour sur vingt doit être placé derrière un appel view. Le seuil de rentabilité dépend du nombre de relectures, et non de ce qu’Anthropic facture.

Avec l’API, vous pouvez également laisser la plateforme réduire la conversation. L’édition du contexte supprime les anciens résultats d’outils lorsque la conversation dépasse un seuil que vous avez défini.

{
  "edits": [
    {
      "type": "clear_tool_uses_20250919",
      "trigger": {"type": "input_tokens", "value": 30000},
      "keep": {"type": "tool_uses", "value": 3},
      "clear_at_least": {"type": "input_tokens", "value": 5000}
    }
  ]
}

Les valeurs par défaut sont un seuil de 100,000 tokens d’entrée et 3 utilisations d’outils conservées. Consultez l’interaction avec la mise en cache avant de l’activer : la suppression du contenu invalide le préfixe mis en cache à l’endroit de la suppression, ce qui entraîne un coût d’écriture du cache lors de la requête suivante. C’est le rôle de clear_at_least. Il retarde la suppression jusqu’à ce que l’économie soit suffisante pour justifier cette écriture. La réponse indique exactement ce qui s’est produit avec context_management, ainsi qu’avec cleared_tool_uses et cleared_input_tokens. Le compromis devient ainsi mesurable, et non théorique. Gestion de la fenêtre de contexte dans Claude Code applique le même principe à une session de développement.

Ce qui fait l’objet d’une ligne tarifaire distincte

La mémoire n’a pas de coût propre, mais certaines fonctionnalités en ont réellement un. Il est donc utile de savoir lesquelles. Voici les tarifs publiés de l’API Claude en août 2026. Certaines opérations sont entièrement gratuites, mais l’API Claude ne propose pas de niveau gratuit, seulement un petit crédit à l’inscription. Tout ce qui suit correspond donc à des dépenses réelles dès votre première requête.

• Recherche Web : 10 $ pour 1 000 recherches, auxquels s’ajoute le coût habituel des tokens ajoutés au contexte par la recherche.
• Exécution de code : 1 550 heures gratuites par organisation et par mois, puis 0,05 $ par heure et par conteneur. Elle est gratuite lorsqu’elle est utilisée avec la recherche Web ou la récupération de contenu Web.
• Claude Managed Agents : exécution de la session à 0,08 $ par heure de session, en plus des frais habituels liés aux tokens.
• Récupération de contenu Web : aucun coût supplémentaire, uniquement le coût en tokens du contenu récupéré.

La mémoire n’apparaît sur aucune de ces lignes. Elle est incluse dans le décompte des tokens d’entrée. C’est précisément à cet endroit que vous pouvez la mesurer et que l’élagage et la mise en cache peuvent la réduire. Si vous prévoyez le budget d’un agent qui s’exécute sans surveillance sur un serveur privé virtuel (VPS), les contrôles de coûts d’un agent IA sur un VPS sont la prochaine mesure à mettre en place. Un agent dont le fichier de mémoire augmente sans élagage devient plus coûteux chaque semaine, sans qu’aucun indicateur ne vous en informe.

FAQ

Les fonctionnalités de mémoire de Claude entraînent-elles des frais supplémentaires ?

Non. La grille tarifaire d’Anthropic indique des tarifs par million de tokens d’entrée, par million de tokens de sortie et pour les multiples de prompt caching, sans ligne dédiée à la mémoire. Dans l’API Claude, l’outil de mémoire est côté client : les fichiers sont donc stockés sur une infrastructure que vous payez déjà. La mémoire ajoute des tokens d’entrée, facturés au tarif normal du modèle pour chaque tour qui les inclut.

Désactiver la mémoire rend-il Claude moins cher ?

Cela réduit le nombre de tokens de chaque requête, donc le coût de chaque requête. L’économie globale dépend de ce qui se passe ensuite. Si Claude doit relire trois fichiers et vous poser deux questions pour reconstituer les informations déjà présentes dans la mémoire, ces tokens coûtent plus cher que la mémoire elle-même. Mesurez la différence au lieu de l’estimer : exécutez /context dans une session où la mémoire automatique est activée, puis dans une session démarrée avec CLAUDE_CODE_DISABLE_AUTO_MEMORY=1, et comparez le nombre total de tokens utilisés pour la même tâche.

Pourquoi ma consommation a-t-elle augmenté alors que je n’ai rien modifié ?

La cause la plus fréquente est un cache miss après une pause. Les entrées du cache restent disponibles pendant 5 minutes par défaut, ou pendant une heure avec le paramètre étendu. La première requête après une interruption retraite donc tout votre préfixe au tarif de base des tokens d’entrée, puis l’écrit à nouveau. La deuxième cause la plus fréquente est une modification du préfixe : modifier une définition d’outil invalide tout le cache, tandis que modifier le system prompt invalide le cache du système et des messages. Dans un abonnement, la rubrique /usage indique ce comportement lorsqu’il représente au moins 10 pour cent de la consommation récente.

La mémoire doit-elle se trouver dans le system prompt ou derrière un appel d’outil ?

Placez-la dans le system prompt lorsqu’elle est utilisée à presque chaque tour. Elle reste alors dans le préfixe mis en cache et coûte le tarif de lecture du cache. Placez-la derrière un appel view lorsque seules certaines tâches en ont besoin. Un fichier lu une seule fois coûte alors ses tokens une seule fois, au lieu de les coûter à chaque tour. Le nombre déterminant est votre nombre de relectures, que l’objet usage fournit directement.

Les fonctionnalités de mémoire sont-elles décomptées des limites d’utilisation de l’abonnement ?

Oui, indirectement, car les limites d’un abonnement dépendent des tokens transportés par chaque requête. La documentation d’aide d’Anthropic indique que les conversations plus longues qui déclenchent la gestion automatique du contexte consomment davantage votre limite d’utilisation. La mémoire allonge légèrement chaque requête, et une session longue répète cette longueur à chaque tour. Comment fonctionnent réellement les limites d’utilisation de Claude explique ce qui est réinitialisé et à quel moment.