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

Les fonctionnalités de mémoire de Claude coûtent-elles plus cher ?

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 concerne 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 enregistré sur un espace de stockage que vous contrôlez.

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 paramètres 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 n’êtes pas facturé par token. La mémoire consomme donc votre quota d’utilisation, et non votre argent. Le mécanisme décrit ci-dessous 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 inclure. Claude Enterprise fonctionne encore différemment : chaque token y est facturé aux tarifs de l’API en plus du prix des licences, de sorte qu’un bloc de mémoire trop volumineux coûte de nouveau de l’argent au lieu de consommer un quota. Si la réduction de la mémoire ramène confortablement votre utilisation sous la limite 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 vous comparez en réalité plusieurs fournisseurs plutôt que les différents forfaits d’Anthropic, la comparaison des forfaits de Claude et de ChatGPT aux tarifs actuels est le meilleur point de départ.

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

Trois produits distincts utilisent ce terme. Les confondre explique en grande partie pourquoi cette question semble complexe.

L’outil de mémoire de l’API Claude. Vous ajoutez une entrée au tableau tools et 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 avec l’API Messages, sans en-tête beta, sur les modèles Claude 4 et ultérieurs. Il s’exécute côté client : Claude demande une opération telle que view /memories, votre gestionnaire l’exécute sur le stockage que vous contrôlez, puis vous renvoyez le résultat dans un bloc tool_result. Anthropic ne stocke jamais le fichier. Vous n’avez donc aucun coût de stockage à répercuter. 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 auto, le prompt système d’utilisation des outils contient 286 tokens, comme indiqué en août 2026. Ce coût est facturé 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 chargent des données au début de chaque session. Les fichiers CLAUDE.md contiennent les instructions que vous écrivez. La mémoire automatique contient les notes que Claude écrit pour lui-même, sous ~/.claude/projects/<project>/memory/. Seules les 200 premières lignes ou les 25KB de MEMORY.md sont chargés, selon la limite atteinte en premier. Les fichiers de sujets placé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 par chaque requête ultérieure de cette 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 écrit et met à jour au fil de vos échanges, avec un espace mémoire distinct pour chaque projet. Settings > Memory répertorie les éléments stockés. Le bouton de cette page permet de sélectionner Pause memory ou Reset memory. Cette surface est facturée par abonnement. La mémoire y consomme donc vos 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. 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 de mémoire que Claude a ouvert 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 reste en cache, et 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 facturée du côté des tokens d’entrée.

Où voir ces chiffres dans votre propre utilisation

Ne reprenez pas un chiffre trouvé 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écautions s’imposent. Le comptage est une estimation. Les tokens supplémentaires qu’Anthropic ajoute pour ses propres optimisations système ne vous sont pas facturés. Effectuez également 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, la même question reçoit une réponse sans aucun curl.

• /context affiche ce qui est actuellement chargé, y compris les fichiers de mémoire. Vous pouvez ainsi voir leur part de la fenêtre avant de saisir quoi que ce soit.
• /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 au fur et à mesure.

Le bloc de session /usage ressemble à ceci :

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 lecture du cache, 940.0k, correspond à l’ensemble de la conversation, mémoire comprise, renvoyé à chaque tour au tarif du cache. La valeur d’entrée, 1.2k, 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 peut différer 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 sessions vierges, l’une normale 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 des 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 la répartition de l’utilisation des tokens de Claude Code mérite d’être lue en regard 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 sous forme de multiples du tarif d’entrée de base de chaque modèle. Cette 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 tarif 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, et une durée de vie de 1 heure coûte 2 fois ce tarif. Anthropic indique clairement le seuil de rentabilité : le cache 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 est le calcul à effectuer avant de décider où placer la mémoire.

Ces multiples permettent de calculer le nombre de relectures. Le bloc suivant applique les multiples publiés ci-dessus. Il ne mesure pas une charge réelle. Il évalue le coût d’un bloc de mémoire de trois façons sur une session de 100 tours, sous 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 ne bénéficie jamais du cache sur les 100 tours est facturé comme 400,000 tokens au tarif de base. Le même bloc, avec une écriture dans un cache de 5 minutes suivie de 99 lectures du cache, est facturé comme 44,600. Si vous le réduisez au quart de sa taille tout en conservant le cache, il est facturé comme 11,150. La fonctionnalité n’a pas changé entre ces 3 lignes. Seul le comportement de relecture a changé. Ces valeurs restent des nombres de tokens, pas des montants. Convertir un nombre de tokens en montant sur votre facture mensuelle consiste à 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.

La deuxième ligne suppose que chacune des 99 requêtes suivantes arrive alors que l’entrée du cache est toujours valide. Cette hypothèse est à l’origine de la plupart des écarts sur les factures réelles.

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

Une entrée de cache a une durée de vie. Le délai commence à 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 ligne saisie dans une session laissée ouverte pendant votre pause déjeuner coûte cher, car l’entrée de cache a expiré pendant votre absence. L’intégralité du préfixe, mémoire comprise, est de nouveau traitée au tarif d’entrée de base, puis réécrite dans le cache. C’est la durée de l’interruption qui détermine ce coût.

Vous pouvez le vérifier au lieu de nous croire sur parole. Avec un forfait Pro, Max, Team ou Enterprise, le détail /usage signale tout comportement responsable d’au moins 10 pour cent de l’utilisation récente. Le contexte long et les cache misses y apparaissent tous deux explicitement. 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 lors de la première requête.

Ce qui invalide discrètement le cache

Le préfixe mis en cache suit un ordre : les outils, puis le système, puis les 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 toute personne qui 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 suit. La requête suivante doit donc tout réécrire. Placez les éléments stables au début et ne les modifiez plus. Placez les éléments volatils vers la fin de la liste des messages, où leur invalidation coûte moins cher.

Il existe un deuxième problème, plus discret. Chaque modèle a un préfixe minimal pouvant être mis en cache : 512 tokens pour Claude Opus 5, 1,024 pour Claude Sonnet 5 et 4,096 pour 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 ce nombre de tokens est traitée sans mise en cache et aucune erreur n’est renvoyée. » Un petit fichier mémoire marqué par cache_control ne produit donc absolument aucun effet, sans message d’erreur. Le symptôme observable est que cache_creation_input_tokens reste à 0 alors que votre prompt contient clairement un breakpoint.

Supprimez la mémoire qui n’est plus utile

Chaque ligne de mémoire consomme des tokens à chaque tour où elle est incluse. 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 réduisent la fiabilité avec laquelle Claude les suit. 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 le garder concis. 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 est le moyen le plus rapide de repérer un fait devenu obsolète. Supprimer la mémoire obsolète des agents 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 où elles sont nécessaires. 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 précédents. 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 la tarification d’Anthropic.

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 déclenchement à 100,000 tokens d’entrée et la conservation de 3 utilisations d’outils. Consultez le fonctionnement de la mise en cache avant de l’activer : la suppression du contenu invalide le préfixe mis en cache au point de la suppression, et vous payez donc une é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 les économies soient suffisamment importantes 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, afin que le compromis soit mesurable et non théorique. Gérer 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 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 que la recherche ajoute au contexte.
• 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 Web.
• Claude Managed Agents : exécution de session facturée 0,08 $ par heure de session, en plus des frais habituels liés aux tokens.
• Récupération Web : aucun frais 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 exactement à 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 fonctionne 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 mécanisme ne vous le signale.

FAQ

Les fonctionnalités de mémoire de Claude sont-elles facturées séparément ?

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 tarifaire dédiée à la mémoire. Dans l’API Claude, l’outil de mémoire est géré 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 des tokens d’entrée du modèle à chaque tour qui les contient.

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à conservées en mémoire, ces tokens coûtent plus cher que la mémoire elle-même. Mesurez plutôt que de supposer : 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 dépensé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 et l’écrit de nouveau. La deuxième cause la plus fréquente est une modification du préfixe : changer une définition d’outil invalide l’intégralité du cache, tandis que modifier le system prompt invalide le cache du système et des messages. Avec un forfait par abonnement, le détail /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 se trouve alors dans le préfixe mis en cache et son coût correspond au 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 ne coûte alors ses tokens qu’une seule fois, au lieu de les coûter à chaque tour. Le nombre déterminant est votre nombre de relectures, et l’objet usage vous fournit directement cette valeur.

Les fonctionnalités de mémoire sont-elles prises en compte dans les limites d’utilisation d’un abonnement ?

Oui, indirectement, car les limites d’un abonnement sont consommées par les tokens contenus dans 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.