Was sind Tokens bei Claude und wie funktionieren sie? Wir haben 3,8 Milliarden gezählt

Das Wort begegnet dir rund um Claude überall: in der Preisliste, in der Limit-Meldung, in /usage, in jedem Artikel übers Sparen. Fast niemand sagt, was ein Token ist, und die Zahl, auf die die Leute schauen, ist selten die, auf die es ankommt. Der Teil, den Claude zurückschreibt, ist ein Bruchteil eines Prozents dessen, was eine Coding-Sitzung zählt.

Also haben wir unsere gezählt. Dreißig Tage Claude Code-Sitzungen auf einem Mac, vom 10. September bis zum 9. Oktober 2026: 388 Sitzungen, 19.668 Anfragen an das Modell, 3,8 Milliarden Tokens. Hier steht, was ein Token ist, auf welche vier Arten Claude sie zählt und wie diese Zahlen bei echter Arbeit aussehen.

Ein Token ist ein Stück Text, und die Größe des Stücks ändert sich

Ein Modell liest keine Buchstaben und keine Wörter. Es liest Tokens: Textstücke aus einem festen Vokabular, manchmal ein ganzes kurzes Wort, oft ein Teil eines Wortes, manchmal ein einzelnes Zeichen oder Byte für etwas, das es noch nie gesehen hat. Alles wird in diesen Stücken gezählt: was du sendest, was Claude schreibt, was es zwischen den Runden behält.

Wie viel Text in ein Token passt, hängt vom Modell und von der Sprache ab. Das Glossar von Anthropic nennt etwa 3,5 englische Zeichen pro Token bei Modellen vor Claude 4.7 und sagt, dass Claude 4.7 und neuer einen neueren Tokenizer nutzen, der für denselben Text etwa 30 % mehr Tokens erzeugt. Die exakte Zahl liefert nur der Token-Counting-Endpoint, mit dem Modell, das du verwenden willst.

Wir haben das Verhältnis an unserem eigenen Text gemessen. Unsere Agenten antworten auf Französisch, also haben wir die Antworten genommen, die reiner Text waren, ohne Denken, ohne Tool-Aufruf, ohne Codeblock, mit mindestens 80 Wörtern: 296 davon, verteilt auf Opus 5, Opus 5.5, Fable 5.1 und Sonnet 5.5. Der Median lag bei 2,3 Zeichen pro Token, etwa 2,6 Tokens pro Wort. Code, JSON und nicht lateinische Schriften ergeben andere Verhältnisse. Es geht nicht um die exakte Zahl: Ein Token ist kleiner als ein Wort, und du zählst sie nie von Hand.

Jede Anfrage wird auf vier Zählern gezählt

Claude Code schreibt jede Sitzung in ein JSONL-Transkript unter ~/.claude/projects/. Jede Antwort des Modells trägt einen usage-Block. Hier ist ein echter aus unseren Transkripten, mit den nützlichen Feldern:

"usage": {
  "input_tokens": 2,
  "cache_creation_input_tokens": 51836,
  "cache_read_input_tokens": 24882,
  "output_tokens": 315,
  "output_tokens_details": { "thinking_tokens": 54 },
  "cache_creation": {
    "ephemeral_1h_input_tokens": 51836,
    "ephemeral_5m_input_tokens": 0
  }
}

Vier Zähler, und sie kosten nicht dasselbe:

• input_tokens: der Teil des Prompts, der weder in den Cache geschrieben noch aus ihm gelesen wird, abgerechnet zum Basis-Eingabepreis. In Claude Code sind das fast immer nur eine Handvoll Tokens, weil fast alles über den Cache läuft.
• cache_creation_input_tokens: der Teil des Prompts, der im Cache gespeichert wird, damit die nächste Anfrage ihn wiederverwenden kann. Ein Cache-Schreibvorgang kostet das 1,25-Fache des Eingabepreises für einen 5-Minuten-Cache und das 2-Fache für einen 1-Stunden-Cache. In unseren Transkripten waren 97 % der Schreibvorgänge vom 1-Stunden-Typ.
• cache_read_input_tokens: der Teil des Prompts, der aus dem Cache wieder abgespielt wird. Ein Cache-Lesevorgang kostet das 0,1-Fache des Eingabepreises bei den meisten Modellen, das 0,05-Fache bei Opus 5.5 und Sonnet 5.5 und das 0,025-Fache bei Fable 5.1 (Anthropics Seite zum Prompt Caching, geprüft am 10. Oktober 2026).
• output_tokens: was Claude schreibt, Denken inklusive. Ausgabe kostet bei jedem aktuellen Modell das 5-Fache des Eingabepreises: 20 Dollar pro Million bei Opus 5.5, 25 bei Opus 5, 50 bei Fable 5.1, 10 bei Sonnet 5.5.

Die ersten drei ergeben zusammen den Kontext, den das Modell für diese Anfrage gelesen hat. Der vierte ist die Antwort.

Wie 30 Tage unserer Sitzungen aussehen

Über die 19.668 Anfragen, jede Anfrage einmal gezählt (ein API-Aufruf kann sich über mehrere Zeilen eines Transkripts erstrecken):

Die Kostenspalte bewertet jede Anfrage mit ihrem eigenen Modell und ihrer eigenen Cache-Dauer. Diesen Betrag zahlen wir nicht: Diese Sitzungen liefen über ein Abo. Es ist das Gewicht jedes Zählers, dieselbe Gewichtung, mit der AgentsRoom den Prozentsatz eines Abos auf die Projekte verteilt.

Drei Beobachtungen.

Fast jedes Token ist die Konversation, die erneut gelesen wird. 97,7 % der Tokens sind Cache-Lesevorgänge. 99,2 % der Anfragen haben etwas aus dem Cache gelesen. Wenn jemand sagt, eine Sitzung habe „50 Millionen Tokens verbraucht“, schaut er auf genau das.

Was Claude schreibt, ist in Tokens winzig und in Kosten nicht. 0,34 % der Tokens, 16,8 % der Rechnung, weil Ausgabe das teuerste Token überhaupt ist. Denken machte 29 % dieser Ausgabe aus.

Cache-Schreibvorgänge sind die teure Überraschung. 2 % der Tokens, 37 % der Kosten. Wir hatten erwartet, dass sie vom Ablaufen des Caches kommen, aber nur 16 von 19.668 Anfragen mussten einen kalten Kontext neu schreiben, sieben davon nach mehr als einer Stunde Stille. 79 % der Schreibvorgänge sind einfach jede neue Nachricht und jedes Tool-Ergebnis, die einmal gespeichert werden, zum doppelten Eingabepreis, bevor sie in jeder folgenden Runde erneut gelesen werden. Die übrigen 20 % sind die erste Anfrage jeder Sitzung.

Warum eine Sitzung mit jeder Runde schwerer wird

Das Modell behält zwischen zwei Anfragen nichts. Claude Code sendet jedes Mal alles erneut: den System-Prompt, die Tool-Definitionen, CLAUDE.md, jede Nachricht, jede gelesene Datei, jede Befehlsausgabe. Der Cache macht den wiederholten Teil pro Token günstig, nicht kostenlos und nicht kleiner.

Mittlerer gelesener Kontext pro Anfrage, nach Position in der Sitzung:

Die mittlere Anfrage las 179.000 Tokens Kontext, um 290 Tokens Antwort zu schreiben. Dieses Verhältnis erzählt die ganze Geschichte der Tokens in einem Coding-Agenten: Die Antwort ist kurz, das Lesen ist lang, und das Lesen wächst mit der Sitzung.

Unsere erste Anfrage ist schwer, 52.000 Tokens, bevor überhaupt jemand etwas getippt hat, weil unsere Agenten mit einem langen Rollen-Briefing und vier MCP-Servern starten, deren Tool-Definitionen im Prompt stehen. Eine nackte Claude Code-Sitzung in einem leeren Ordner startet viel niedriger. /context zeigt, was deine vor der ersten Nachricht mitträgt.

Was eine Sitzung verbraucht

Über die 380 Sitzungen mit mindestens drei Anfragen:

• 33 Anfragen im Median, 16 bis 61 für die mittlere Hälfte.
• 27.000 Ausgabe-Tokens im Median, 12.000 bis 48.000.
• 5,4 Millionen verarbeitete Tokens im Median, 1,5 bis 10,7 Millionen für die mittlere Hälfte, davon 5,1 Millionen Cache-Lesevorgänge.
• 181.000 Tokens im Median in den Cache geschrieben oder ohne Cache gesendet: der Teil, der wirklich neu war.
• 4,55 Dollar zu API-Listenpreisen im Median, 1,81 bis 9,25 für die mittlere Hälfte.

Die ehrliche Antwort auf „Wie viele Tokens verbraucht eine Coding-Sitzung?“ ist also eine Spanne von etwa einer bis zehn Millionen, fast alles derselbe Kontext, der erneut gelesen wird. Eine Sitzung, die den ganzen Nachmittag an einer langen Aufgabe läuft, liegt am oberen Ende der Spanne; eine Sitzung, die einen Bug behebt und aufhört, liegt am unteren Ende.

Was das 5-Stunden-Fenster und die Woche wirklich zählen

Bei einem Pro- oder Max-Abo siehst du nie einen Token-Stand. Das Hilfecenter von Anthropic sagt, dass beide Abos ein Sitzungslimit von fünf Stunden und ein Wochenlimit haben, dass diese Limits zwischen Claude und Claude Code geteilt werden (IDE inklusive) und dass Max-Abos ein separates Wochenlimit für Fable haben. Für keines davon veröffentlicht es eine Token-Zahl. /usage zeigt einen Prozentsatz jedes Fensters und den Zeitpunkt, zu dem es zurückgesetzt wird.

Was diesen Prozentsatz bewegt, laut Anthropics eigener Liste: Nachrichtenlänge, Größe von Anhängen, Länge der aktuellen Konversation, Tool-Nutzung, Modellwahl, Reasoning-Aufwand und mehrstufige Aufgaben. Liest man das zusammen mit den Tabellen oben, dominiert „Länge der aktuellen Konversation“ eine Coding-Sitzung: Der bei jeder Anfrage gelesene Kontext wächst über fünfzig Anfragen von 52.000 auf 237.000 Tokens. Das Hilfecenter sagt außerdem, dass gecachte Inhalte in Projekten bei Wiederverwendung weniger auf deine Limits angerechnet werden, was dieselbe Idee ist wie der Preis eines Cache-Lesevorgangs.

Wir wissen nicht, wie Anthropic Tokens in einen Prozentsatz eines Fensters umrechnet, und wir werden keine Umrechnung erfinden. Was die Daten sagen: Eine späte Anfrage in einer langen Sitzung zählt bei derselben Frage ein Mehrfaches einer frühen.

Was die Zählung in der Praxis ändert

Vier Hebel, in der Reihenfolge, in der sie in unseren Daten zählen:

• /clear zwischen Aufgaben, die nichts miteinander zu tun haben. Anthropic nennt es „den wirksamsten einzelnen Hebel für Qualität und Kosten“. Eine neue Aufgabe in einer alten Sitzung bezahlt bei jeder Anfrage den Kontext der alten Aufgabe.
• /compact, wenn du eine lange Sitzung fortsetzt. Es ersetzt den Verlauf durch eine kurze Zusammenfassung, sodass die nächsten Anfragen weniger lesen.
• Achte darauf, was im Kontext landet. Ein Datei-Lesevorgang oder eine Befehlsausgabe von 20.000 Tokens wird einmal zum doppelten Eingabepreis geschrieben und dann bei jeder folgenden Anfrage erneut gelesen, bis die Sitzung endet. Nur die Zeilen zu lesen, die du brauchst, statt der ganzen Datei, zahlt sich doppelt aus.
• Modell und Aufwand. Denken machte 29 % unserer Ausgabe aus, und Ausgabe ist das teuerste Token. Ein niedrigerer Reasoning-Aufwand bei Routinearbeit senkt die Ausgabe, und ein günstigeres Modell senkt alle Preise auf einmal.

Was in unseren Daten keine Rolle spielte: eine Sitzung ruhen zu lassen. Mit dem 1-Stunden-Cache, den Claude Code in unseren Transkripten nutzt, kam ein kaltes Neuschreiben in 30 Tagen 16 Mal vor.

Weitere Wege, weniger auszugeben, findest du unter wie du deine Claude Code-Token-Kosten senkst.

Zähl deine eigenen

Die Tabelle oben stammt aus einem Skript ohne Abhängigkeiten. Es liest jedes Claude Code-Transkript auf dem Rechner, zählt jede Anfrage einmal und gibt die vier Zähler und die Mediane pro Sitzung aus. Füge einen Filter auf o["timestamp"] hinzu, wenn du ein Zeitfenster willst.

import json, glob, os, statistics as st
from collections import defaultdict

FIELDS = ("input_tokens", "cache_creation_input_tokens",
          "cache_read_input_tokens", "output_tokens")
totals, sessions = defaultdict(int), []
for path in glob.glob(os.path.expanduser("~/.claude/projects/*/*.jsonl")):
    seen, session = set(), defaultdict(int)
    with open(path, errors="ignore") as fh:
        for line in fh:
            try: o = json.loads(line)
            except ValueError: continue
            msg = o.get("message") or {}
            usage = msg.get("usage") if isinstance(msg, dict) else None
            if o.get("type") != "assistant" or not usage: continue
            rid = o.get("requestId") or o.get("uuid")
            if rid in seen: continue   # one API call can span several lines
            seen.add(rid)
            session["requests"] += 1
            for f in FIELDS:
                n = usage.get(f) or 0
                totals[f] += n
                session[f] += n
    if session["requests"] >= 3: sessions.append(session)

grand = sum(totals[f] for f in FIELDS)
for f in FIELDS:
    print(f"{f:30s} {totals[f]:>15,} {100 * totals[f] / grand:6.2f}%")
for key in ("requests", "output_tokens", "cache_read_input_tokens"):
    print(f"median per session, {key}: {st.median(s[key] for s in sessions):,.0f}")

Vergleiche deine Anteile mit unseren. Die Zeile der Cache-Lesevorgänge ist die Konversation, die erneut gelesen wird, und die Zeile der Cache-Schreibvorgänge ist das, was neu war: Diese beiden sagen mehr über deine Rechnung als die Ausgabezeile.

Wo AgentsRoom es anzeigt

Das Skript liefert dir einen Monat. Während du arbeitest, zeigt AgentsRoom dieselben Zähler pro Agent: ein Token-Badge im Composer jeder Sitzung, das rot wird, wenn eine Sitzung schwer wird, einen Sitzungsmonitor mit Eingabe, Ausgabe, Cache-Schreibvorgängen, Cache-Lesevorgängen und der Cache-Trefferquote, und einen Sitzungs-Trace, der die Sitzung Runde für Runde nachspielt und zeigt, welcher Datei-Lesevorgang oder welches Tool-Ergebnis den Kontext gefüllt hat. Das Nutzungs-Panel verteilt den Prozentsatz, den dein Abo meldet, auf deine Projekte und deine Agenten und gewichtet jede Sitzung nach dem, was sie zu API-Preisen kosten würde, dieselbe Gewichtung wie in der Tabelle oben.

Was dir nichts davon liefert, ist ein Token-Stand, weil dein Abo keinen hat. Für diese Frage lies wie viele Tokens du bei Claude noch hast. Für die Geschwindigkeit, mit der diese Ausgabe-Tokens ankommen, lies Claude Code Tokens pro Sekunde, gemessen.

Häufige Fragen

Was ist ein Token bei Claude?

Die Einheit, in der Claude Text liest und schreibt: ein Wortstück, manchmal ein ganzes kurzes Wort, manchmal ein einzelnes Zeichen oder Byte. Laut Anthropic hängt die Größe vom Modell und von der Sprache ab: Bei Modellen vor Claude 4.7 entsprach ein Token etwa 3,5 englischen Zeichen, und Claude 4.7 und neuer nutzen einen neueren Tokenizer, der für denselben Text etwa 30 % mehr Tokens erzeugt. Alles, was Claude tut, wird in Tokens gemessen: was du sendest, was es zurückschreibt und was es zwischen den Runden in seinem Cache behält.

Wie viele Zeichen oder Wörter hat ein Claude-Token?

Das hängt von der Sprache und vom Text ab. Anthropic nennt etwa 3,5 englische Zeichen pro Token bei Modellen vor Claude 4.7 und etwa 30 % mehr Tokens für denselben Text bei Claude 4.7 und neuer. Bei 296 reinen Textantworten, die unsere Agenten im September und Oktober 2026 auf Französisch geschrieben haben, entsprach ein Token 2,3 Zeichen, also etwa 2,6 Tokens pro Wort. Code, JSON und nicht lateinische Schriften ergeben andere Verhältnisse. Für eine exakte Zählung nimmt der Token-Counting-Endpoint von Anthropic den Text und das Modell entgegen.

Warum verbraucht Claude Code so viele Tokens?

Weil jede Anfrage die gesamte Konversation erneut sendet: den System-Prompt, die Tool-Definitionen, CLAUDE.md, jede Nachricht und jedes bisherige Tool-Ergebnis. Bei unseren 19.668 Anfragen trug die mittlere Anfrage 179.000 Tokens Kontext, um 290 Tokens Antwort zu schreiben, und der Kontext wuchs von 52.000 Tokens bei der ersten Anfrage einer Sitzung auf 237.000 nach fünfzig Anfragen. Der Cache macht dieses erneute Lesen pro Token günstig, gezählt wird es trotzdem.

Wie viele Tokens verbraucht eine typische Claude Code-Sitzung?

Bei unseren 380 Sitzungen mit drei oder mehr Anfragen, aufgezeichnet zwischen dem 10. September und dem 9. Oktober 2026: im Median 33 Anfragen, 27.000 Ausgabe-Tokens und insgesamt 5,4 Millionen verarbeitete Tokens, davon 5,1 Millionen Cache-Lesevorgänge. Die Hälfte der Sitzungen lag zwischen 1,5 und 10,7 Millionen Tokens. Zu API-Listenpreisen hätte diese mittlere Sitzung etwa 4,55 Dollar gekostet; bei einem Pro- oder Max-Abo wird dieselbe Arbeit stattdessen auf das 5-Stunden-Fenster und das Wochenfenster angerechnet.

Zählen Denk-Tokens mit?

Ja. Denk-Tokens sind in jedem usage-Block Teil von output_tokens, mit einem Feld thinking_tokens, das angibt, wie viel der Ausgabe Denken war. Über die API werden sie zum Ausgabepreis abgerechnet, und Anthropic nennt den Reasoning-Aufwand unter den Dingen, die die Nutzungslimits eines Abos schneller aufbrauchen. In unserem Korpus machte das Denken 29 % von allem aus, was die Modelle geschrieben haben.

Was ist der Unterschied zwischen Cache-Schreib- und Cache-Lese-Tokens?

Ein Cache-Schreibvorgang speichert einen Teil des Prompts, damit die nächste Anfrage ihn wiederverwenden kann, und kostet mehr als normale Eingabe: das 1,25-Fache des Eingabepreises für einen 5-Minuten-Cache, das 2-Fache für einen 1-Stunden-Cache. Ein Cache-Lesevorgang verwendet diesen gespeicherten Teil wieder und kostet deutlich weniger: das 0,1-Fache des Eingabepreises bei den meisten Modellen, das 0,05-Fache bei Opus 5.5 und Sonnet 5.5, das 0,025-Fache bei Fable 5.1. In unseren Sitzungen machten Cache-Lesevorgänge 98 % der Tokens und 46 % der Kosten zu Listenpreisen aus; Cache-Schreibvorgänge 2 % der Tokens und 37 % der Kosten.