# Ile kosztowali agenci? ccusage, /usage, monitory i budżety w bramkach

URL: https://developertoolkit.ai/pl/ecosystem/observability/agent-cost-tracking/
Description: Jak śledzić koszty Claude Code, Codeksa i Cursora: /usage, ccusage, monitory i budżety zespołów w LiteLLM, Cloudflare AI Gateway lub claude gateway.

Śledzenie kosztów agentów działa na trzech poziomach. Wbudowane polecenia (`/usage` w Claude Code, `/status` i `/usage` w Codeksie) pokazują jedną sesję albo plan. Lokalne narzędzia, takie jak ccusage, sumują koszt jednej maszyny. Ograniczenie wydatków zespołu wymaga budżetów na ścieżce żądań: limitów planu lub Console albo bramki z budżetami na klucz, na przykład LiteLLM albo Claude apps gateway od Anthropic.

Ktoś z zespołu puścił w weekend trzech agentów równolegle, faktura za API skoczyła, a dział finansów chce wiedzieć, który zespół ile wydał. Masz licencje, kilka kluczy API i zero liczb w podziale na zespoły. Ta strona jest dla **programisty**, który chce dziś zobaczyć własne wydatki, i dla **tech leada**, który musi nałożyć zespołowi budżet, nie spowalniając go.

## Co daje ci ta konfiguracja śledzenia kosztów

- **Mapę tego, które narzędzie odpowiada na które pytanie o koszty**, sprawdzoną 2026-09-26 na Claude Code 2.1.283, Codex CLI 0.157.1 i ccusage 20.0.24.
- **Własny koszt miesiąca jednym poleceniem** i to, co ta kwota znaczy przy subskrypcji, a co przy kluczu API.
- **Pasek statusu na żywo i monitor 5-godzinnego okna**, żeby długi przebieg agenta cię nie zaskoczył.
- **Budżet zespołu na kluczach wirtualnych LiteLLM** dla Claude Code i Codeksa oraz dwie alternatywy.
- **Miesięczny raport kosztów w dziesięć minut**, trzy prompty do skopiowania i pułapkę rozliczeniową, przez którą bramka nic nie liczy.

Ta strona opisuje narzędzia. Politykę organizacji (właściciel budżetu, przypisanie do centrów kosztów, przekroczenia) znajdziesz na stronie o [zarządzaniu kosztami użycia AI](/pl/org/cost-governance/), a metodę przeliczania wydatków na koszt zaakceptowanej zmiany na [stronie o ekonomii](/pl/strategy/economics/).

## Które narzędzie odpowiada na które pytanie o koszty?

Zacznij od pytania. Każdy wiersz sprawdzono 2026-09-26 w zainstalowanych CLI, w dokumentacji Claude Code o [kosztach](https://code.claude.com/docs/en/costs.md) i [limitach wydatków w bramce](https://code.claude.com/docs/en/claude-apps-gateway-spend-limits.md), w kodzie Codeksa pod tagiem `rust-v0.157.1` oraz w repozytorium GitHub każdego projektu.

| Pytanie | Narzędzie | Zakres | Czy ogranicza wydatki? |
| --- | --- | --- | --- |
| Ile kosztowała ta sesja i jak blisko jestem limitu planu? | Claude Code `/usage`; Codex `/status` i `/usage` | Jedna sesja, jeden plan | Nie |
| Ile wydałem w tym miesiącu na wszystkich agentów na laptopie? | ccusage | Jedna maszyna, 18 agentów | Nie |
| Kiedy skończy mi się 5-godzinne okno? | `ccusage blocks --active`, Claude-Code-Usage-Monitor | Jedna maszyna, Claude Code | Nie (tylko ostrzega) |
| Ile tokenów na repozytorium, także przez wiele worktree? | tokscale | Jedna maszyna, wielu agentów | Nie |
| Ile wydał każdy programista, prawie w czasie rzeczywistym? | OpenTelemetry w Claude Code, raporty wydatków dostawców | Cały zespół | Nie |
| Czy mogę zatrzymać jeden nienadzorowany przebieg w CI, zanim przepali budżet? | `claude -p --max-budget-usd` | Jeden przebieg headless | Tak, na przebieg |
| Czy mogę dać każdemu zespołowi miesięczny budżet? | Klucze wirtualne LiteLLM, Claude apps gateway, limity w Console lub w planie; Cloudflare AI Gateway śledzi wydatki na bramkę, a ogranicza tylko liczbę żądań | Każde żądanie przez bramkę lub konto | Tak |

Popularność na dzień 2026-09-26, według GitHuba i rejestrów pakietów: [ccusage](https://github.com/ccusage/ccusage) ma 18,7 tys. gwiazdek (npm 20.0.24), [LiteLLM](https://github.com/BerriAI/litellm) 59,6 tys. (PyPI 1.102.1), [bramka Portkey](https://github.com/Portkey-AI/gateway) 13,1 tys. (npm 1.15.2), [Claude-Code-Usage-Monitor](https://github.com/Maciek-roboblog/Claude-Code-Usage-Monitor) 8,7 tys. (PyPI `claude-monitor` 4.0.0), a [tokscale](https://github.com/junhoyeo/tokscale) 5,5 tys. (npm 4.17.0). Żadne nie jest wtyczką ani serwerem MCP, więc żadne nie dokłada tokenów do kontekstu agenta.

Punkt odniesienia przed ustaleniem budżetów: strona Anthropic o kosztach (sprawdzona 2026-09-26) podaje, że we wdrożeniach firmowych Claude Code kosztuje średnio „around $13 per developer per active day and $150-250 per developer per month”, a 90% użytkowników mieści się poniżej 30 USD na aktywny dzień. To liczba dostawcy i dotyczy tylko Claude Code. Zanim ustalisz limit na jej podstawie, zmierz własny zespół przez miesiąc.

## Zobacz własne wydatki w dwie minuty

Najszybsza odpowiedź to wbudowane polecenie, a dla całego miesiąca ccusage.

**Claude Code**

    Wpisz `/usage` w sesji. Blok Session pokazuje łączny koszt sesji, czas pracy API i czas zegarowy, zmiany w kodzie oraz koszt w podziale na modele.

    Znaczenie kwoty zależy od tego, jak się logujesz:

    - **Pro, Max albo licencja Team lub Enterprise:** koszt sesji to lokalna wycena według cennika; dla planów Pro i Max strona kosztów Anthropic pisze, że „isn't relevant for billing purposes”. Liczą się paski zużycia planu na tym samym ekranie, z ostatnim zużyciem przypisanym do umiejętności (skills), subagentów, wtyczek i serwerów MCP (`d` i `w` przełączają między 24 godzinami a 7 dniami).
    - **Klucz API albo dostawca chmurowy:** koszt sesji szacuje rzeczywiste wydatki za tokeny; wiążąca kwota jest na stronie zużycia w Console albo w konsoli rozliczeń chmury.

    Od v2.1.211 sumy zerują się po `/clear`. Od v2.1.251 wiersz `Prompt cache (main)` pokazuje udział trafień cache w tokenach wejściowych i liczbę chybień, czyli typowe źródło niewyjaśnionych wydatków w długich sesjach.

**Codex**

    Codex 0.157.1 ma dwa polecenia. `/status` pokazuje „current session configuration and token usage”, a `/usage` pozwala „view account usage or use a usage limit reset” (opisy z `slash_command.rs` pod tagiem `rust-v0.157.1`). W planie ChatGPT zużycie liczy się względem 5-godzinnych i tygodniowych przydziałów, a nie kwoty na fakturze.

    Szacunek w dolarach w rozbiciu na dni da ci ccusage, które czyta lokalne logi Codeksa:

    ```bash
    npx ccusage@latest codex daily      # also: monthly, session
    ```

    Osobny pakiet `@ccusage/codex` jest przestarzały.

**Cursor**

    2026-09-26 nie udało się potwierdzić polecenia pokazującego koszt sesji w Cursorze. Liczby dają dwie drogi:

    - **tokscale** pobiera zużycie z API eksportu zużycia Cursora, a nie z plików lokalnych. Najpierw zaloguj się w aplikacji desktopowej Cursora:

      ```bash
      npx tokscale@latest cursor login --name work   # reuses the desktop app's session
      npx tokscale@latest cursor sync --json         # caches the export under ~/.config/tokscale/cursor-cache/
      npx tokscale@latest models --light --client cursor --month   # print a table of Cursor usage
      ```

      Wiersze Cursora nie mają workspace, więc trafiają do `Unknown workspace`.
    - **Dashboard zespołu i Analytics API Cursora** (źródła wtórne) pokazują zużycie administratorom planów Teams i Enterprise; zanim zbudujesz na nich raport, sprawdź, co udostępnia twój plan.

    ccusage 20.0.24 nie wymienia Cursora wśród swoich 18 źródeł.

### Raport miesiąca dla wszystkich agentów w ccusage

ccusage czyta logi zużycia, które agenci zapisują na twojej maszynie, i wycenia je. Nie ma serwera ani rejestracji. W terminalu:

```bash
npx ccusage@latest monthly
```

Raport zaczyna się od wiersza `Detected:` z nazwami znalezionych agentów (na przykład `Detected: Claude, Codex`), potem jest wiersz na miesiąc z podwierszem na agenta. Kolumny: `Month`, `Agent`, `Models`, `Input`, `Output`, `Cache Create`, `Cache Read`, `Total Tokens` i `Cost (USD)`. Na większości maszyn intensywnie używających agentów `Cache Read` jest zdecydowanie największą kolumną tokenów. Dlatego długa sesja kosztuje więcej, niż sugerują same prompty.

**ccusage wycenia tokeny według cennika, a nie twojej faktury**

Przy subskrypcji kolumna `Cost (USD)` pokazuje, ile te same tokeny kosztowałyby w API. Przydaje się do porównania ceny planu z rozliczeniem za tokeny i do wychwycenia agenta, który się rozpędził, ale to nie jest kwota, którą zapłaciłeś. Dlatego ccusage potrafi pokazać setki dolarów przy planie za 100 USD. Przy kluczu API jest przybliżeniem rachunku przed ewentualnym rabatem z umowy.

Polecenia, których użyjesz najczęściej, sprawdzone w `ccusage --help` 20.0.24:

```bash
npx ccusage@latest                                   # default: daily report, all detected agents
npx ccusage@latest monthly --last 3                  # the last three months only
npx ccusage@latest claude daily --instances          # Claude Code, split by project
npx ccusage@latest claude monthly --breakdown        # Claude Code, split by model
npx ccusage@latest blocks --active                   # current 5-hour block with a projection
npx ccusage@latest monthly --since 2026-09-01 --json > sept.json
```

Zbiorczy raport `monthly` nie ma flagi `--breakdown` (mają ją podpolecenia agentów i `blocks`); rozbicie na agentów w zbiorczym JSON-ie dodaje `--by-agent`.

### Jak śledzić wydatki agentów na żywo?

Dla Claude Code ccusage ma tryb paska statusu (w wersji 20.0.24 oznaczony jako beta). Dodaj go do `~/.claude/settings.json`:

```json title="~/.claude/settings.json"
{
  "statusLine": { "type": "command", "command": "npx -y ccusage@20.0.24 statusline" }
}
```

Przypnij wersję: pasek stanu uruchamia się przy każdym odświeżeniu, a nieprzypięte `npx -y ccusage` pobierałoby to, co akurat trafi do npm. Działa lokalnie i nie zużywa kontekstu; `--cost-source cc` pokazuje koszt sesji wyliczony przez samo Claude Code zamiast wyliczenia ccusage.

Dwie alternatywy, obie lokalne:

```bash
uv tool install claude-monitor                 # PyPI package; npm "claude-monitor" is a different project
claude-monitor --plan pro                      # live TUI of token burn against your plan window

npx tokscale@latest models --light --group-by workspace,model --merge-worktrees --month
```

Trzymaj `claude-monitor` w podzielonym panelu podczas długiego przebiegu, żeby widzieć, kiedy skończy się 5-godzinne okno. Polecenie tokscale daje jeden wiersz na repozytorium nawet przy równoległych worktree, czego nie potrafi ani ccusage, ani `/usage`.

### Ogranicz jeden nienadzorowany przebieg

Dla zadania headless w CI Claude Code 2.1.283 ma flagę `--max-budget-usd <amount>`: „Maximum dollar amount to spend on API calls (only works with --print)”.

```bash
claude -p "Fix the failing test in packages/billing and run the suite" \
  --max-budget-usd 5 \
  --permission-mode acceptEdits \
  --allowedTools "Bash(npm test *)"
```

`claude -p` startuje w trybie uprawnień Manual (od v2.1.285 w trybie auto u zewnętrznych dostawców lub z wyłączoną telemetrią), więc bez `--permission-mode` i `--allowedTools` przebieg startujący w trybie Manual nie może ani edytować plików, ani uruchomić testów; resztę konfiguracji opisuje strona [agenci headless w CI](/pl/ecosystem/agent-tools/headless-agents-ci/). Budżet ogranicza jeden przebieg, a nie zespół, i liczy ten sam szacunek według cennika co `/usage`. W `codex exec --help` 0.157.1 nie ma odpowiednika.

## Wybierz bramkę dla budżetów zespołów

Lokalne narzędzia raportują, ale nikogo nie zatrzymają. Limit wymaga, żeby każde żądanie przeszło przez coś, co policzy wydatki przed przekazaniem go dalej. Wybierz pierwszy pasujący wiersz.

| Korzystasz z | Użyj | Dlaczego | Uważaj na |
| --- | --- | --- | --- |
| Licencje Claude Team lub Enterprise | Wbudowanych mechanizmów planu: przydział na licencję, kredyty użycia (usage credits) i limity wydatków w **Admin settings > Usage** | Zero infrastruktury; raport wydatków na użytkownika z eksportem CSV | Zużycie w ramach przydziału licencji nie jest liczone w dolarach |
| API Anthropic przez Console | Limitów wydatków workspace'u w Console | Wbudowane; Claude Code dostaje własny workspace | Logowania przez Console trafiają do jednego workspace'u „Claude Code”; limity na zespół wymagają kluczy API zespołów wydanych z osobnych workspace'ów |
| Claude Code na Bedrocku, Claude Platform on AWS, Google Cloud lub Foundry | **Claude apps gateway** (`claude gateway --config gateway.yaml`) | Limity na użytkownika, grupę i organizację: dzienne, tygodniowe lub miesięczne; SSO; wbudowana w binarkę `claude` | Wymaga Postgresa; gdy baza nie odpowiada, domyślnie przepuszcza żądania. Przyjmuje też API Anthropic jako upstream, więc firmy korzystające z Console mogą przez nią ustawić limity na użytkownika z SSO |
| Wielu dostawców, Claude Code i Codex razem | **Proxy LiteLLM** | Klucze wirtualne na programistę, budżety na klucz i na zespół, jeden rachunek dla wielu dostawców | Hostujesz sam; przypnij wersję (patrz krok 1 niżej) |
| Cloudflare już stoi przed twoim ruchem | **Cloudflare AI Gateway** | Usługa zarządzana; logi, cache, limity żądań i wydatki na bramkę | Raportuje wydatki na bramkę; limitu kwotowego nie zweryfikowano |
| Bramka także dla własnych funkcji LLM | Bramki Portkey (`npx @portkey-ai/gateway`, port 8787) | Routing, mechanizmy awaryjne (fallbacki), zabezpieczenia (guardrails) | Konfiguracja dla Claude Code niezweryfikowana (2026-09-26) |

Nie zaczynaj nowych wdrożeń na Helicone: od marca 2026, po przejęciu przez Mintlify, jest w trybie utrzymania (źródło wtórne: prasa i blogi).

**Pułapka rozliczeniowa ANTHROPIC_BASE_URL**

Samo ustawienie `ANTHROPIC_BASE_URL` nie przenosi rozliczeń do bramki. Jeśli programista jest zalogowany przez claude.ai, żądania przechodzą przez bramkę, ale aktywnym poświadczeniem pozostaje logowanie claude.ai: obowiązuje rozliczenie subskrypcji, a budżet na klucz nie ma czego naliczyć. Na rozliczenie za tokeny przełącza dopiero poświadczenie bramki: `ANTHROPIC_AUTH_TOKEN` (wysyłany jako `Authorization: Bearer`), `ANTHROPIC_API_KEY` (wysyłany jako `x-api-key`) albo `apiKeyHelper`. `/status` pokazuje aktywny adres bazowy i źródło poświadczenia.

## Ustaw budżet zespołu na kluczach wirtualnych LiteLLM

Poniższy proces daje zespołowi płatności 400 USD miesięcznie, każdemu jego programiście osobisty limit 150 USD i kończy się miesięcznym raportem. Używa modeli Anthropic za LiteLLM; te same klucze działają w Codeksie przez dostawcę w formacie OpenAI. Wariant z lokalnym modelem bez dostępu do internetu opisuje strona o [bramkach i modelach lokalnych](/pl/ecosystem/agent-tools/gateways-local-models/).

1. **Zainstaluj przypiętą wersję LiteLLM.** 2026-03-24 wersje 1.82.7 i 1.82.8 pakietu `litellm` w PyPI były złośliwymi programami kradnącymi poświadczenia; PyPI usunęło obie, a opiekunowie śledzą incydent w `BerriAI/litellm#24518`. Nigdy nie instaluj nieprzypiętego proxy na hoście, który trzyma klucze dostawców:

    ```bash
    uv tool install 'litellm[proxy]==1.102.1'
    ```

    Dla obrazu serwera skompiluj plik wymagań z hashami i instaluj przez `pip --require-hashes`. Pakiet `litellm` w npm to niezwiązany port w JavaScripcie.

2. **Opisz modele i bazę danych.** Klucze wirtualne i budżety wymagają Postgresa (`DATABASE_URL`) i klucza głównego. Klucz dostawcy i klucz główny pochodzą z twojego magazynu sekretów:

    ```yaml title="litellm-config.yaml"
    model_list:
      - model_name: claude-opus-5-5
        litellm_params:
          model: anthropic/claude-opus-5-5
          api_key: os.environ/ANTHROPIC_API_KEY
          input_cost_per_token: 0.000004         # $4 per million input tokens
          output_cost_per_token: 0.00002         # $20 per million output tokens
          cache_read_input_token_cost: 0.0000002 # $0.20 per million cached input tokens
      - model_name: claude-haiku-4-5
        litellm_params:
          model: anthropic/claude-haiku-4-5
          api_key: os.environ/ANTHROPIC_API_KEY

    general_settings:
      master_key: os.environ/LITELLM_MASTER_KEY
      database_url: os.environ/DATABASE_URL
    ```

    ```bash
    litellm --config litellm-config.yaml    # listens on port 4000
    ```

    Wpis Opus 5.5 ma własne ceny katalogowe z [przeglądu modeli](/pl/ecosystem/models/), bo mapa cen dołączona do LiteLLM 1.102.1 powstała przed premierą Opus 5.5. Bez nich proxy, które nie może pobrać zdalnej mapy (host z ograniczonym ruchem wychodzącym albo `LITELLM_LOCAL_MODEL_COST_MAP=True`), zapisze 0 USD za każde żądanie do Opus 5.5.

    Zakończ TLS przed proxy, bo klucze podróżują w nagłówkach; przykłady używają adresu `https://llm-gw.internal`. Wpis Haiku obsługuje pracę Claude Code w tle (podsumowania rozmów i podobne), którą krok 5 do niego przypina. Dodaj każdy model, który programiści wybierają przez `/model`; modele spoza listy zwracają błąd.

3. **Utwórz zespół z budżetem.** `max_budget` jest w dolarach amerykańskich, a `budget_duration` określa, kiedy się zeruje:

    ```bash
    curl -sS https://llm-gw.internal/team/new \
      -H "Authorization: Bearer $LITELLM_MASTER_KEY" \
      -H "Content-Type: application/json" \
      -d '{"team_alias": "payments", "max_budget": 400, "soft_budget": 300, "budget_duration": "1mo"}'
    ```

    Odpowiedź zawiera `team_id`; zachowaj go. `soft_budget` niczego nie blokuje; tylko wyzwala alerty Slack lub e-mail w LiteLLM, jeśli je skonfigurowałeś. W LiteLLM 1.102.1 `1mo` (a także `30d`) zeruje budżet o północy pierwszego dnia miesiąca, w UTC, chyba że w `litellm_settings` ustawisz `timezone` na strefę, w której dział finansów zamyka miesiąc.

4. **Wydaj jeden klucz na programistę, w ramach zespołu.** Osobny limit klucza nie pozwoli, żeby weekendowa flota jednej osoby zjadła budżet całego zespołu:

    ```bash
    curl -sS https://llm-gw.internal/key/generate \
      -H "Authorization: Bearer $LITELLM_MASTER_KEY" \
      -H "Content-Type: application/json" \
      -d '{"team_id": "TEAM_ID", "key_alias": "payments-anna", "max_budget": 150, "budget_duration": "1mo", "models": ["claude-opus-5-5", "claude-haiku-4-5"]}'
    ```

    `TEAM_ID` to wartość z kroku 3. Przekaż zwrócony klucz programiście przez menedżer sekretów, nigdy przez czat. Gdy klucz albo jego zespół przekroczy `max_budget`, LiteLLM odrzuca kolejne żądania z HTTP 429 (`budget_exceeded`) do końca okresu.

5. **Skieruj agentów na bramkę.**

      **Claude Code**

        Wpisz adres bazowy do ustawień zarządzanych, żeby nikt o nim nie zapomniał, a klucz niech każdy programista podaje sam:

        ```json title="Managed settings: env block"
        {
          "env": {
            "ANTHROPIC_BASE_URL": "https://llm-gw.internal",
            "ANTHROPIC_DEFAULT_HAIKU_MODEL": "claude-haiku-4-5"
          }
        }
        ```

        Każdy programista eksportuje `ANTHROPIC_AUTH_TOKEN` ze swojego magazynu sekretów albo konfigurujesz `apiKeyHelper`, który czyta klucz z sejfu. Bez takiego poświadczenia działa opisana wyżej pułapka. Ustawienia zarządzane opisuje strona o [polityce zarządzanej](/pl/org/managed-policy/).

      **Codex**

        Dodaj dostawcę w `~/.codex/config.toml` i wybierz go:

        ```toml title="~/.codex/config.toml"
        model_provider = "litellm"

        [model_providers.litellm]
        name = "LiteLLM"
        base_url = "https://llm-gw.internal/v1"
        env_key = "LITELLM_API_KEY"
        wire_api = "responses"
        ```

        `env_key` to nazwa zmiennej środowiskowej z kluczem wirtualnym programisty. Codex korzysta z Responses API, więc bramka musi obsługiwać `/v1/responses` dla modeli z listy. Dodaj modele OpenAI, których używa zespół, do `model_list` z kroku 2, a potem uruchom jedno krótkie zadanie jako test dymny.

      **Cursor**

        2026-09-26 nie znaleźliśmy potwierdzonego sposobu, żeby puścić agenta Cursora przez twoją bramkę. Wydatki z dashboardu zespołu w Cursorze (źródło wtórne) dopisuj do miesięcznego raportu ręcznie, jako osobne źródło.

6. **Udowodnij, że budżet liczy, zanim ktoś zacznie na nim polegać.** Na jednym laptopie uruchom nową sesję, wpisz `/status` i sprawdź, że adres bazowy to bramka, a źródłem poświadczenia jest zmienna środowiskowa, a nie logowanie przez claude.ai. Wyślij jeden prompt. Potem odczytaj wydatki klucza:

    ```bash
    curl -sS "https://llm-gw.internal/key/info?key=$(printf %s "$DEVELOPER_KEY" | sha256sum | cut -d' ' -f1)" \
      -H "Authorization: Bearer $LITELLM_MASTER_KEY"
    ```

    Polecenie wysyła skrót SHA-256 klucza z kroku 4 (LiteLLM 1.102.1 go przyjmuje), więc surowy klucz nie trafia do adresów URL ani logów. Wydatki muszą być większe od zera i zbliżone do kosztu sesji w `/usage`. Jeśli wynoszą zero, LiteLLM nie zna ceny tego modelu: dodaj do wpisu modelu `input_cost_per_token` i `output_cost_per_token`, biorąc stawki z [przeglądu modeli](/pl/ecosystem/models/). Na koniec ustaw kluczowi testowemu budżet 0,01 USD i sprawdź, że następne żądanie zostanie odrzucone.

7. **Raportuj co miesiąc.** Pierwszego dnia roboczego tech lead pobiera budżet i wydatki każdego zespołu przez `GET /team/info?team_id=TEAM_ID` i zestawia je z fakturą dostawcy; poniższy prompt to automatyzuje.

### Ruch przez Cloudflare AI Gateway albo limity w Claude apps gateway

**Cloudflare AI Gateway** nie wymaga serwera. Strona integracji Cloudflare z Claude Code (sprawdzona 2026-09-26) używa trzech zmiennych; token czytaj z magazynu sekretów:

```bash
export ANTHROPIC_BASE_URL="https://gateway.ai.cloudflare.com/v1/$CF_ACCOUNT_ID/$CF_GATEWAY_ID/anthropic"
export ANTHROPIC_API_KEY="$CF_AIG_TOKEN"
export ANTHROPIC_CUSTOM_HEADERS="cf-aig-authorization: Bearer $CF_AIG_TOKEN"
claude
```

Bramka musi mieć włączone uwierzytelnianie, a token potrzebuje uprawnienia `Run`; poświadczenie Anthropic pochodzi z kluczy zapisanych w Cloudflare, z Unified Billing albo z twojego klucza. Utwórz jedną bramkę na zespół, żeby widzieć wydatki zespołów. Sprawdzone źródła pokazują raportowanie wydatków i limity żądań, ale nie limit kwotowy, więc budżety egzekwuj gdzie indziej.

**Claude apps gateway** ustawia limity przez swoje API administracyjne, gdy włączysz blok `admin:` (z kluczem zapisu) w `gateway.yaml`; kwoty to ciągi całkowitych centów amerykańskich, więc `"40000"` oznacza 400 USD:

```bash
curl -sS https://claude-gateway.internal.example.com/v1/organizations/spend_limits \
  -H "x-api-key: $GATEWAY_ADMIN_WRITE_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scope": {"type": "rbac_group", "rbac_group_id": "payments"}, "amount": "40000", "period": "monthly"}'
```

Limit grupy to domyślny limit na osobę, który dziedziczy każdy członek grupy, a nie wspólna pula; limity zerują się na granicach kalendarza UTC. Programista ponad limitem dostaje `429` z `billing_error` i czasem zerowania; Claude Code od v2.1.225 ostrzega przy 75% i 95%, a od v2.1.251 dodaje pasek **Spend limit** w `/usage`. To wywołanie zwraca listę osób z najwyższymi wydatkami w danym miesiącu, gotową do raportu (`-g` wyłącza w curl rozwijanie nawiasów; wystarczy klucz z `admin.read_keys`):

```bash
curl -sS -g "https://claude-gateway.internal.example.com/v1/organizations/spend_limits/effective?sort=spend_desc&period[]=monthly" \
  -H "x-api-key: $GATEWAY_ADMIN_READ_KEY"
```

## Prompty do śledzenia kosztów agentów

**Prompt do skopiowania: wyjaśnij moje wydatki na agentów w tym miesiącu**

```text
Run `npx ccusage@latest monthly --json` and `npx ccusage@latest claude daily --instances --json` and read both outputs.

Tell me: total cost this month by agent and by model; the three projects with the highest cost; the three most expensive days and what share of their tokens were cache reads versus fresh input and output. Remember that on a subscription these dollar figures are list-price equivalents, not my bill, and say so in the summary.

Then give me three concrete changes that would cut the biggest cost driver, ranked by expected effect, each tied to a number from the report. Do not change any files.
```

**Prompt do skopiowania: miesięczny raport kosztów zespołów z LiteLLM**

```text
The LiteLLM proxy is at https://llm-gw.internal and the master key is in the environment variable LITELLM_MASTER_KEY. Never print the key.

1. Call GET /team/list, then GET /team/info?team_id=<id> for each team. For each team record team_alias, max_budget, spend and budget_reset_at, and for each of its keys record key_alias and spend.
2. Build a markdown table per team: budget, spend, percent used, the top three keys by spend, and any key above 80% of its own max_budget.
3. Add a short "Actions" list: teams above 90% of budget, keys with zero spend this period (unused licences), and any team whose spend is more than double last month's if the file reports/last-month.json exists.

Write the result to reports/agent-cost-YYYY-MM.md with the current month. Change no budgets and create no keys.
```

**Prompt do skopiowania: sprawdź, czy każdy agent naprawdę idzie przez bramkę**

```text
Read the managed settings file, ~/.claude/settings.json, every .claude/settings.json in this repository, and ~/.codex/config.toml.

Report as a table: where ANTHROPIC_BASE_URL is set; whether ANTHROPIC_AUTH_TOKEN, ANTHROPIC_API_KEY or apiKeyHelper is also set in a place that applies to interactive sessions; which model_provider Codex uses and whether its base_url points at the gateway; and any credential written in plain text in a file tracked by git.

Flag as a billing risk every place where ANTHROPIC_BASE_URL is set without a gateway credential: the claude.ai login then stays active and the gateway never counts those requests. Propose the smallest fix for each finding. Do not edit any file.
```

## Skąd wiesz, że liczby kosztów są prawdziwe?

Każda liczba z tej strony jest szacunkiem, dopóki jej nie uzgodnisz z fakturą. Sprawdzaj przy konfiguracji i po każdej aktualizacji agenta albo bramki:

- **Uzgadniaj z fakturą co miesiąc.** Porównaj wydatki zespołu w bramce, albo sumę z ccusage i `/usage`, ze stroną zużycia w Console, z raportem wydatków planu Team lub Enterprise albo z konsolą rozliczeń chmury. Różnica powyżej twojej tolerancji oznacza maszynę lub zadanie CI, które omija bramkę, model wyceniany przez bramkę na zero albo źle wycenione tokeny cache.
- **Raportuj według stawek z umowy, gdzie się da.** Claude Code liczy koszt w `/usage`, w pasku statusu i w OpenTelemetry według cennika. Od v2.1.242 administrator może ustawić w ustawieniach zarządzanych `modelPricing` ze stawkami z umowy; `/usage` oznacza wtedy sumę dopiskiem `at your organization's configured rates`. Claude apps gateway ma odpowiednik: blok `pricing.overrides`.
- **Testuj blokadę, nie tylko licznik.** Budżet, który nigdy nie odrzucił żądania, jest niesprawdzony. Trzymaj jeden klucz testowy z minimalnym budżetem i co miesiąc sprawdzaj, że jest odrzucany.
- **Wyznacz właścicieli.** Operator bramki odpowiada za test dymny i przypięcie wersji, tech lead za miesięczny raport i zmiany budżetów, a dział finansów za uzgodnienie z fakturą.

## Co się psuje przy śledzeniu kosztów agentów?

| Objaw | Przyczyna | Naprawa |
| --- | --- | --- |
| Bramka nie pokazuje wydatków, choć zespół pracuje | `ANTHROPIC_BASE_URL` ustawione bez poświadczenia bramki, więc żądania dalej idą na logowaniu claude.ai | Ustaw `ANTHROPIC_AUTH_TOKEN` albo `apiKeyHelper`; sprawdź w `/status` |
| Wydatki klucza zostają na 0 USD po prawdziwych żądaniach | LiteLLM nie zna ceny nowego modelu | Dodaj `input_cost_per_token` i `output_cost_per_token` do wpisu modelu; sprawdź ponownie `/key/info` |
| Suma z bramki wyraźnie niższa niż faktura | Tokeny odczytu i zapisu cache nie są wycenione albo zadania CI używają bezpośredniego klucza API | Porównaj kolumny tokenów z `ccusage` dla jednego dnia; przenieś sekrety CI na klucze bramki |
| Za bramką żądania Claude Code kończą się „model not found” | Wybór z `/model` albo model przypięty w `ANTHROPIC_DEFAULT_HAIKU_MODEL` nie jest na liście `model_list` | Dodaj model do `model_list` albo przypnij `ANTHROPIC_DEFAULT_HAIKU_MODEL` do modelu z listy |
| Budżet zeruje się kilka godzin przed lub po zamknięciu miesiąca w finansach | LiteLLM domyślnie zeruje budżety o północy UTC | Ustaw `timezone` w `litellm_settings`; Claude apps gateway zawsze zeruje na granicach kalendarza w UTC |
| Claude apps gateway przepuszcza żądania podczas awarii | Postgres nie odpowiada, a egzekwowanie domyślnie przepuszcza ruch | Ustaw `enforcement.fail_closed_on_error: true`, jeśli niepoliczone wydatki są gorsze niż przestój |

**Pułapki w narzędziach do kosztów agentów**

- `claude-monitor` i `ccmonitor` w npm to niezwiązane projekty. Monitor to pakiet PyPI `claude-monitor`; `ccmonitor` to tylko alias polecenia, który ten pakiet instaluje.
- Dashboard analityczny Claude Code w planach Team i Enterprise nie pokazuje kosztu tokenów na użytkownika. Po liczby na osobę sięgnij do eksportu CSV raportu wydatków, do [OpenTelemetry](/pl/ecosystem/observability/agent-telemetry/) albo, w planie Enterprise, do Enterprise Analytics API (klucz z zakresem `read:analytics`), które zwraca koszt na użytkownika.
- Stare linki `ryoppippi/ccusage` prowadzą do repozytorium przeniesionego do `ccusage/ccusage`.

## Dokąd dalej ze śledzeniem kosztów agentów

- [Zarządzanie kosztami użycia AI](/pl/org/cost-governance/) — Kto jest właścicielem budżetu, przypisanie do centrów kosztów i co się dzieje, gdy zespół przekroczy limit.
- [Telemetria i analityka](/pl/ecosystem/observability/agent-telemetry/) — Koszt na użytkownika prawie w czasie rzeczywistym dzięki OpenTelemetry w Claude Code i Codeksie.
- [Bramki i modele lokalne](/pl/ecosystem/agent-tools/gateways-local-models/) — LiteLLM z modelem lokalnym, Claude Code Router i CC Switch oraz konfiguracja bez dostępu do internetu.
- [Ekonomia oprogramowania budowanego przez agentów](/pl/strategy/economics/) — Przelicz wydatki na koszt zaakceptowanej zmiany, liczbę potrzebną do decyzji o budżecie.

Jak obniżyć wydatki, które pokazują te narzędzia, opisują strony o [optymalizacji kosztów kontekstu](/pl/workflows/context/cost-per-context/), [kontroli kosztów w Claude Code](/pl/claude-code/operate/cost-control/) i [zarządzaniu kosztami w Codeksie](/pl/codex/operate/cost-management/). Ceny planów trzech narzędzi porównuje strona o [porównaniu kosztów i ROI](/pl/comparison/pricing-analysis/). Przegląd sekcji, [pomiar pracy z agentami](/pl/ecosystem/observability/), zestawia śledzenie kosztów z telemetrią, botami do review, bramkami bezpieczeństwa i ewaluacjami.
