Czym są tokeny w Claude i jak działają? Policzyliśmy 3,8 miliarda

To słowo spotykasz wszędzie wokół Claude: w cenniku, w komunikacie o limicie, w /usage, w każdym artykule o oszczędzaniu. Prawie nikt nie mówi, czym jest token, a liczba, na którą ludzie patrzą, rzadko jest tą, która ma znaczenie. To, co Claude odpisuje, to ułamek procenta tego, co liczy sesja programistyczna.

Więc policzyliśmy nasze. Trzydzieści dni sesji Claude Code na jednym Macu, od 10 września do 9 października 2026: 388 sesji, 19 668 żądań do modelu, 3,8 miliarda tokenów. Oto czym jest token, cztery sposoby, w jakie Claude je liczy, i jak te liczby wyglądają przy prawdziwej pracy.

Token to kawałek tekstu, a rozmiar tego kawałka się zmienia

Model nie czyta liter ani słów. Czyta tokeny: kawałki tekstu ze stałego słownika, czasem całe krótkie słowo, często część słowa, czasem pojedynczy znak lub bajt dla czegoś, czego nigdy nie widział. Wszystko liczy się w tych kawałkach: to, co wysyłasz, to, co pisze Claude, to, co trzyma między turami.

Ile tekstu mieści się w tokenie, zależy od modelu i od języka. Glosariusz Anthropic podaje około 3,5 znaku angielskiego na token w modelach sprzed Claude 4.7 i mówi, że Claude 4.7 i nowsze używają nowszego tokenizera, który dla tego samego tekstu daje około 30% więcej tokenów. Dokładną liczbę daje tylko endpoint do liczenia tokenów, z modelem, którego zamierzasz użyć.

Zmierzyliśmy tę proporcję na własnym tekście. Nasi agenci odpowiadają po francusku, więc wzięliśmy odpowiedzi w czystym tekście, bez myślenia, bez wywołania narzędzia, bez bloku kodu, liczące co najmniej 80 słów: 296 odpowiedzi z Opus 5, Opus 5.5, Fable 5.1 i Sonnet 5.5. Mediana wyniosła 2,3 znaku na token, około 2,6 tokenu na słowo. Kod, JSON i pisma niełacińskie dają inne proporcje. Nie chodzi o dokładną liczbę: token jest mniejszy niż słowo i nigdy nie liczysz ich ręcznie.

Każde żądanie jest liczone na czterech licznikach

Claude Code zapisuje każdą sesję w transkrypcji JSONL w ~/.claude/projects/. Każda odpowiedź modelu zawiera blok usage. Oto prawdziwy blok z naszych transkrypcji, z przydatnymi polami:

"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
  }
}

Cztery liczniki, które nie kosztują tyle samo:

• input_tokens: część promptu, która ani nie jest zapisywana do pamięci podręcznej, ani z niej odczytywana, rozliczana po bazowej cenie wejścia. W Claude Code to prawie zawsze garść tokenów, bo prawie wszystko przechodzi przez pamięć podręczną.
• cache_creation_input_tokens: część promptu zapisana w pamięci podręcznej, żeby następne żądanie mogło ją ponownie wykorzystać. Zapis do pamięci podręcznej kosztuje 1,25 ceny wejścia dla pamięci 5-minutowej i 2 razy tyle dla 1-godzinnej. W naszych transkrypcjach 97% zapisów było typu 1-godzinnego.
• cache_read_input_tokens: część promptu odtworzona z pamięci podręcznej. Odczyt z pamięci podręcznej kosztuje 0,1 ceny wejścia w większości modeli, 0,05 w Opus 5.5 i Sonnet 5.5 oraz 0,025 w Fable 5.1 (strona Anthropic o prompt caching, sprawdzona 10 października 2026).
• output_tokens: to, co pisze Claude, łącznie z myśleniem. Wyjście kosztuje 5 razy więcej niż wejście w każdym obecnym modelu: 20 dolarów za milion w Opus 5.5, 25 w Opus 5, 50 w Fable 5.1, 10 w Sonnet 5.5.

Pierwsze trzy razem dają kontekst, który model przeczytał przy tym żądaniu. Czwarty to odpowiedź.

Jak wygląda 30 dni naszych sesji

Na 19 668 żądaniach, każde żądanie liczone raz (jedno wywołanie API może zajmować kilka linii transkrypcji):

Kolumna kosztu wycenia każde żądanie według jego własnego modelu i jego własnego czasu życia pamięci podręcznej. Nie płacimy tej kwoty: te sesje działały w ramach subskrypcji. To waga każdego licznika, ta sama, której AgentsRoom używa, żeby podzielić procent subskrypcji między projekty.

Trzy wnioski.

Prawie każdy token to ponownie czytana rozmowa. 97,7% tokenów to odczyty z pamięci podręcznej. 99,2% żądań odczytało coś z pamięci podręcznej. Kiedy ktoś mówi, że sesja „zużyła 50 milionów tokenów”, patrzy właśnie na to.

To, co pisze Claude, jest małe w tokenach, ale nie w koszcie. 0,34% tokenów, 16,8% rachunku, bo wyjście to najdroższy token, jaki istnieje. Myślenie stanowiło 29% tego wyjścia.

Zapisy do pamięci podręcznej to kosztowna niespodzianka. 2% tokenów, 37% kosztu. Spodziewaliśmy się, że biorą się z wygasania pamięci podręcznej, ale tylko 16 żądań na 19 668 musiało ponownie zapisać zimny kontekst, siedem z nich po ponad godzinie ciszy. 79% zapisów to po prostu każda nowa wiadomość i każdy wynik narzędzia zapisane raz, po podwójnej cenie wejścia, zanim zostaną ponownie odczytane w każdej kolejnej turze. Pozostałe 20% to pierwsze żądanie każdej sesji.

Dlaczego sesja z każdą turą robi się cięższa

Model nie zachowuje niczego między dwoma żądaniami. Claude Code za każdym razem wysyła wszystko od nowa: prompt systemowy, definicje narzędzi, CLAUDE.md, każdą wiadomość, każdy przeczytany plik, każde wyjście polecenia. Pamięć podręczna sprawia, że powtarzana część jest tania w przeliczeniu na token, ale nie darmowa i nie mniejsza.

Mediana kontekstu czytanego na żądanie, według pozycji w sesji:

Mediana żądania czytała 179 000 tokenów kontekstu, żeby napisać 290 tokenów odpowiedzi. Ta proporcja to cała historia tokenów w agencie programistycznym: odpowiedź jest krótka, czytanie jest długie, a czytanie rośnie razem z sesją.

Nasze pierwsze żądanie jest ciężkie, 52 000 tokenów, zanim ktokolwiek cokolwiek wpisał, bo nasi agenci startują z długim opisem roli i czterema serwerami MCP, których definicje narzędzi siedzą w prompcie. Goła sesja Claude Code w pustym folderze startuje dużo niżej. /context pokazuje, co niesie twoja przed pierwszą wiadomością.

Ile zużywa jedna sesja

Na 380 sesjach liczących co najmniej trzy żądania:

• 33 żądania w medianie, od 16 do 61 dla środkowej połowy.
• 27 000 tokenów wyjściowych w medianie, od 12 000 do 48 000.
• 5,4 miliona przetworzonych tokenów w medianie, od 1,5 do 10,7 miliona dla środkowej połowy, z czego 5,1 miliona to odczyty z pamięci podręcznej.
• 181 000 tokenów zapisanych do pamięci podręcznej lub wysłanych poza nią w medianie: część, która była naprawdę nowa.
• 4,55 dolara według cennika API w medianie, od 1,81 do 9,25 dla środkowej połowy.

Uczciwa odpowiedź na pytanie „ile tokenów zużywa sesja programistyczna” to więc przedział od około jednego do dziesięciu milionów, prawie w całości ten sam kontekst czytany ponownie. Sesja, która przez całe popołudnie pracuje nad jednym długim zadaniem, jest na górze przedziału; sesja, która naprawia jeden błąd i się kończy, jest na dole.

Co naprawdę liczą okno 5-godzinne i tydzień

W subskrypcji Pro lub Max nigdy nie widzisz salda tokenów. Centrum pomocy Anthropic mówi, że oba plany mają 5-godzinny limit sesji i limit tygodniowy, że te limity są wspólne dla Claude i Claude Code (łącznie z IDE) i że plany Max mają osobny limit tygodniowy dla Fable. Dla żadnego z nich nie publikuje liczby tokenów. /usage pokazuje procent każdego okna i godzinę jego resetu.

Co porusza tym procentem, według listy samego Anthropic: długość wiadomości, rozmiar załączników, długość bieżącej rozmowy, użycie narzędzi, wybór modelu, poziom wysiłku i zadania wieloetapowe. W zestawieniu z tabelami powyżej to „długość bieżącej rozmowy” dominuje w sesji programistycznej: kontekst czytany przy każdym żądaniu rośnie z 52 000 do 237 000 tokenów w ciągu pięćdziesięciu żądań. Centrum pomocy mówi też, że treści z pamięci podręcznej w projektach liczą się mniej do twoich limitów, gdy są ponownie wykorzystywane, co jest tą samą ideą co cena odczytu z pamięci podręcznej.

Nie wiemy, jak Anthropic przelicza tokeny na procent okna, i nie będziemy wymyślać przelicznika. Dane mówią natomiast, że późne żądanie w długiej sesji liczy się kilka razy bardziej niż wczesne, przy tym samym pytaniu.

Co w praktyce zmienia licznik

Cztery dźwignie, w kolejności, w jakiej ważą w naszych danych:

• /clear między niepowiązanymi zadaniami. Anthropic nazywa to „najskuteczniejszą pojedynczą dźwignią zarówno dla jakości, jak i kosztu”. Nowe zadanie w starej sesji płaci za kontekst starego zadania przy każdym żądaniu.
• /compact, gdy kontynuujesz długą sesję. Zastępuje historię krótkim podsumowaniem, więc kolejne żądania czytają mniej.
• Pilnuj, co trafia do kontekstu. Przeczytany plik albo wyjście polecenia o rozmiarze 20 000 tokenów jest zapisywane raz po podwójnej cenie wejścia, a potem ponownie czytane przy każdym kolejnym żądaniu aż do końca sesji. Czytanie tylko potrzebnych linii zamiast całego pliku opłaca się podwójnie.
• Model i wysiłek. Myślenie stanowiło 29% naszego wyjścia, a wyjście to najdroższy token. Niższy poziom wysiłku przy rutynowej pracy obniża wyjście, a tańszy model obniża wszystkie ceny naraz.

Co w naszych danych nie miało znaczenia: zostawienie sesji bezczynnej. Przy 1-godzinnej pamięci podręcznej, której Claude Code używa w naszych transkrypcjach, zimny ponowny zapis zdarzył się 16 razy w 30 dni.

Więcej sposobów na wydawanie mniej znajdziesz w artykule jak obniżyć koszty tokenów w Claude Code.

Policz swoje

Tabela powyżej pochodzi ze skryptu bez zależności. Czyta każdą transkrypcję Claude Code na komputerze, liczy każde żądanie raz i wypisuje cztery liczniki oraz mediany na sesję. Dodaj filtr na o["timestamp"], jeśli chcesz ograniczyć okres.

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}")

Porównaj swoje udziały z naszymi. Linia odczytów z pamięci podręcznej to ponownie czytana rozmowa, a linia zapisów to to, co było nowe: te dwie mówią o twoim rachunku więcej niż linia wyjścia.

Gdzie AgentsRoom to pokazuje

Skrypt daje ci miesiąc. W trakcie pracy AgentsRoom pokazuje te same liczniki dla każdego agenta: plakietkę tokenów w composerze każdej sesji, która robi się czerwona, gdy sesja staje się ciężka, monitor sesji z wejściem, wyjściem, zapisami i odczytami pamięci podręcznej oraz współczynnikiem trafień pamięci podręcznej, a także ślad sesji, który odtwarza sesję tura po turze, żeby pokazać, który przeczytany plik albo wynik narzędzia wypełnił kontekst. Panel zużycia dzieli procent, który raportuje twoja subskrypcja, między twoje projekty i twoich agentów, ważąc każdą sesję tym, ile kosztowałaby według cen API, tak samo jak w tabeli powyżej.

Żadne z tych narzędzi nie daje ci salda tokenów, bo twoja subskrypcja go nie ma. W tej sprawie przeczytaj, ile tokenów zostało ci w Claude. O tym, z jaką szybkością przychodzą te tokeny wyjściowe, przeczytasz w artykule tokeny na sekundę w Claude Code, zmierzone.

Najczęściej zadawane pytania

Co to jest token w Claude?

Jednostka, w której Claude czyta i pisze tekst: kawałek słowa, czasem całe krótkie słowo, czasem pojedynczy znak lub bajt. Według Anthropic rozmiar zależy od modelu i języka: w modelach sprzed Claude 4.7 token miał około 3,5 znaku angielskiego, a Claude 4.7 i nowsze używają nowszego tokenizera, który dla tego samego tekstu daje około 30% więcej tokenów. Wszystko, co robi Claude, jest liczone w tokenach: to, co wysyłasz, to, co odpisuje, i to, co trzyma w pamięci podręcznej między turami.

Ile znaków lub słów ma token Claude?

To zależy od języka i od tekstu. Anthropic podaje około 3,5 znaku angielskiego na token w modelach sprzed Claude 4.7 i około 30% więcej tokenów dla tego samego tekstu w Claude 4.7 i nowszych. Na 296 odpowiedziach w czystym tekście, które nasi agenci napisali po francusku we wrześniu i październiku 2026, token miał 2,3 znaku, czyli około 2,6 tokenu na słowo. Kod, JSON i pisma niełacińskie dają inne proporcje. Dokładną liczbę daje endpoint Anthropic do liczenia tokenów, który przyjmuje tekst i model.

Dlaczego Claude Code zużywa tak dużo tokenów?

Bo każde żądanie wysyła całą rozmowę od nowa: prompt systemowy, definicje narzędzi, CLAUDE.md, każdą wiadomość i każdy dotychczasowy wynik narzędzia. Na naszych 19 668 żądaniach mediana niosła 179 000 tokenów kontekstu, żeby napisać 290 tokenów odpowiedzi, a kontekst rósł z 52 000 tokenów przy pierwszym żądaniu sesji do 237 000 po pięćdziesięciu żądaniach. Pamięć podręczna sprawia, że to ponowne czytanie jest tanie w przeliczeniu na token, ale nadal jest liczone.

Ile tokenów zużywa typowa sesja Claude Code?

Na naszych 380 sesjach liczących co najmniej trzy żądania, zarejestrowanych między 10 września a 9 października 2026: mediana 33 żądań, 27 000 tokenów wyjściowych i łącznie 5,4 miliona przetworzonych tokenów, z czego 5,1 miliona to odczyty z pamięci podręcznej. Połowa sesji mieściła się między 1,5 a 10,7 miliona tokenów. Według cennika API ta mediana sesji kosztowałaby około 4,55 dolara; w subskrypcji Pro lub Max ta sama praca jest zamiast tego odliczana od okna 5-godzinnego i okna tygodniowego.

Czy tokeny myślenia się liczą?

Tak. Tokeny myślenia są częścią output_tokens w każdym bloku usage, a pole thinking_tokens mówi, jaka część wyjścia była myśleniem. W API są rozliczane po cenie wyjścia, a Anthropic wymienia poziom wysiłku wśród rzeczy, które szybciej zużywają limity subskrypcji. W naszym korpusie myślenie stanowiło 29% wszystkiego, co napisały modele.

Czym różnią się tokeny zapisu do pamięci podręcznej od tokenów odczytu z niej?

Zapis do pamięci podręcznej przechowuje część promptu, żeby następne żądanie mogło ją ponownie wykorzystać, i kosztuje więcej niż zwykłe wejście: 1,25 ceny wejścia dla pamięci podręcznej 5-minutowej, 2 razy tyle dla 1-godzinnej. Odczyt z pamięci podręcznej ponownie wykorzystuje tę zapisaną część i kosztuje dużo mniej: 0,1 ceny wejścia w większości modeli, 0,05 w Opus 5.5 i Sonnet 5.5, 0,025 w Fable 5.1. W naszych sesjach odczyty z pamięci podręcznej stanowiły 98% tokenów i 46% kosztu według cennika; zapisy do pamięci podręcznej 2% tokenów i 37% kosztu.