option

cost-tracking

affaan-m/ECC affaan-m/ECC

Analysez l'utilisation des jetons Claude Code, les dépenses et les budgets à partir du journal des indicateurs du système de suivi des coûts ECC local. Fournit des synthèses, des ventilations par modèle, par session ou par date, ainsi qu'une exportation au format CSV.

...Développer tout
32
Heure mise à jour 2 octobre 2026

Suivi des coûts

Utilisez cette compétence pour analyser l'historique des coûts et de l'utilisation de Claude Code à partir du journal des métriques généré par le hook « stop:cost-tracker » d'ECC.

Emplacement des données

Le tracker ajoute un objet JSON par arrêt de session au fichier ~/.claude/metrics/costs.jsonl. Chaque ligne correspond à un instantané cumulatif pour cette session; pour calculer le total des dépenses, il faut donc prendre la dernière ligne par session_id et additionner les valeurs d’une session à l’autre — l’addition de chaque ligne entraîne un comptage multiple.

Schéma des lignes :

Champ Signification
timestamp Horodatage ISO de l’instantané
session_id Claude Code : identifiant de session
transcript_path Chemin d'accès à la transcription de la session
modèle Modèle utilisé
input_tokens / output_tokens Nombre de tokens
cache_write_tokens / cache_read_tokens Nombre de tokens dans le cache des prompts
estimated_cost_usd Coût cumulé précalculé en USD pour la session

Privilégiez estimated_cost_usd plutôt que de calculer manuellement les prix : les prix des modèles et du cache varient, et le tracker fait autorité.

Quand l'utiliser

  • L'utilisateur demande « Combien ai-je dépensé ? », « Combien a coûté cette session ? » ou « Quelle est ma consommation de jetons ? »
  • L’utilisateur évoque des budgets, des limites de dépenses, des dépassements ou des contrôles de coûts.
  • L’utilisateur souhaite une ventilation des coûts par modèle, session ou date, ou une exportation au format CSV.

Fonctionnement

Vérifiez d’abord que le journal existe (utilisez `node`, pas `sqlite3 ` — le tracker écrit en JSONL, et `node` est multiplateforme) :

node -e 'const fs=require("fs"),os=require("os"),p=require("path");const f=p.join(os.homedir(),".claude","metrics","costs.jsonl");console.log(fs.existsSync(f)?"journal des coûts trouvé":"journal des coûts introuvable : "+f)'

Si le journal est manquant, ne fabriquez pas de données d'utilisation. Indiquez à l'utilisateur que le suivi des coûts se remplit après la fin de la première session avec le hook `stop:cost-tracker` activé.

Exemple — résumé, par modèle, 7 derniers jours

node -e '
const fs=require("fs"),os=require("os"),path=require("path");
const f=path.join(os.homedir(),".claude","metrics","costs.jsonl");
if(!fs.existsSync(f)){console.log("journal des coûts introuvable : "+f);process.exit(0);}
const rows=fs.readFileSync(f,"utf8").split(/\r?\n/).filter(Boolean).map(l=>{try{return JSON.parse(l)}catch{return null}}).filter(Boolean);
const bySession = new Map();
for (const r of rows) { const k = r.session_id || r.transcript_path || r.timestamp; const p = bySession.get(k); if (!p || String(r.timestamp)>String(p.timestamp)), bySession.set(k, r);}
const latest = [...bySession.values()];
const cost = r => Number(r.estimated_cost_usd) || 0, day = r => String(r.timestamp || "").slice(0, 10), sum = a => a.reduce((s, r) => s + cost(r), 0), f4 = n => "$" + n.toFixed(4);
const today = new Date().toISOString().slice(0, 10), yest = new Date(Date.now() - 864e5).toISOString().slice(0, 10);
console.log("aujourd’hui : "+f4(sum(latest.filter(r=>day(r)===today)))+" | hier : " + f4(sum(latest.filter(r => day(r) === yest))) + " | total : " + f4(sum(latest)) + " (" + latest.length + " sessions)");
const m = new Map(); for (const r of latest) { const k = r.model || "(unknown)"; m.set(k, (m.get(k) || 0) + cost(r)); }
console.log("par modèle :"); [...m.entries()].sort((a, b) => b[1] - a[1]).forEach(([k, v]) => console.log("  " + f4(v) + "  " + k));
'

Pour une analyse détaillée d’une session ou une exportation au format CSV, parcourez le même ensemble « latest » (ou les lignes brutes pour le CSV) et affichez les champs dont vous avez besoin.

Conseils pour les rapports

Lors de la présentation des données de coûts, incluez les dépenses d’aujourd’hui par rapport à celles d’hier, le total sur l’ensemble des sessions, une ventilation par modèle et le nombre de sessions. Affichez les montants inférieurs à un dollar avec quatre décimales, et les montants plus importants avec deux.

Anti-modèles

  • Ne totalisez pas chaque ligne — les montants sont cumulés par session ; réduisez d’abord le tout à la dernière ligne par session_id.
  • N’estimez pas les coûts à partir du nombre brut de jetons lorsque le champ ` estimated_cost_usd ` est présent.
  • Ne partez pas du principe que le journal existe sans avoir vérifié.
  • Ne codez pas en dur les tarifs actuels des modèles dans les réponses destinées aux utilisateurs.
  • Ne recommandez pas l’installation de hooks ou de plugins non vérifiés qui exécutent du code arbitraire.

Connexes

  • /cost-report - Rapport sous forme de commande portant sur le même journal de métriques.
  • cost-aware-llm-pipeline - Modèles de routage des modèles et de conception budgétaire.
  • token-budget-advisor - Planification du contexte et du budget de tokens.
  • strategic-compact - Compactage du contexte pour réduire la dépense répétée de jetons.
Voir sur GitHub
---
name: cost-tracking
description: Analyze Claude Code token usage, spending, and budgets from the local ECC cost-tracker metrics log. Provides summaries, breakdowns by model, session, or date, and CSV export.
---

# Cost Tracking

Use this skill to analyze Claude Code cost and usage history from the metrics log
that ECC's `stop:cost-tracker` hook writes.

## Where the data lives

The tracker appends one JSON object per session-stop to
`~/.claude/metrics/costs.jsonl`. Each row is a **cumulative snapshot for that
session**, so to total spend you take the **latest row per `session_id`** and
sum across sessions — summing every row multiply-counts.

Row schema:

| Field | Meaning |
| --- | --- |
| `timestamp` | ISO timestamp of the snapshot |
| `session_id` | Claude Code session identifier |
| `transcript_path` | Path to the session transcript |
| `model` | Model used |
| `input_tokens` / `output_tokens` | Token counts |
| `cache_write_tokens` / `cache_read_tokens` | Prompt-cache token counts |
| `estimated_cost_usd` | Precomputed cumulative cost in USD for the session |

Prefer `estimated_cost_usd` over hand-calculating pricing — model and cache
prices change, and the tracker is the source of truth.

## When to Use

- The user asks "how much have I spent?", "what did this session cost?", or
  "what is my token usage?"
- The user mentions budgets, spending limits, overruns, or cost controls.
- The user wants a cost breakdown by model, session, or date, or a CSV export.

## How It Works

First verify the log exists (use `node`, not `sqlite3` — the tracker writes
JSONL, and `node` is cross-platform):

```bash
node -e 'const fs=require("fs"),os=require("os"),p=require("path");const f=p.join(os.homedir(),".claude","metrics","costs.jsonl");console.log(fs.existsSync(f)?"cost log found":"cost log not found: "+f)'
```

If the log is missing, do not fabricate usage data. Tell the user that cost
tracking populates after the first session ends with the `stop:cost-tracker`
hook enabled.

## Example — summary, by model, last 7 days

```bash
node -e '
const fs=require("fs"),os=require("os"),path=require("path");
const f=path.join(os.homedir(),".claude","metrics","costs.jsonl");
if(!fs.existsSync(f)){console.log("cost log not found: "+f);process.exit(0);}
const rows=fs.readFileSync(f,"utf8").split(/\r?\n/).filter(Boolean).map(l=>{try{return JSON.parse(l)}catch{return null}}).filter(Boolean);
const bySession=new Map();
for(const r of rows){const k=r.session_id||r.transcript_path||r.timestamp;const p=bySession.get(k);if(!p||String(r.timestamp)>String(p.timestamp))bySession.set(k,r);}
const latest=[...bySession.values()];
const cost=r=>Number(r.estimated_cost_usd)||0, day=r=>String(r.timestamp||"").slice(0,10), sum=a=>a.reduce((s,r)=>s+cost(r),0), f4=n=>"$"+n.toFixed(4);
const today=new Date().toISOString().slice(0,10), yest=new Date(Date.now()-864e5).toISOString().slice(0,10);
console.log("today: "+f4(sum(latest.filter(r=>day(r)===today)))+" | yesterday: "+f4(sum(latest.filter(r=>day(r)===yest)))+" | total: "+f4(sum(latest))+" ("+latest.length+" sessions)");
const m=new Map();for(const r of latest){const k=r.model||"(unknown)";m.set(k,(m.get(k)||0)+cost(r));}
console.log("by model:");[...m.entries()].sort((a,b)=>b[1]-a[1]).forEach(([k,v])=>console.log("  "+f4(v)+"  "+k));
'
```

For a session drilldown or CSV export, iterate the same `latest` set (or the raw
rows for CSV) and print the fields you need.

## Reporting Guidance

When presenting cost data, include today's spend vs yesterday, total across all
sessions, a by-model breakdown, and session count. Format sub-dollar amounts
with four decimals, larger amounts with two.

## Anti-Patterns

- Do not sum every row — they are cumulative per session; reduce to the latest
  row per `session_id` first.
- Do not estimate costs from raw token counts when `estimated_cost_usd` is present.
- Do not assume the log exists without checking.
- Do not hard-code current model pricing in user-facing answers.
- Do not recommend installing unreviewed hooks or plugins that execute arbitrary code.

## Related

- `/cost-report` - Command-form report over the same metrics log.
- `cost-aware-llm-pipeline` - Model-routing and budget-design patterns.
- `token-budget-advisor` - Context and token-budget planning.
- `strategic-compact` - Context compaction to reduce repeated token spend.

Tous les fichiers

1 fichiers

Installer cost-tracking

Téléchargez et décompressez les fichiers de compétences dans votre répertoire .claude/skills/.

Télécharger le ZIP

Clonez le dépôt et copiez les fichiers de compétence dans votre projet.

git clone https://github.com/affaan-m/ECC/tree/main/skills/cost-tracking # Copy SKILL.md to your .claude/skills/ directory

Copier Copier
Configuration rapide: Copiez le dossier de la compétence dans .claude/skills/ Claude détectera automatiquement la compétence et l'utilisera
Dépôt affaan-m/ECC

Compétences similaires

airtable-automation
Heure mise à jour 29 juin 2026
notion-automation
Heure mise à jour 29 juin 2026
seo-programmatic
Heure mise à jour 29 juin 2026
revops
Heure mise à jour 29 juin 2026
OR