Czym są tokeny w Claude i jak liczyć koszty

Czym są tokeny w Claude?

Token to jednostka tekstu czytanego i zapisanego przez Claude: fragment słowa, wynoszący w przybliżeniu 3.5 znaku angielskiego. Wartość ta pochodzi ze słownika firmy Anthropic. Po uwzględnieniu spacji i interpunkcji, liczba tokenów na jedno słowo jest znacznie wyższa, zatem tysiąc słów tekstu ciągłego to powyżej 1300 tokenów. Kod generuje większe obciążenie w przeliczeniu na linię: nawiasy, operatory, podkreślniki oraz wcięcia dzielą tekst na więcej tokenów na znak niż język angielski. Plik źródłowy liczący kilkaset linii zazwyczaj zajmuje kilka tysięcy tokenów. Przeczytanie pliku o długości 2000 linii przez agenta wiąże się z kosztem rzędu pięciu cyfr, jeszcze przed napisaniem pierwszej linii nowego kodu.

Dwie kwestie dotyczące tokenizerów wprowadzają użytkowników w błąd. Po pierwsze, są one specyficzne dla danego modelu. Według stanu na lipiec 2026, modele Opus 4.7 i nowsze, Sonnet 5 oraz Fable 5 wykorzystują nowszy tokenizer. Generuje on o około 30% więcej tokenów dla tego samego tekstu niż wcześniejsze modele Claude (dokładny wzrost zależy od treści), co zmienia szacowany budżet tokenów, mimo że ceny za pojedynczy token nie wzrosły. Po drugie, tiktoken, biblioteka powszechnie używana w artykułach blogowych, jest tokenizerem OpenAI. Zaniża ona liczbę tokenów dla Claude o około 15–20% w przypadku zwykłego tekstu, a w przypadku kodu różnica jest większa. Jedynym wiarygodnym sposobem liczenia jest endpoint count_tokens, opisany poniżej.

Dlaczego sesja programowania generuje określone koszty

Każda faktura za Claude, niezależnie od tego, czy dotyczy API, czy limitów subskrypcji, opiera się na jednym wskaźniku: liczbie tokenów wejściowych (input) oraz wyjściowych (output). Cennik sugeruje prostotę: określona kwota za milion tokenów wejściowych oraz określona kwota za milion tokenów wyjściowych. Brak w nim jednak informacji, że w sesji programowania opartej na agentach (agentic coding session) koszt tokenów wejściowych rośnie znacznie szybciej, niż można przypuszczać. Wynika to z faktu, że przy każdym kroku cała historia konwersacji jest przesyłana ponownie. Przez piętnaście lat sprzedawałem infrastrukturę rozliczaną według zużycia, a tokeny są pierwszym wskaźnikiem, którego klienci nie potrafią precyzyjnie określić. Niniejszy materiał wyjaśnia: co stanowi input i output w sesji agentycznej, dlaczego pętla ponownego przesyłania danych jest kosztowna, jak prompt caching zmienia kalkulację oraz które parametry faktycznie wpływają na końcowy koszt.

Wszystko jest inputem: co faktycznie liczy licznik

Użytkownicy błędnie zakładają, że płacą za kod generowany przez Claude. W sesji agentycznej koszt ten stanowi jedynie niewielką część. Tokeny wejściowe (input tokens) — o niższej stawce, ale znacznie większym wolumenie — obejmują:

• System prompt. Instrukcje ramowe Claude Code oraz pliki CLAUDE.md i pliki pamięci, ładowane na początku sesji i przesyłane przy każdym zapytaniu.
• Definicje narzędzi (tool definitions). Każdy schemat narzędzia, które agent może wywołać. Każdy połączony serwer MCP zwiększa te stałe koszty — choć Claude Code domyślnie odracza pełne definicje narzędzi MCP, więc do kontekstu trafiają jedynie nazwy narzędzi do momentu ich pierwszego użycia, co zmniejsza, lecz nie eliminuje kosztów.
• Każdy plik odczytany przez agenta. Read pliku źródłowego przesyła jego całą zawartość do kontekstu, gdzie plik pozostaje.
• Każdy wynik działania narzędzia. Wyniki testów, wyjście grep, komunikaty terminala, logi budowania — wszystkie te dane powracają jako tokeny wejściowe. Nieudany zestaw testów generujący 8,000 linii tekstu skutkuje kosztem odpowiadającym małej książce.
• Cała dotychczasowa konwersacja, przesyłana ponownie w każdym kroku. Ten element wymaga osobnego omówienia.

Przyczyny wysokich kosztów przy ponownym przesyłaniu danych

API Claude jest bezstanowe (stateless). Nie przechowuje informacji o sesji między zapytaniami. Podczas 2. tury klient przesyła dane z tury 1, odpowiedź oraz nową wiadomość. Podczas 50. tury przesyłane są dane z tur 1–49 — wszystkie odczytane pliki, wyniki narzędzi oraz diffy — wraz z turą 50. Model przy każdym zapytaniu ponownie przetwarza cały transkrypcja, a każdy ponownie przetworzony token jest rozliczany jako input.

Konsekwencja: koszt pojedynczej tury rośnie liniowo wraz z długością sesji, natomiast całkowity koszt sesji rośnie kwadratowo. Ta sama wiadomość składająca się z jednej linii, która w 3. turze kosztowała pół centa, może kosztować dwadzieścia razy więcej w 60. turze, ponieważ zawiera dane z sześćdziesięciu poprzednich tur. Jest to główna przyczyna większości zgłoszeń dotyczących wysokich rachunków. Nie jest to specyficzna cecha modelu Claude — każdy produkt LLM sprawiający wrażenie stanowego (stateful) jest w rzeczywistości bezstanowym API z pętlą ponownego przesyłania danych (resend loop).

Output: to co widać, plus procesy myślowe

Tokeny wyjściowe (output) są droższe — ich stawka wynosi pięciokrotność stawki za tokeny wejściowe (input) w obecnej ofercie ($5/$25 w Opus 4.8, $3/$15 w Sonnet 5, $1/$5 w Haiku 4.5, stan na lipiec 2026). Output obejmuje wygenerowany przez Claude tekst oraz kod, a także tokeny myślowe (thinking tokens): wewnętrzne rozumowanie modelu przed udzieleniem odpowiedzi. Kluczowe są dwa fakty. Proces myślowy jest rozliczany według stawek za output i obciąża limit max_tokens — odpowiedź API kończy się przy przekroczeniu stop_reason: "max_tokens", co oznacza, że skrócona odpowiedź często wynika z wyczerpania budżetu przez proces myślowy przed wygenerowaniem tekstu. Dodatkowo w obecnych modelach podsumowanie rozumowania może nie być wyświetlane — modele Opus 4.8, Sonnet 5 oraz Fable 5 domyślnie je pomijają — jednak proces myślowy nadal zachodzi i jest fakturowany. Ukryte procesy nie są bezpłatne.

Claude Code domyślnie umożliwia rozszerzone myślenie, ponieważ mierzalnie poprawia to zadania wieloetapowe, a domyślny budżet może wynosić dziesiątki tysięcy tokenów na żądanie. W prostszych zadaniach można ograniczyć ten proces: obniżyć poziom zaangażowania za pomocą /effort lub w /model, albo dostosować ustawienia myślenia w /config. Jest to realny mechanizm kontroli kosztów, a nie przypuszczenie.

Prompt caching zmienia kalkulację kosztów

Prompt caching zapobiega nadmiernym kosztom przy wielokrotnym przesyłaniu danych. API może zapamiętać stały prefiks promptu — prompt systemowy, definicje narzędzi, historię konwersacji — i przy kolejnym zapytaniu obsłużyć go za ułamek ceny. Według stanu na lipiec 2026 r. mnożniki wynoszą: zapis do cache (write) kosztuje 1.25× bazowej stawki za input (2× dla wariantu 1-hour), natomiast odczyt z cache (read) kosztuje 0.1×. Zapisy są płatne wyżej; odczyty są o 90% tańsze. Pojedynczy odczyt pokrywa koszt dopłaty za 5-minutowy zapis.

Claude Code zarządza cache automatycznie. W stabilnej sesji większość danych przesyłanych ponownie pochodzi z cache. Domyślny czas życia cache wynosi five minutes od ostatniego użycia. Jeśli nastąpi przerwa przekraczająca ten czas, cache wygasa. Kolejne zapytanie spowoduje ponowny zapis całego skumulowanego prefiksu w cenie 1.25× zamiast odczytu w cenie 0.1×. W sesji o rozmiarze 150K-tokenów jeden taki "zimny" krok kosztuje więcej niż kilkanaście kroków "ciepłych". Należy przyjąć następującą zasadę: przerwa w pracy może generować wyższe koszty niż ciągłe działanie, ponieważ każda przerwa dłuższa niż TTL zmienia kolejny krok z taniego odczytu w kosztowny zapis. Należy pracować w blokach; nie należy wysyłać pojedynczych wiadomości w odstępach co dziesięć minut w ramach jednej dużej sesji.

W przypadku wywoływania API z poziomu własnej aplikacji na VPS, funkcje te nie są dostępne automatycznie. Częstym błędem jest umieszczanie znaczników czasu lub request ID wewnątrz promptu systemowego. Powoduje to zmianę bajtów prefiksu przy każdym zapytaniu, co de facto wyłącza mechanizm cache. Objawem tego błędu jest wartość usage.cache_read_input_tokens równa zero przy identycznych zapytaniach.

Wzór wraz z przykładem obliczeniowym

Należy ignorować twierdzenia o stałym koszcie sesji wynoszącym "$X". Koszty sesji różnią się od siebie o dwa rzędy wielkości. Obowiązuje poniższy wzór:

turn cost = (uncached input      x base input price)
          + (cache writes        x 1.25 x base input price)
          + (cache reads         x 0.10 x base input price)
          + (output incl. thinking x output price)

session cost = sum over all turns

Przykład obliczeniowy dla modelu Claude Opus 4.8. Według stanu na lipiec 2026 r. koszt wynosi $5 za milion tokenów wejściowych oraz $25 za milion tokenów wyjściowych. Jeden krok w środku sesji o łącznym kontekście 80,000 tokenów: 75,000 odczytanych z cache, 3,000 nowo zapisanych, 2,000 nowych tokenów wejściowych spoza cache, 1,500 tokenów wyjściowych (w tym tokeny procesu myślowego).

• Odczyty z cache: 75,000 × $0.50/M = $0.0375
• Zapisy do cache: 3,000 × $6.25/M = $0.019
• Wejście spoza cache: 2,000 × $5/M = $0.010
• Wyjście: 1,500 × $25/M = $0.0375

Koszt jednego kroku wynosi około $0.10. Pięćdziesiąt takich kroków to około $5. Koszt tego samego kroku po wygaśnięciu cache: pełne 80,000 tokenów zapisanych ponownie przy stawce $6.25/M daje $0.50 przed doliczeniem wyjścia. Jest to około pięć razy więcej niż koszt pełnego kroku w cache przy identycznej pracy. Ta różnica obrazuje znaczenie mechanizmu cache.

Dane służą do kalibracji, a nie do precyzyjnego prognozowania. Według danych Anthropic dla wdrożeń Claude Code w sektorze enterprise (stan na lipiec 2026 r.), średni koszt wynosi około $13 na developera dziennie ($150–250 miesięcznie), przy czym 90% użytkowników generuje koszty poniżej $30 dziennie. Koszt końcowy zależy od wybranego modelu, higieny sesji oraz wielkości bazy kodu, co uzasadnia znaczenie poniższych parametrów.

Podgląd własnego zużycia

W Claude Code służy do tego polecenie /usage (/cost nadal działa — jest to alias). Blok Session na górze wyświetla statystyki tokenów oraz lokalnie obliczoną szacowaną kwotę kosztów dla bieżącej sesji; w planach subskrypcyjnych ten sam ekran pokazuje paski limitów planu oraz zestawienie zużycia z podziałem na skills, subagents, plugins oraz poszczególne serwery MCP. W przypadku rozliczeń API jedynym wiarygodnym źródłem danych jest strona zużycia w Claude Console — wartość w CLI jest jedynie szacunkiem. Polecenie /context generuje kolorową siatkę przedstawiającą elementy zajmujące okno kontekstowe — system prompt, tools, definicje MCP, pliki oraz historię — i jest najszybszą metodą na wykrycie przeładowanego CLAUDE.md lub nadmiernie komunikatywnego serwera MCP; należy użyć flagi all, aby uzyskać pełne zestawienie dla każdego elementu.

W przypadku API każda odpowiedź zawiera dokładne informacje o operacji:

response = client.messages.create(model="claude-sonnet-5", max_tokens=2048,
                                  messages=messages)
u = response.usage
total_prompt = u.input_tokens + u.cache_creation_input_tokens + u.cache_read_input_tokens
print(f"uncached={u.input_tokens} written={u.cache_creation_input_tokens} "
      f"read={u.cache_read_input_tokens} output={u.output_tokens}")

Należy pamiętać, że input_tokens to tylko pozostałość spoza pamięci cache — rzeczywisty rozmiar promptu to suma wszystkich trzech pól wejściowych. Agent działający przez godzinę, który wykazuje input_tokens: 4000, nie jest tani; pozostałe 200,000 tokenów zostało pobranych z cache. Aby oszacować zużycie przed wysłaniem żądania, należy użyć endpointu do liczenia tokenów — wywołanie jest bezpłatne, posiada własny limit zapytań (rate limit) i liczy tokeny za pomocą tokenizera wskazanego modelu (wynik należy traktować jako przybliżenie; rozliczenia opierają się na rzeczywistym zapytaniu):

count = client.messages.count_tokens(model="claude-sonnet-5",
                                     messages=[{"role": "user", "content": big_file}])
print(count.input_tokens)

Nigdy nie używaj tiktoken, ze względu na powyższy powód.

Plany subskrypcyjne a model pay-as-go

Mechanizmy opisane w tym przewodniku są identyczne w każdym przypadku; różni się jedynie sposób rozliczenia. W przypadku klucza API, Anthropic nalicza opłaty pay-as-go za każdy token według podanych stawek — każda wymieniona powyżej wartość to realny koszt. W ramach subskrypcji Claude (Pro, Max, Team, Enterprise) zużycie Claude Code jest rozliczane z limitu zawartego w planie: od lipca 2026 roku jest to pięciogodzinne okno sesji oraz okno tygodniowe, współdzielone przez modele oraz czat claude.ai, a kwota /usage dolarów ma charakter informacyjny, a nie rozliczeniowy. Po wyczerpaniu limitu wyświetli się komunikat "You've hit your session limit" lub "You've hit your weekly limit" wraz z czasem resetu — zmiana modelu za pomocą /model nie przywróci dostępu, ponieważ limity są współdzielone między modelami. Plany mogą opcjonalnie umożliwiać korzystanie z kredytów zużycia, zarządzanych przez /usage-credits, w celu dokupienia limitu po przekroczeniu progu. Nie podaję limitów planów: są to najbardziej zmienne wartości w tym temacie, dlatego należy sprawdzać claude.com/pricing oraz własne paski /usage. Mechanika tokenów nadal obowiązuje w subskrypcji — nieefektywna sesja zużywa limit w taki sam sposób, w jaki zużywałaby środki pieniężne. W kwestii subskrypcji należy sprawdzić który plan Claude pasuje do Twojego zużycia.

Skuteczne metody optymalizacji

• Ogranicz zakres danych odczytywanych przez agenta. Polecenie "Fix the validation bug in auth.py" odczytuje jeden plik; "improve this codebase" odczytuje czterdzieści. Należy utrzymywać CLAUDE.md w formie minimalistycznej — dane te są ładowane w każdej sesji, dlatego należy ograniczyć je do niezbędnego minimum — a instrukcje specyficzne dla danego procesu należy przenieść do umiejętności (skills) ładowanych na żądanie.
• Stosuj zwięzłość i separację. Należy stosować /clear między niezwiązanymi zadaniami — nieaktualny kontekst jest przesyłany ponownie i ponownie fakturowany przy każdej kolejnej wiadomości. W ramach jednego długiego zadania /compact Focus on the failing tests and the diff podsumowuje historię, co zapobiega wykładniczemu wzrostowi kosztów.
• Dobieraj odpowiedni model. Sonnet obsługuje większość zadań programistycznych w cenie 2 $/10 $ za milion tokenów według stawek wstępnych z lipca 2026 r. (cena standardowa 3 $/15 $, w porównaniu do Opus za 5 $/25), natomiast Haiku w cenie 1 $/5 jest odpowiednim narzędziem do mechanicznych zadań subagentów, takich jak analiza logów. /model umożliwia przełączanie modeli w trakcie sesji.
• Filtruj nadmiarowe dane wyjściowe. Użycie mechanizmu grep, który ogranicza wynik testu do samych błędów przed przesłaniem go do Claude, redukuje 20 000 tokenów wyniku narzędzia do 300 tokenów; proces ten powtarza się przy każdym kolejnym przesłaniu tej samej tury.
• Przetwarzaj w trybie wsadowym zadania nieinteraktywne. W przypadku własnych potoków API — klasyfikacji, masowego przeglądu lub zadań nocnych — Batches API oferuje te same modele z 50% zniżką w zamian za asynchroniczne dostarczanie wyników.
• Uwzględniaj czas działania pamięci cache. Pracuj w ciągłych blokach czasowych. Odizolowana sesja Claude Code w tmux na VPS nie generuje kosztów podczas bezczynności — tokeny są zużywane tylko podczas trwania tury — jednak bezczynność powoduje utratę rozgrzanego cache, co skutkuje koniecznością ponownego zapisu danych przy kolejnej turze.

FAQ

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

Liczba ta nie jest stała. Pojedyncza tura w trakcie sesji zazwyczaj obejmuje dziesiątki tysięcy tokenów promptu po skumulowaniu plików i historii. Cała sesja może obejmować miliony tokenów, z czego większość pochodzi z cache przy stawce stanowiącej 1/10 stawki podstawowej. Według danych Anthropic dla przedsiębiorstw z lipca 2026 roku, średni koszt wynosi około $13 na developera dziennie, przy czym 90% użytkowników generuje koszty poniżej $30. Uruchom /usage we własnej sesji; pięć minut obserwacji dostarczy dokładniejszych danych niż jakiekolwiek publikowane średnie.

Czy tokeny myślowe (thinking tokens) generują koszty, nawet jeśli nie są widoczne?

Tak. Tokeny myślowe są rozliczane jako tokeny wyjściowe (output tokens) według wyższej stawki i wliczane do max_tokens. Obecne modele naliczają opłaty nawet wtedy, gdy interfejs nie wyświetla podsumowania rozumowania. Jeśli odpowiedź zostaje przerwana przez stop_reason: "max_tokens" przed zakończeniem widocznej odpowiedzi, prawdopodobnie wyczerpano budżet na tokeny myślowe. W Claude Code można obniżyć poziom wysiłku za pomocą /effort dla zadań niewymagających głębokiego rozumowania.

Dlaczego długa sesja Claude Code staje się coraz droższa w przeliczeniu na wiadomość?

Wynika to z bezstanowości (stateless) API: każda tura ponownie przesyła całą konwersację — wszystkie odczytane pliki, wyniki narzędzi i poprzednie wymiany — jako płatny input. Zatem tura 50 zawiera w sobie dane z tur od 1 do 49. Prompt caching pozwala na obsługę powtarzającego się prefiksu przy koszcie około 1/10 podstawowej ceny inputu, jednak sam prefiks stale rośnie. Przekroczenie czasu TTL cache powoduje, że kolejna tura jest rozliczana jako pełna re-write. Komenda /compact skraca historię; /clear ją resetuje.

Jak sprawdzić zużycie tokenów i koszty w Claude?

W Claude Code komenda /usage wyświetla statystyki tokenów sesji, lokalne szacowanie kosztów oraz paski limitów planu dla subskrypcji (/cost to alias); /context pokazuje zawartość okna. W celu uzyskania wiarygodnych danych rozliczeniowych API należy użyć strony usage w Claude Console. Własny kod powinien odczytywać response.usage — suma input_tokens, cache_creation_input_tokens oraz cache_read_input_tokens określa rzeczywisty rozmiar promptu — a szacowanie powinno odbywać się za pomocą endpointu count_tokens, a nie tiktoken.