Claude Messages API 申请及使用

Anthropic Claude to bardzo potężny system AI do rozmów, który potrafi generować płynne i naturalne odpowiedzi w zaledwie kilka sekund po wprowadzeniu podpowiedzi. Claude Messages API to oficjalny natywny format API Anthropic, który różni się od formatu OpenAI (Chat Completion), ponieważ wykorzystuje własną strukturę żądań i odpowiedzi Anthropic, co pozwala lepiej wykorzystać unikalne możliwości Claude’a, takie jak wejście treści multimodalnych, wywołania narzędzi, głębokie myślenie (Extended Thinking) i inne zaawansowane cechy. Dokument ten głównie opisuje proces korzystania z Claude Messages API, dzięki któremu możemy korzystać z natywnego interfejsu zgodnego z oficjalnym Anthropic do wywoływania funkcji rozmowy Claude’a.

申请流程

Aby korzystać z Claude Messages API, najpierw przejdź do Ace Data Cloud 控制台, aby uzyskać swój token API, który należy zachować na przyszłość.

Jeśli nie jesteś zalogowany lub zarejestrowany, automatycznie zostaniesz przekierowany na stronę logowania, aby zarejestrować się i zalogować, a po zakończeniu zostaniesz automatycznie przekierowany z powrotem na bieżącą stronę. Jeden token API wystarczy do wywołania wszystkich usług platformy, nie ma potrzeby składania osobnych wniosków dla każdej usługi. Pierwsze zgłoszenie otrzyma darmowy limit, aby można było skorzystać z bezpłatnej wersji; w przypadku niewystarczającego limitu można doładować saldo ogólne w kontrolerze.

📘 Pełna dokumentacja: Claude Messages API →

基本使用

Ścieżka żądania Claude Messages API to /v1/messages, zgodna z oficjalnym API Anthropic. Musimy podać co najmniej trzy wymagane parametry:

model：wybór modelu Claude, który ma być użyty. Najnowszy flagowy model to claude-fable-5-1 (1 milion tokenów kontekstowych, maksymalne wyjście 128K tokenów); oryginalny claude-fable-5 pozostaje w pełni kompatybilny.
messages：tablica wiadomości wejściowych, każda wiadomość zawiera role（rola）i content（treść），gdzie role obsługuje user i assistant.
max_tokens：maksymalna liczba tokenów wyjściowych, używana do ograniczenia długości pojedynczej odpowiedzi.

Często używane opcjonalne parametry:

system：systemowa podpowiedź, używana do ustalenia zachowania i roli modelu.
temperature：losowość generacji, w zakresie 0-1, im wyższa wartość, tym bardziej rozproszone odpowiedzi.
stream：czy używać odpowiedzi strumieniowej, ustawienie na true umożliwia zwracanie wyników słowo po słowie.
stop_sequences：niestandardowe sekwencje zatrzymania, model przestanie generować, gdy napotka te teksty.
top_p：parametr próbkowania jądra, współpracujący z temperaturą w kontrolowaniu losowości generacji.
top_k：próbkowanie tylko z K najwyżej prawdopodobnych opcji.
tools：definicja narzędzi, umożliwiająca modelowi wywoływanie zewnętrznych funkcji.
tool_choice：kontroluje, jak model korzysta z dostarczonych narzędzi.
cache_control：automatycznie tworzy punkty kontrolne pamięci podręcznej na ostatnim blokowanym do pamięci podręcznej w żądaniu; można również zapisać na konkretnym bloku treści.

cURL 示例

curl -X POST 'https://api.acedata.cloud/v1/messages' \
  -H 'accept: application/json' \
  -H 'authorization: Bearer {token}' \
  -H 'content-type: application/json' \
  -d '{
    "model": "claude-fable-5-1",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Hello, Claude"
      }
    ]
  }'

Python 示例

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-fable-5-1",
    "max_tokens": 1024,
    "messages": [
        {"role": "user", "content": "Hello, Claude"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Po wywołaniu, zwrócony wynik wygląda następująco:

{
  "id": "msg_013Zva2CMHLNnXjNJJKqJ2EF",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Hi! My name is Claude. How can I help you today?"
    }
  ],
  "model": "claude-opus-4-8",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 12,
    "output_tokens": 15
  }
}

Opis pól zwróconego wyniku:

id：unikalny identyfikator tej wiadomości.
type：zawsze message.
role：zawsze assistant.
content：tablica treści odpowiedzi, każdy element zawiera type（np. text）i odpowiadającą treść.
model：nazwa modelu przetwarzającego żądanie.
stop_reason：powód zatrzymania. Stabilne wartości to end_turn、max_tokens、stop_sequence、tool_use、pause_turn（można zwrócić aktualną treść asystenta, aby kontynuować）、refusal i model_context_window_exceeded.
stop_sequence：jeśli zatrzymano z powodu niestandardowej sekwencji zatrzymania, wyświetla dopasowany tekst sekwencji zatrzymania.
stop_details：gdy stop_reason to refusal, może zawierać kategorię i opis odmowy.
usage：statystyki użycia tokenów. input_tokens to niebuforowane wejście; cache_creation_input_tokens i cache_read_input_tokens to odpowiednio zapisywanie i odczytywanie pamięci podręcznej; output_tokens to liczba tokenów wyjściowych. Oficjalna stawka za odczyt pamięci podręcznej Fable 5.1 wynosi $0.25/milion tokenów, a stawki za zapis pamięci podręcznej przez 5 minut i 1 godzinę wynoszą odpowiednio$ 12.50 i $20/milion tokenów; rzeczywiste ceny platformy są przeliczane według zniżek pakietowych. Odpowiedzi nieliniowe mogą również zawierać cost zarejestrowany przez Ace Data Cloud.

系统提示词

Claude Messages API obsługuje ustawianie systemowych podpowiedzi za pomocą pola system, które służy do definiowania zachowania, roli i kontekstu modelu.

Python 示例

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "system": "Jesteś profesjonalnym asystentem tłumaczeń chińskich, przetłumacz angielskie zdania wprowadzone przez użytkownika na chiński.",
    "messages": [
        {"role": "user", "content": "The quick brown fox jumps over the lazy dog."}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Ustawiając podpowiedź system, można precyzyjnie kontrolować rolę i sposób działania Claude’a.

流式响应

Interfejs ten obsługuje również odpowiedzi strumieniowe, ustawiając parametr stream na true, aby uzyskać efekt stopniowego zwracania, co jest idealne do implementacji wyświetlania słowo po słowie na stronie internetowej.

Python 示例

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "stream": True,
    "messages": [
        {"role": "user", "content": "Cześć, Claude"}
    ]
}

response = requests.post(url, json=payload, headers=headers, stream=True)
for line in response.iter_lines():
    if line:
        print(line.decode("utf-8"))

Strumieniowa odpowiedź jest zwracana w formacie Server-Sent Events (SSE), każda linia zaczyna się od prefiksu event: i data:. Typy zdarzeń strumieniowych obejmują:

message_start: początek wiadomości, zawierający podstawowe informacje o wiadomości i nazwę modelu.
content_block_start: początek bloku treści.
content_block_delta: inkrementalna aktualizacja bloku treści, zawierająca nowo wygenerowane fragmenty tekstu.
content_block_stop: koniec bloku treści.
message_delta: inkrementalna aktualizacja na poziomie wiadomości, zawierająca informacje o stop_reason i ostatecznym usage.
message_stop: koniec wiadomości.

Wynik wygląda następująco:

event: message_start
data: {"type":"message_start","message":{"id":"msg_01XFDUDYJgAACzvnptvVoYEL","type":"message","role":"assistant","content":[],"model":"claude-sonnet-4-20250514","stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":12,"output_tokens":0}}}

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Cześć"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"! Nazywam się"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" Claude. Jak mogę ci dzisiaj pomóc?"}}

event: content_block_stop
data: {"type":"content_block_stop","index":0}

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"output_tokens":15}}

event: message_stop
data: {"type":"message_stop"}

Można zauważyć, że zdarzenie content_block_delta w strumieniowej odpowiedzi zawiera stopniowo generowane treści, a poprzez połączenie wszystkich text_delta można uzyskać pełną odpowiedź.

Przykład JavaScript

const options = {
  method: "POST",
  headers: {
    accept: "application/json",
    authorization: "Bearer {token}",
    "content-type": "application/json",
  },
  body: JSON.stringify({
    model: "claude-sonnet-4-20250514",
    max_tokens: 1024,
    stream: true,
    messages: [{ role: "user", content: "Cześć, Claude" }],
  }),
};

const response = await fetch("https://api.acedata.cloud/v1/messages", options);
const reader = response.body.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  console.log(decoder.decode(value));
}

Wiele rund rozmowy

Jeśli chcesz zintegrować funkcję wielu rund rozmowy, musisz na przemian umieszczać wiadomości ról user i assistant w tablicy messages, przekazując wcześniejszą historię rozmowy.

Przykład Python

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
        {"role": "user", "content": "Cześć, mam na imię Alice."},
        {"role": "assistant", "content": "Cześć Alice! Miło cię poznać. Jak mogę ci dzisiaj pomóc?"},
        {"role": "user", "content": "Jakie jest moje imię?"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Wynik wygląda następująco:

{
  "id": "msg_01Y1wfQmd89g968TVbFu57Yc",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Twoje imię to Alice, jak właśnie mi powiedziałaś!"
    }
  ],
  "model": "claude-sonnet-4-20250514",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 40,
    "output_tokens": 14
  }
}

Przekazując pełną historię rozmowy w messages, Claude może dokładnie odpowiedzieć, uwzględniając kontekst.

Model głębokiego myślenia

Myślenie Claude’a i podsumowanie myślenia to dwa różne pojęcia: model może przeprowadzać wewnętrzne rozumowanie, ale API nie zwraca oryginalnego łańcucha myślenia. Gdy konieczne jest pokazanie procesu rozumowania, API zwraca przetworzone podsumowanie. Aktualny model zaleca użycie myślenia adaptacyjnego i kontrolowanie ogólnego wysiłku rozumowania za pomocą output_config.effort:

import requests

url = "https://api.acedata.cloud/v1/messages"
headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}
payload = {
    "model": "claude-opus-5",
    "max_tokens": 16000,
    "thinking": {
        "type": "adaptive",
        "display": "summarized"
    },
    "output_config": {
        "effort": "high"
    },
    "messages": [
        {"role": "user", "content": "Jaki jest sinus 30 stopni?"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Blok myślenia w odpowiedzi wygląda następująco:

{
  "type": "thinking",
  "thinking": "Problem pyta o standardową wartość trygonometryczną...",
  "signature": "opaque-signature"
}

display: "summarized" zwraca czytelne podsumowanie myślenia; nie jest to oryginalny łańcuch myślenia.
display: "omitted" zwraca thinking: "", ale nadal zachowuje nieprzezroczysty signature, aby wspierać dalszą rozmowę.
Fable 5.1, Fable 5, Opus 5, Sonnet 5, Opus 4.8 i Opus 4.7 mają domyślną wartość omitted dla display; Opus 4.6, Sonnet 4.6 i wcześniejsze modele wspierające myślenie domyślnie używają summarized.
Display wpływa tylko na zwracane treści i opóźnienie strumieniowe, nie wyłącza rozumowania ani nie zmniejsza naliczania tokenów myślenia.
Czy myślenie jest domyślnie włączone oraz domyślne wartości display to dwa niezależne pytania. Opus 5, Sonnet 5 domyślnie włączają myślenie adaptacyjne; Opus 4.8, 4.7 i 4.6 muszą być jawnie włączone.
budget_tokens jest używane tylko w starszych modelach, które nadal wspierają stały budżet myślenia. Nowe modele powinny używać thinking.type=adaptive i output_config.effort; myślenie w Fable 5.1 jest zawsze włączone i nie można go jawnie wyłączyć.
W przypadku wielu rund rozmowy i wywołań narzędzi, należy zwrócić pełny blok myślenia oraz podpis zwrócony przez asystenta bez zmian; nie należy modyfikować ani samodzielnie generować podpisu.
Niektóre częściowo kompatybilne trasy nie mogą bezstratnie przetwarzać redacted_thinking lub jawnie wyłączać myślenia, w takim przypadku zwrócą błąd parametru, a nie cicho porzucą lub zmienią semantykę żądania.

W strumieniowym żądaniu, summarized wygeneruje thinking_delta; omitted nie wygeneruje thinking_delta, zachowując jedynie cykl życia bloku myślenia i signature_delta.

Model wizualny

Claude obsługuje wejścia multimodalne, mogąc jednocześnie przetwarzać tekst i obrazy. W API wiadomości, aby skorzystać z możliwości wizualnych, należy ustawić `content` w formacie tablicy i przekazać blok zawartości obrazu.

### Użycie kodowania Base64 dla obrazów

```python
import base64
import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

# Odczyt i kodowanie obrazu
with open("image.png", "rb") as f:
    image_data = base64.standard_b64encode(f.read()).decode("utf-8")

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/png",
                        "data": image_data
                    }
                },
                {
                    "type": "text",
                    "text": "Co jest na tym obrazie?"
                }
            ]
        }
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Użycie obrazu z URL

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://cdn.acedata.cloud/ueugot.png"
                    }
                },
                {
                    "type": "text",
                    "text": "Co jest na tym obrazie?"
                }
            ]
        }
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Przykład cURL

curl -X POST 'https://api.acedata.cloud/v1/messages' \
  -H 'accept: application/json' \
  -H 'authorization: Bearer {token}' \
  -H 'content-type: application/json' \
  -d '{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "image",
            "source": {
              "type": "url",
              "url": "https://cdn.acedata.cloud/ueugot.png"
            }
          },
          {
            "type": "text",
            "text": "Co jest na tym obrazie?"
          }
        ]
      }
    ]
  }'

Obsługiwane formaty obrazów to: image/jpeg, image/png, image/gif, image/webp.

Dokumenty i PDF

PDF używa bloku zawartości document, wspierając stabilne źródła w formacie Base64 i URL. Źródło Base64 musi używać application/pdf:

import base64

with open("report.pdf", "rb") as f:
    pdf_data = base64.standard_b64encode(f.read()).decode("utf-8")

payload = {
    "model": "claude-fable-5-1",
    "max_tokens": 1024,
    "messages": [{
        "role": "user",
        "content": [
            {
                "type": "document",
                "source": {
                    "type": "base64",
                    "media_type": "application/pdf",
                    "data": pdf_data
                },
                "title": "Raport kwartalny"
            },
            {"type": "text", "text": "Podsumuj ten PDF."}
        ]
    }]
}

Źródło URL zapisuje się jako {"type":"url","url":"https://example.com/report.pdf"}. document wspiera również text/plain oraz źródła content składające się z bloków text/image; opcjonalne pola to title, context i citations. Źródło file_id API plików należy do niezależnej funkcji beta i nie jest objęte stabilnym kontraktem tego interfejsu.

Cache podpowiedzi

Najwyższy poziom cache_control automatycznie umieszcza punkty przerwania w ostatnim możliwym bloku do buforowania:

payload = {
    "model": "claude-fable-5-1",
    "max_tokens": 1024,
    "cache_control": {"type": "ephemeral", "ttl": "5m"},
    "system": "Jesteś ekspertem w tej materiałach referencyjnych.",
    "messages": [{"role": "user", "content": "Podsumuj kluczowe punkty."}]
}

Gdy potrzebna jest precyzyjna kontrola pozycji, można również umieścić ten sam cache_control w blokach zawartości text, image, document, tool_use, tool_result lub definicji narzędzi. ttl wspiera 5m (domyślnie) oraz 1h; proszę ocenić zapis i trafienie bufora przez usage.cache_creation_input_tokens i usage.cache_read_input_tokens. Przykład zwracanej odpowiedzi:

{
  "id": "msg_01NCrxpZmV17bhQJJRQEFEb9",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Ten obraz przedstawia interfejs konfiguracji żądania API dla tego, co wydaje się być usługą zakończenia czatu AI. Interfejs zawiera parametry do wyboru modelu, wiadomości, trybu strumieniowego i ustawień maksymalnej liczby tokenów."
    }
  ],
  "model": "claude-sonnet-4-20250514",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 1570,
    "output_tokens": 52
  }
}

Wywołanie narzędzi (Tool Use)

API wiadomości Claude natywnie wspiera funkcję wywoływania narzędzi, pozwalając modelowi na wywoływanie zdefiniowanych przez Ciebie narzędzi/funkcji w razie potrzeby.

Przykład w Pythonie

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "tools": [
        {
            "name": "get_weather",
            "description": "Pobierz aktualną pogodę w danej lokalizacji",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Miasto i stan, np. San Francisco, CA"
                    }
                },
                "required": ["location"]
            }
        }
    ],
    "messages": [
        {"role": "user", "content": "Jaka jest pogoda w San Francisco?"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Gdy model zdecyduje się na wywołanie narzędzia, w zwróconym wyniku content będzie zawierać blok zawartości typu tool_use:

{
  "id": "msg_01Aq9w938a90dw8q",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Pozwól, że sprawdzę pogodę w San Francisco dla Ciebie."
    },
    {
      "type": "tool_use",
      "id": "toolu_01A09q90qw90lq917835lgs",
      "name": "get_weather",
      "input": {
        "location": "San Francisco, CA"
      }
    }
  ],
  "model": "claude-sonnet-4-20250514",
  "stop_reason": "tool_use",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 120,
    "output_tokens": 68
  }
}

Zauważ, że stop_reason to tool_use, co oznacza, że model potrzebuje wywołać narzędzie. Po otrzymaniu tego wyniku, musisz wykonać funkcję narzędzia i zwrócić wynik w formie tool_result do modelu:

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "tools": [
        {
            "name": "get_weather",
            "description": "Pobierz aktualną pogodę w danej lokalizacji",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Miasto i stan, np. San Francisco, CA"
                    }
                },
                "required": ["location"]
            }
        }
    ],
    "messages": [
        {"role": "user", "content": "Jaka jest pogoda w San Francisco?"},
        {
            "role": "assistant",
            "content": [
                {"type": "text", "text": "Pozwól, że sprawdzę pogodę w San Francisco dla Ciebie."},
                {"type": "tool_use", "id": "toolu_01A09q90qw90lq917835lgs", "name": "get_weather", "input": {"location": "San Francisco, CA"}}
            ]
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": "toolu_01A09q90qw90lq917835lgs",
                    "content": "Słonecznie, 72°F"
                }
            ]
        }
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Model będzie generować ostateczną odpowiedź w naturalnym języku na podstawie wyników zwróconych przez narzędzie.

Różnice w stosunku do API Chat Completion

Ace Data Cloud oferuje dwa formaty API Claude, a główne różnice są następujące: usage.input_tokens w API Messages oznacza tylko niebuforowane wejście, cache_read_input_tokens i cache_creation_input_tokens są niezależnie rozliczane; wszystkie trzy będą rozliczane według odpowiednich cen.

Cecha	API Messages (`/v1/messages`)	API Chat Completion (`/v1/chat/completions`)
Format	Format natywny Anthropic	Format zgodny z OpenAI
System prompt	Niezależne pole `system`	Przekazywane przez `messages` w `role: "system"`
Struktura odpowiedzi	Tablica `content` (obsługuje różne typy)	Tablica `choices` (zawiera `message`)
Format strumieniowy	Wydarzenia SSE (wiele typów wydarzeń)	Linie SSE `data`
Głębokie myślenie	Natywny parametr `thinking`	Wyzwalane przez specjalną nazwę modelu (np. sufiks `-thinking`)
Wywołanie narzędzi	Natywne `tools` + `input_schema`	Zgodny z OpenAI format `functions`
Statystyka tokenów	`input_tokens` / `output_tokens`	`prompt_tokens` / `completion_tokens`

Jeśli Twój system już zintegrował API w formacie OpenAI, możesz użyć API Chat Completion do płynnego przełączenia. Jeśli potrzebujesz korzystać z pełnych natywnych możliwości Claude’a, zaleca się użycie API Messages.

Obsługa błędów

Odpowiedzi błędów z publicznego interfejsu używają envelope platformy Ace Data Cloud: error.code to stabilny kod błędu, error.message to opis, a trace_id służy do diagnozowania żądań. Typowe statusy HTTP obejmują:

400: Nieprawidłowe parametry żądania lub treść protokołu.
401: Nieprawidłowy, brakujący lub wygasły token autoryzacji.
403: Zabroniony dostęp, niewystarczające saldo lub ograniczenia kwotowe.
404: API lub model nie istnieje.
413: Zbyt duża treść żądania.
429: Zbyt wiele żądań.
500 / 503 / 504: Błąd serwisu, tymczasowo niedostępny lub przekroczenie czasu przetwarzania.

Przykład odpowiedzi błędu

{
  "error": {
    "code": "api_error",
    "message": "pobieranie nie powiodło się"
  },
  "trace_id": "2cf86e86-22a4-46e1-ac2f-032c0f2a4e89"
}

Ta struktura błędu jest umową czasową Ace Data Cloud, nie jest równoznaczna z oficjalnym envelope błędów Anthropic; proszę obsługiwać zgodnie z statusem HTTP i error.code.

Wnioski

Dzięki temu dokumentowi zrozumiałeś, jak korzystać z API Claude Messages w natywnym formacie Anthropic do wywoływania funkcji konwersacyjnych Claude’a. API Messages obsługuje podstawowe rozmowy, systemowe podpowiedzi, odpowiedzi strumieniowe, wieloetapowe rozmowy, głębokie myślenie, zrozumienie wizualne, PDF, buforowanie podpowiedzi i wywołania narzędzi. W razie jakichkolwiek pytań, prosimy o kontakt z naszym zespołem wsparcia technicznego.

Getting Started

Czat AI

Obraz AI

Wideo AI

Audio AI

Sieć i dane

CAPTCHA

Tożsamość

Proxy

Advanced

Coding

Claude Messages API 申请及使用

申请流程

基本使用

cURL 示例

Python 示例

系统提示词

Python 示例

流式响应

Python 示例

Przykład JavaScript

Wiele rund rozmowy

Przykład Python

Model głębokiego myślenia

Model wizualny

Użycie obrazu z URL

Przykład cURL

Dokumenty i PDF

Cache podpowiedzi

Wywołanie narzędzi (Tool Use)

Przykład w Pythonie

Różnice w stosunku do API Chat Completion

Obsługa błędów

Przykład odpowiedzi błędu

Wnioski

​申请流程

​基本使用

​cURL 示例

​Python 示例

​系统提示词

​Python 示例

​流式响应

​Python 示例

​Przykład JavaScript

​Wiele rund rozmowy

​Przykład Python

​Model głębokiego myślenia

​Model wizualny

​Użycie obrazu z URL

​Przykład cURL

​Dokumenty i PDF

​Cache podpowiedzi

​Wywołanie narzędzi (Tool Use)

​Przykład w Pythonie

​Różnice w stosunku do API Chat Completion

​Obsługa błędów

​Przykład odpowiedzi błędu

​Wnioski

申请流程

基本使用

cURL 示例

Python 示例

系统提示词

Python 示例

流式响应

Python 示例

Przykład JavaScript

Wiele rund rozmowy

Przykład Python

Model głębokiego myślenia

Model wizualny

Użycie obrazu z URL

Przykład cURL

Dokumenty i PDF

Cache podpowiedzi

Wywołanie narzędzi (Tool Use)

Przykład w Pythonie

Różnice w stosunku do API Chat Completion

Obsługa błędów

Przykład odpowiedzi błędu

Wnioski