guides

API Claude Fable 5.2: ceny, konfiguracja i przykłady kodu

Poyo.ai Team
16 min read
Share:

Najważniejsze wnioski

  • ID modelu: claude-fable-5-2. Premiera 9 listopada 2026, okno kontekstu 1M tokenów i do 128K tokenów wyjściowych na żądanie.
  • Cena: $8 / $40 za milion tokenów wejściowych/wyjściowych w API Anthropic, czyli o 20% mniej niż w Fable 5.1. W PoYo model kosztuje $6.40 / $32.
  • Dwa sposoby wywołania w PoYo: format Anthropic Messages pod POST https://api.poyo.ai/v1/messages albo zgodny z OpenAI POST https://api.poyo.ai/v1/chat/completions. Oficjalne SDK Anthropic działają po ustawieniu bazowego adresu URL na https://api.poyo.ai.
  • Myślenie jest zawsze włączone. Głębokość i koszt ustawiasz parametrem output_config.effort. Domyślna wartość to high; do rutynowej pracy używaj medium lub low.
  • Myślenie jest rozliczane jako wyjście. Nawet krótka odpowiedź na poziomie high może zużyć tysiące tokenów wyjściowych, dlatego ustawiaj effort jawnie i dobieraj max_tokens tak, by zmieściło się myślenie i odpowiedź.
  • Najpierw sprawdzaj stop_reason. Mówi, czy model skończył, wywołał narzędzie, doszedł do max_tokens, czy zwrócił refusal z powodów bezpieczeństwa, więc odczytuj go przed treścią.

API Claude Fable 5.2 w skrócie

Claude Fable 5.2
ID modelu w APIclaude-fable-5-2
Premiera9 listopada 2026
Okno kontekstu1M tokenów
Maksymalne wyjście128K tokenów na żądanie
Wejście → wyjścieTekst i obrazy → tekst
MyślenieAdaptacyjne, zawsze włączone
Poziomy effortlow, medium, high (domyślny), xhigh, max
Granica wiedzyCzerwiec 2026
Retencja danychRetencja przez 30 dni
Cena oficjalna (za 1M tokenów)$8 wejście / $40 wyjście / $0.20 odczyt z cache
Cena w PoYo (za 1M tokenów)$6.40 wejście / $32 wyjście / $0.16 odczyt z cache
Endpointy PoYo/v1/messages, /v1/chat/completions

Anthropic przeznacza Fable 5.2 do wymagającego rozumowania i długotrwałej pracy agentowej, a jako punkt wyjścia dla większości zastosowań zaleca Claude Opus 5.5. Jeśli wciąż wybierasz między tymi dwoma modelami, najpierw przeczytaj artykuł Claude Fable 5.2 vs Opus 5.5. Ten przewodnik dotyczy integracji.

Prototyp systemu operacyjnego zbudowany przez agentów Claude Fable 5.2, uruchomiony na laptopie. Wideo z materiałów Anthropic z premiery Claude Fable 5.2.

Fable 5, 5.1 czy 5.2: której ceny szukasz?

Wyszukiwanie „Claude Fable 5 pricing” może dotyczyć każdego z trzech modeli Fable wydanych w 2026 roku. Wszystkie mają okno kontekstu 1M i limit wyjścia 128K, a każdy ma własną cenę:

ModelPremieraWejścieWyjścieOdczyt z cacheID modelu w API
Claude Fable 59 czerwca 2026$10$50$1.00claude-fable-5
Claude Fable 5.11 września 2026$10$50$0.25claude-fable-5-1
Claude Fable 5.29 listopada 2026$8$40$0.20claude-fable-5-2

Oficjalne ceny w USD za milion tokenów. Fable 5.2 to pierwsza obniżka ceny w segmencie Fable i zarazem aktualny model, więc nowe projekty warto zaczynać właśnie od niego. Dalsza część przewodnika dotyczy Fable 5.2.

Ceny w skrócie

Opłata (za 1M tokenów)Oficjalnie (Anthropic)PoYoKredyty PoYo
Wejście$8.00$6.401 280
Wyjście (z myśleniem)$40.00$32.006 400
Odczyt z cache$0.20$0.1632
Zapis do cache, 5 minut$10.00$8.001 600
Zapis do cache, 1 godzina$16.00$12.802 560

PoYo rozlicza się w modelu pay-as-you-go w kredytach ($1 = 200 kredytów), bez subskrypcji. Całe okno kontekstu 1M jest rozliczane według standardowych stawek, więc prompt na 900K tokenów kosztuje za token tyle samo co prompt na 9K tokenów. Ceny wszystkich pozostałych modeli Claude znajdziesz w naszym przewodniku po cenach Claude API.

Szybki start

  1. Utwórz klucz API w panelu PoYo.
  2. Wysyłaj żądania na https://api.poyo.ai z modelem ustawionym na claude-fable-5-2.
  3. Uwierzytelniaj się nagłówkiem x-api-key: YOUR_KEY w /v1/messages (działa też Authorization: Bearer YOUR_KEY) albo nagłówkiem Authorization: Bearer YOUR_KEY w /v1/chat/completions.

curl (format Anthropic Messages)

curl https://api.poyo.ai/v1/messages \
  -H "x-api-key: $POYO_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-fable-5-2",
    "max_tokens": 16000,
    "output_config": {"effort": "medium"},
    "messages": [
      {"role": "user", "content": "Znajdź wyścig danych w tej puli workerów w Go i zaproponuj poprawkę: ..."}
    ]
  }'

Odpowiedź to standardowy obiekt Message Anthropic. Treść odpowiedzi znajduje się w bloku text w content; przed nim może pojawić się blok thinking.

Python (SDK Anthropic)

import os
import anthropic

client = anthropic.Anthropic(
    base_url="https://api.poyo.ai",
    api_key=os.environ["POYO_API_KEY"],
)

with client.messages.stream(
    model="claude-fable-5-2",
    max_tokens=32000,
    output_config={"effort": "medium"},
    thinking={"type": "adaptive", "display": "summarized"},
    messages=[{"role": "user", "content": "Napisz plan migracji tej usługi z REST na gRPC: ..."}],
) as stream:
    message = stream.get_final_message()

if message.stop_reason == "refusal":
    print("Request declined:", message.stop_details)
else:
    for block in message.content:
        if block.type == "thinking":
            print("Thinking summary:", block.thinking)
        elif block.type == "text":
            print(block.text)

print(message.usage)

Strumieniowanie chroni długie żądania przed przekroczeniem limitów czasu HTTP. Na poziomie high i wyższych jedno trudne żądanie może trwać kilka minut.

TypeScript (SDK Anthropic)

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  baseURL: "https://api.poyo.ai",
  apiKey: process.env.POYO_API_KEY,
});

const message = await client.messages
  .stream({
    model: "claude-fable-5-2",
    max_tokens: 32000,
    output_config: { effort: "medium" },
    messages: [{ role: "user", content: "Sprawdź ten pull request pod kątem problemów z bezpieczeństwem: ..." }],
  })
  .finalMessage();

if (message.stop_reason === "refusal") {
  console.log("Request declined:", message.stop_details);
} else {
  for (const block of message.content) {
    if (block.type === "text") console.log(block.text);
  }
}

Chat Completions zgodne z OpenAI

Jeśli twój stos już korzysta z formatu żądań OpenAI, wyślij ten sam identyfikator modelu do /v1/chat/completions:

curl https://api.poyo.ai/v1/chat/completions \
  -H "Authorization: Bearer $POYO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5-2",
    "messages": [
      {"role": "system", "content": "Jesteś doświadczonym inżynierem danych."},
      {"role": "user", "content": "Zaprojektuj schemat do deduplikacji zdarzeń w ClickHouse."}
    ],
    "stream": true
  }'

W oficjalnym SDK OpenAI ustaw base_url na https://api.poyo.ai/v1. Z /v1/messages korzystaj wtedy, gdy potrzebujesz ustawień specyficznych dla Claude, takich jak output_config.effort, sposób wyświetlania myślenia, cache_control i definicje narzędzi w stylu Anthropic.

Effort: główna dźwignia jakości i kosztu

Fable 5.2 myśli adaptacyjnie przy każdym żądaniu. O tym, jak dużo, decyduje ustawienie effort w output_config:

EffortKiedy używaćUwagi
lowSzybka wymiana zdań, dobrze określone zadania, subagenci o dużym wolumenieNajszybszy i najtańszy. Przy długich zadaniach dodaj instrukcję „dokończ całe zadanie”
mediumInteraktywne programowanie, czat, codzienna praca z wiedząDobry wybór domyślny dla większości ruchu w produkcie
high (domyślny)Trudne programowanie, research, praca agentowa, długie przebiegi bez nadzoruWedług Anthropic większość przyrostu możliwości jest dostępna już na high
xhighNajtrudniejsze, długotrwałe zadania programistyczne i agentoweStosuj tam, gdzie twoje ewaluacje pokazują wymierny zysk; zużywa więcej tokenów
maxBadanie górnej granicy możliwości lub rzadkie zadania, w których głębia liczy się bardziej niż czas i tokenyNajgłębsze rozumowanie i najdłuższe tury

Wykres Anthropic FrontierCode 2.0 przedstawiający wynik względem kosztu zadania dla Claude Fable 5.2 na poziomach effort low, medium, high, xhigh i max obok innych modeli

Jak effort przekłada się na wynik i koszt zadania w FrontierCode 2.0. Wykres z materiałów Anthropic z premiery Claude Fable 5.2.

Trzy praktyczne zasady:

  • Ustawiaj effort w każdym żądaniu. Kod przeniesiony z Opus 5.5 działał domyślnie na medium. W Fable 5.2 to samo żądanie działa na high i zużywa więcej tokenów wyjściowych.
  • Ilością myślenia steruj przez effort. Aby tury były szybsze i tańsze, Anthropic zaleca niższy poziom effort zamiast poleceń w prompcie w rodzaju „odpowiedz od razu, bez zastanawiania się”. Na high i wyższych Fable 5.2 myśli przed niemal każdą odpowiedzią, nawet przed przywitaniem.
  • Długość odpowiedzi określaj w prompcie. Effort ustala głębokość myślenia, a prompt decyduje o tym, jak długa będzie końcowa odpowiedź.

Zmierzony przykład tego, jak effort wpływa na rachunek, znajdziesz w wynikach testów praktycznych w artykule Claude Fable 5.2 vs Opus 5.5: w jednym zadaniu programistycznym Fable 5.2 uzyskał ten sam wynik na medium i high, a na medium kosztowało to mniej więcej jedną czwartą.

Myślenie adaptacyjne: co „zawsze włączone” oznacza dla twojego kodu

  • Pomiń thinking albo wyślij {"type": "adaptive"}. To cała konfiguracja myślenia. Głębokość wynika z effort, który zastępuje dawne ustawienia budget_tokens i disabled.
  • Tokeny myślenia są rozliczane jako wyjście i wliczają się do max_tokens. Dobierz max_tokens tak, by zmieściło się myślenie i odpowiedź: 16K to rozsądne minimum, a do trudnych zadań nadaje się 32K lub więcej ze strumieniowaniem.
  • Podsumowania myślenia włączasz na życzenie. Domyślnie bloki myślenia przychodzą z pustym polem thinking, dzięki czemu strumieniowanie pozostaje szybkie. Dodaj "display": "summarized", aby otrzymać czytelne podsumowanie. W obu trybach rozliczane jest całe myślenie.
  • Próbkowanie zostaw modelowi. Wysyłaj żądania bez temperature, top_p i top_k; Fable 5.2 samodzielnie zarządza próbkowaniem.
  • Odczytuj usage. output_tokens obejmuje już myślenie, a output_tokens_details.thinking_tokens pokazuje, ile z tego przypada na myślenie.

Używanie narzędzi

Fable 5.2 przyjmuje tool_choice o wartości auto (domyślnie) lub none. Jeśli chcesz, by narzędzie zostało wywołane, wymień je z nazwy w prompcie:

{
  "model": "claude-fable-5-2",
  "max_tokens": 16000,
  "output_config": {"effort": "medium"},
  "tools": [
    {
      "name": "get_order_status",
      "description": "Look up an order by its ID and return the shipping status and carrier.",
      "input_schema": {
        "type": "object",
        "properties": {"order_id": {"type": "string"}},
        "required": ["order_id"]
      }
    }
  ],
  "tool_choice": {"type": "auto"},
  "messages": [
    {"role": "user", "content": "Gdzie jest zamówienie A-1042? Sprawdź to za pomocą get_order_status."}
  ]
}

Gdy model wywołuje narzędzie, odpowiedź kończy się stop_reason: "tool_use". Uruchom narzędzie, a następnie odeślij blok tool_result w kolejnej wiadomości użytkownika. Całą turę asystenta przekaż z powrotem bez zmian, łącznie z blokami myślenia.

Inne zasady, które warto znać:

  • W tool_choice używaj auto lub none. Aby mieć pewność, że narzędzie zostanie uruchomione, wymień je w prompcie. Gdy potrzebujesz gwarantowanego JSON-a, użyj structured output: output_config.format ze schematem JSON.
  • Obsługa komputera działa przez zestaw narzędzi computer_toolset_20260801.
  • Dane wejściowe narzędzi parsuj parserem JSON. Poradzi sobie z każdym sposobem escapowania, jakiego model użyje w argumentach narzędzi.

Ramiona robota sterowane przez Claude Fable 5.2 na podstawie obrazu z kamer układają kostkę logiczną. Wideo z materiałów Anthropic z premiery Claude Fable 5.2.

Kontekst 1M i prompt caching

Okno 1M tokenów mieści mniej więcej 555 000 angielskich słów, czyli wystarczająco dużo na sporą bazę kodu lub plik umów w jednym żądaniu. Fable 5.2 korzysta z tokenizera wprowadzonego w Claude Opus 4.7, który z tego samego tekstu tworzy więcej tokenów niż modele sprzed wersji 4.7, dlatego zanim zaplanujesz pracę pod ten limit, policz tokeny na własnych plikach.

Przy długich promptach cache zwraca się najbardziej. Odczyt z cache w Fable 5.2 kosztuje 2,5% ceny wejścia ($0.20 wobec $8 za milion tokenów). W PoYo wystarczy dodać cache_control na najwyższym poziomie żądania, a ostatni blok, który da się zapisać w cache, zostanie zapisany automatycznie:

{
  "model": "claude-fable-5-2",
  "max_tokens": 16000,
  "cache_control": {"type": "ephemeral", "ttl": "1h"},
  "output_config": {"effort": "medium"},
  "system": "You answer questions about the contract below. Quote clause numbers.\n\n<contract>...</contract>",
  "messages": [
    {"role": "user", "content": "Wypisz wszystkie prawa do wypowiedzenia umowy i ich okresy wypowiedzenia."}
  ]
}

Stałą treść (prompt systemowy, definicje narzędzi, dokument) umieszczaj na początku, a zmieniające się pytanie na końcu. W rozmowie wieloturowej lub pętli agenta każda nowa tura odczytuje wcześniejszy prefiks z cache. Zapis do cache na 5 minut kosztuje 1,25× ceny wejścia i zwraca się po jednym odczycie; cache na 1 godzinę kosztuje 2× i zwraca się po dwóch.

Dwa nawyki pozwalają zachować działanie zarówno cache, jak i rozumowania modelu w kolejnych turach:

  • Historię tylko uzupełniaj. Każdy blok myślenia jest powiązany z promptem systemowym, narzędziami i wiadomościami, które go poprzedzały. Utrzymuj stałe system i tools przez całą rozmowę, a nowe tury dopisuj na końcu messages. Jeśli wcześniejsze tury zostaną zmienione, a stare bloki myślenia odesłane, kontrola prefiksu w API oznaczy żądanie komunikatem The block is bound to a different conversation. Aby zmienić instrukcje, zacznij nową rozmowę.
  • Model zmieniaj, kiedy chcesz. W tej samej rozmowie możesz zmieniać model między żądaniami. Bloki myślenia Fable 5.2 odczytują Fable 5.2 i Mythos 5.2; gdy rozmowa przechodzi do innego modelu, np. Opus 5.5, API automatycznie pomija te bloki, żądanie kończy się powodzeniem, a nowy model kontynuuje z własnym rozumowaniem. Każdy model ma własny cache.

Obsługa odmów

Fable 5.2 korzysta z klasyfikatorów bezpieczeństwa. Gdy któryś z nich zatrzyma żądanie, odpowiedź przychodzi jako HTTP 200 ze stop_reason: "refusal" i obiektem stop_details, który wskazuje obszar zasad, np. cyber, bio lub reasoning_extraction. Twój kod powinien:

  1. Sprawdzać stop_reason przed odczytaniem content, tak jak w przykładach w Pythonie i TypeScript powyżej.
  2. Logować stop_details.category, aby widzieć, które prompty to wywołują.
  3. Wysłać żądanie do innego modelu, np. Opus 5.5, albo pokazać użytkownikowi jasny komunikat.

Aby zobaczyć, jak model rozumował, poproś o myślenie z "display": "summarized". Rozumowanie nie trafia wtedy do tekstu odpowiedzi, a właśnie tego obszaru dotyczy kategoria reasoning_extraction.

Migracja z Fable 5.1 lub Opus 5.5

Skąd przechodziszCo się zmienia
Claude Fable 5.1Zmień ID modelu. Ceny spadają z $10 / $50 do $8 / $40. Kontrola prefiksu obejmuje teraz każde konto, więc historię tylko uzupełniaj. Do obsługi komputera używaj computer_toolset_20260801. W narzędziu advisor ustaw doradcę na claude-fable-5-2. Powtórz przegląd poziomów effort, zaczynając od high
Claude Opus 5.5Cena tokenów zmienia się z $4 / $20 na $8 / $40; odczyt z cache zostaje przy $0.20. Domyślny effort zmienia się z medium na high, więc ustawiaj go jawnie. Fable 5.2 działa z 30-dniową retencją danych. Zasady myślenia i tool_choice są takie same
Claude Opus 5 lub starszyPozwól myśleniu działać adaptacyjnie i steruj nim przez effort zamiast disabled i budget_tokens. Używaj tool_choice auto z instrukcją w prompcie albo structured output do JSON-a. Próbkowanie zostaw modelowi zamiast ustawiać temperature, top_p i top_k. Dobierz max_tokens tak, by zmieściło się myślenie i odpowiedź

Prompty przeniesione z wcześniejszych modeli warto przejrzeć. Przy długich, wieloetapowych zadaniach Anthropic zaleca dodanie do promptu systemowego instrukcji „dokończ całe zadanie”, zwłaszcza na poziomach low i medium. Fable 5.2 ściśle trzyma się zasad stylu, więc poluzuj sztywne limity długości zdań pisane z myślą o starszych modelach, aby jego teksty brzmiały naturalnie. Po zmianie promptu zacznij nową rozmowę.

Ile kosztuje żądanie

Tokeny wyjściowe poniżej obejmują myślenie. Wszystkie ceny za milion tokenów.

ScenariuszTokenyOficjalnie ($8 / $40)PoYo ($6.40 / $32)
Odpowiedź w czacie5K wejścia + 1K wyjścia0.005×8 + 0.001×40 = $0.0800.005×6.4 + 0.001×32 = $0.064 (12.8 kredytu)
Code review50K wejścia + 8K wyjścia0.05×8 + 0.008×40 = $0.720.05×6.4 + 0.008×32 = $0.576 (115.2 kredytu)
Sesja agenta2M odczytów z cache + 300K nowego wejścia + 150K wyjścia2×0.2 + 0.3×8 + 0.15×40 = $8.802×0.16 + 0.3×6.4 + 0.15×32 = $7.04
Dokument na 800K tokenów, pierwsze pytanie800K zapisane do cache na 5 minut + 10K wyjścia0.8×10 + 0.01×40 = $8.400.8×8 + 0.01×32 = $6.72
Ten sam dokument, kolejne pytanie800K odczytu z cache + 10K wyjścia0.8×0.2 + 0.01×40 = $0.560.8×0.16 + 0.01×32 = $0.45

Wiersze z dokumentem pokazują, dlaczego cache ma znaczenie: po pierwszym pytaniu każde kolejne kosztuje mniej więcej piętnaście razy mniej. W sesji agenta wyjście stanowi około dwóch trzecich rachunku, dlatego effort jest pierwszym ustawieniem, które warto dostroić.

Claude Fable 5.2 w PoYo

PoYo udostępnia Fable 5.2 o 20% taniej niż według oficjalnych stawek Anthropic za tokeny, z kilkoma praktycznymi dodatkami:

  • Jeden klucz API do wszystkich modeli. Fable 5.2, Opus 5.5, Sonnet 5.5, modele GPT oraz modele do obrazów, wideo i audio korzystają z tego samego klucza i panelu.
  • Pay-as-you-go. Kredyty są rozliczane za tokeny, bez subskrypcji.
  • Oba formaty żądań. Fable 5.2 wywołasz w formacie Anthropic Messages lub OpenAI Chat Completions z tym samym ID modelu.

Przetestuj prompty w Playground na stronie modelu Claude Fable 5.2, a potem przenieś ten sam identyfikator modelu do produkcji. Aby porównać go z codziennym modelem domyślnym, zmień "model" na claude-opus-5-5 na stronie Claude Opus 5.5 przy tym samym kluczu.

Najczęstsze pytania

Ile kosztuje API Claude Fable 5.2?

$8 za milion tokenów wejściowych i $40 za milion tokenów wyjściowych w API Anthropic, a odczyt z cache kosztuje $0.20. W PoYo ten sam model kosztuje $6.40 za wejście, $32 za wyjście i $0.16 za odczyt z cache w przeliczeniu na milion tokenów. Tokeny myślenia są rozliczane według stawki za wyjście.

Ile kosztuje Claude Fable 5?

Claude Fable 5 (czerwiec 2026) kosztuje $10 / $50 za milion tokenów wejściowych/wyjściowych, a odczyt z cache $1. Fable 5.1 zachował cenę $10 / $50 i obniżył odczyt z cache do $0.25. Fable 5.2 obniża cenę do $8 / $40 przy odczycie z cache za $0.20.

Jaki jest identyfikator modelu Claude Fable 5.2?

claude-fable-5-2, dokładnie w tej postaci. Używaj go w /v1/messages lub /v1/chat/completions.

Czy mogę używać SDK Anthropic z PoYo?

Tak. Ustaw bazowy adres URL na https://api.poyo.ai i podaj klucz PoYo jako klucz API. SDK samo wysyła x-api-key i anthropic-version, a strumieniowanie działa z pomocniczymi funkcjami stream z SDK.

Jak sprawić, by Fable 5.2 mniej myślał?

Ustaw output_config.effort na low lub medium. Myślenie adaptacyjne działa przy każdym żądaniu i skaluje się z poziomem effort, więc niższy poziom daje szybsze i tańsze odpowiedzi.

Jakiego poziomu effort używać?

Do pracy interaktywnej i rutynowego programowania zacznij od medium, a do trudnych, długotrwałych zadań agentowych od high. Na xhigh przechodź tam, gdzie twoje ewaluacje pokazują zysk, a low stosuj przy prostych wywołaniach o dużym wolumenie.

Jak rozliczany jest długi kontekst?

Całe okno 1M tokenów jest rozliczane według standardowej stawki, więc długie prompty kosztują za token tyle samo co krótkie. Prompt caching dodatkowo obniża koszt ponownego wczytywania długiego kontekstu.

Czy mogę zmienić model lub edytować wiadomości w trakcie rozmowy?

Model możesz zmienić w dowolnym momencie: wyślij kolejne żądanie z innym model, a API w razie potrzeby automatycznie pominie wcześniejsze bloki myślenia, więc żądanie zakończy się powodzeniem. Jeśli chodzi o edycję, utrzymuj stałe system i tools, dopisuj nowe wiadomości i odsyłaj każdą turę asystenta dokładnie w takiej postaci, w jakiej ją otrzymałeś; kontrola prefiksu oznacza historie, w których wcześniejsze tury zmieniono po wygenerowaniu bloku myślenia. Aby zmienić instrukcje, zacznij nową rozmowę.

Czym różni się Fable 5.2 od Mythos 5.2?

Oba mają te same możliwości, specyfikację i ceny. Mythos 5.2 jest udostępniany organizacjom zweryfikowanym w ramach programów Anthropic, takich jak Cyber Verification Program, a Fable 5.2 jest dostępny dla wszystkich programistów.

Share: