> ## Documentation Index
> Fetch the complete documentation index at: https://docs.qingbo.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Claude Messages API

* Fully compatible with the Claude Messages API format
* Supports multi-turn conversations and one-shot queries
* Supports multimodal content including text and images

<RequestExample>
  ```bash cURL theme={"system"}
  curl -X POST https://www.qingbo.dev/v1/messages \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -H "anthropic-version: 2023-06-01" \
    -d '{
      "model": "claude-sonnet-4.5",
      "max_tokens": 1024,
      "system": "你是一个专业的AI助手。",
      "messages": [
        {
          "role": "user",
          "content": "解释一下冒泡排序算法。"
        }
      ]
    }'
  ```

  ```python Python theme={"system"}
  import anthropic

  client = anthropic.Anthropic(
      base_url="https://www.qingbo.dev/v1",
      api_key="YOUR_API_KEY"
  )

  message = client.messages.create(
      model="claude-sonnet-4.5",
      max_tokens=1024,
      system="你是一个专业的AI助手。",
      messages=[
          {"role": "user", "content": "解释一下冒泡排序算法。"}
      ]
  )

  print(message.content[0].text)
  ```

  ```javascript JavaScript theme={"system"}
  import Anthropic from '@anthropic-ai/sdk';

  const client = new Anthropic({
    baseURL: 'https://www.qingbo.dev/v1',
    apiKey: 'YOUR_API_KEY'
  });

  const message = await client.messages.create({
    model: 'claude-sonnet-4.5',
    max_tokens: 1024,
    system: '你是一个专业的AI助手。',
    messages: [
      { role: 'user', content: '解释一下冒泡排序算法。' }
    ]
  });

  console.log(message.content[0].text);
  ```

  ```go Go theme={"system"}
  package main

  import (
      "bytes"
      "encoding/json"
      "fmt"
      "io"
      "net/http"
  )

  func main() {
      payload := map[string]interface{}{
          "model":      "claude-sonnet-4.5",
          "max_tokens": 1024,
          "system":     "你是一个专业的AI助手。",
          "messages": []map[string]string{
              {"role": "user", "content": "解释一下冒泡排序算法。"},
          },
      }

      body, _ := json.Marshal(payload)
      req, _ := http.NewRequest("POST", "https://www.qingbo.dev/v1/messages", bytes.NewBuffer(body))
      req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
      req.Header.Set("Content-Type", "application/json")
      req.Header.Set("anthropic-version", "2023-06-01")

      resp, err := http.DefaultClient.Do(req)
      if err != nil {
          panic(err)
      }
      defer resp.Body.Close()

      result, _ := io.ReadAll(resp.Body)
      fmt.Println(string(result))
  }
  ```

  ```java Java theme={"system"}
  import java.net.http.*;
  import java.net.URI;

  public class Main {
      public static void main(String[] args) throws Exception {
          String payload = """
          {
            "model": "claude-sonnet-4.5",
            "max_tokens": 1024,
            "system": "你是一个专业的AI助手。",
            "messages": [
              {"role": "user", "content": "解释一下冒泡排序算法。"}
            ]
          }
          """;

          HttpClient client = HttpClient.newHttpClient();
          HttpRequest request = HttpRequest.newBuilder()
              .uri(URI.create("https://www.qingbo.dev/v1/messages"))
              .header("Authorization", "Bearer YOUR_API_KEY")
              .header("Content-Type", "application/json")
              .header("anthropic-version", "2023-06-01")
              .POST(HttpRequest.BodyPublishers.ofString(payload))
              .build();

          HttpResponse<String> response = client.send(request,
              HttpResponse.BodyHandlers.ofString());
          System.out.println(response.body());
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null} theme={"system"}
  {
    "id": "msg_013Zva2CMHLNnXjNJJKqJ2EF",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
        "text": "你好！我是Claude。很高兴见到你。"
    }
  ],
    "model": "claude-sonnet-4.5",
  "stop_reason": "end_turn",
    "stop_sequence": null,
  "usage": {
      "input_tokens": 12,
      "output_tokens": 18
  }
  }
  ```

  ```json 400 theme={null} theme={"system"}
  {
    "error": {
      "code": 400,
      "message": "Invalid request parameters",
      "type": "invalid_request_error"
    }
  }
  ```

  ```json 401 theme={null} theme={"system"}
  {
    "error": {
      "code": 401,
      "message": "Authentication failed, please check your API key",
      "type": "authentication_error"
    }
  }
  ```

  ```json 429 theme={null} theme={"system"}
  {
    "error": {
      "code": 429,
      "message": "Too many requests, please try again later",
      "type": "rate_limit_error"
    }
  }
  ```

  ```json 500 theme={null} theme={"system"}
  {
    "error": {
      "code": 500,
      "message": "Internal server error, please try again later",
      "type": "server_error"
    }
  }
  ```
</ResponseExample>

## Authorizations

<ParamField header="x-api-key" type="string" required>
  API key used for authentication.

  Visit the [API Key management page](https://qingbo.dev/dashboard/keys) to obtain your API Key.

  Add it to the request header:

  ```
  x-api-key: YOUR_API_KEY
  ```
</ParamField>

<ParamField header="anthropic-version" type="string" required>
  API version.

  Specifies which Claude API version to use.

  Example: `2023-06-01`
</ParamField>

## Body

<ParamField body="model" type="string" required>
  Model name.

  * `claude-opus-4.6` — Claude 4.6 Opus, latest flagship
  * `claude-sonnet-4.6` — Claude 4.6 Sonnet, latest version
  * `claude-opus-4.5` — Claude 4.5 Opus flagship
  * `claude-sonnet-4.5` — Claude 4.5 Sonnet, balanced
  * `claude-haiku-4.5` — Claude 4.5 Haiku, fast response
</ParamField>

<ParamField body="messages" type="array" required>
  Message list with alternating `user` and `assistant` roles.

  <Expandable title="Message object properties">
    <ParamField body="role" type="string" required>
      Role: `user` (user input) or `assistant` (model reply, used for multi-turn conversations or prefilling).
    </ParamField>

    <ParamField body="content" type="string" required>
      Message content. Accepts a string or an array of content blocks (multimodal).
    </ParamField>
  </Expandable>
</ParamField>

<ParamField body="max_tokens" type="integer" required>
  Maximum tokens to generate.

  Maximum number of tokens before generation stops. The model may stop earlier.

  Maximum value varies by model — refer to the model documentation.

  Minimum: 1
</ParamField>

<ParamField body="system" type="string | array">
  System prompt.

  The system prompt defines Claude's role, personality, goals, and instructions.

  **String format:**

  ```json theme={"system"}
  {
    "system": "你是一位专业的Python编程导师"
  }
  ```

  **Structured format:**

  ```json theme={"system"}
  {
    "system": 
    [
      {
        "type": "text",
        "text": "你是一位专业的Python编程导师"
      }
    ]
  }
  ```
</ParamField>

<ParamField body="temperature" type="number">
  Temperature, range 0–1.

  Controls output randomness:

  * Low values (e.g., 0.2): more deterministic, more conservative
  * High values (e.g., 0.8): more random, more creative

  Default: 1.0
</ParamField>

<ParamField body="top_p" type="number">
  Nucleus sampling parameter, range 0–1.

  Uses nucleus sampling. We recommend using either `temperature` or `top_p`, not both.

  Default: 1.0
</ParamField>

<ParamField body="top_k" type="integer">
  Top-K sampling.

  Sample only from the top K highest-probability options to remove "long-tail" low-probability responses.

  Recommended only for advanced use cases.
</ParamField>

<ParamField body="stream" type="boolean">
  Whether to enable streaming output.

  * `true`: Stream the response progressively via Server-Sent Events (SSE).
  * `false`: Return the full response in one go.

  Default: false
</ParamField>

<ParamField body="stop_sequences" type="array">
  Stop sequences.

  Custom text sequences that stop generation when encountered. Up to 4 sequences, each up to 32 tokens long.
</ParamField>

<ParamField body="metadata" type="object">
  Metadata.

  An object used to track or identify the request.
</ParamField>

## Response

<ResponseField name="id" type="string">
  Unique identifier of the message.
</ResponseField>

<ResponseField name="type" type="string">
  Object type, always `message`.
</ResponseField>

<ResponseField name="role" type="string">
  Role, always `assistant`.
</ResponseField>

<ResponseField name="content" type="array">
  Array of message content.

  <Expandable title="Properties">
    <ResponseField name="type" type="string">
      Content type.

      * `text` — Text content
      * `tool_use` — Tool use (if tools are enabled)
    </ResponseField>

    <ResponseField name="text" type="string">
      Text content (when type is `text`).
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="model" type="string">
  Name of the model that actually served the request.
</ResponseField>

<ResponseField name="stop_reason" type="string">
  Reason generation stopped.

  Possible values:

  * `end_turn` — Natural completion
  * `max_tokens` — Reached max token limit
  * `stop_sequence` — Stop sequence encountered
  * `tool_use` — Tool use
</ResponseField>

<ResponseField name="stop_sequence" type="string">
  The triggering stop sequence (if any).
</ResponseField>

<ResponseField name="usage" type="object">
  Token usage statistics.

  <Expandable title="Properties">
    <ResponseField name="input_tokens" type="integer">
      Input tokens.
    </ResponseField>

    <ResponseField name="output_tokens" type="integer">
      Output tokens.
    </ResponseField>
  </Expandable>
</ResponseField>

## Examples

### Single turn

```json theme={null} theme={"system"}
{
  "model": "claude-sonnet-4.5",
  "max_tokens": 1024,
  "messages": [
    {"role": "user", "content": "解释一下量子计算"}
  ]
}
```

### Multi-turn conversation

```json theme={null} theme={"system"}
{
  "model": "claude-sonnet-4.5",
  "max_tokens": 1024,
  "messages": [
    {"role": "user", "content": "你好"},
    {"role": "assistant", "content": "你好！我是Claude。"},
    {"role": "user", "content": "能解释一下AI吗？"}
  ]
}
```

### Using a system prompt

```json theme={null} theme={"system"}
{
  "model": "claude-sonnet-4.5",
  "max_tokens": 1024,
  "system": "你是一位经验丰富的数据科学家，专长包括统计分析和机器学习。",
  "messages": [
    {"role": "user", "content": "如何选择合适的机器学习算法？"}
  ]
}
```

### Prefilling the response

```json theme={null} theme={"system"}
{
  "model": "claude-sonnet-4.5",
  "max_tokens": 1024,
  "messages": [
    {"role": "user", "content": "列出5个Python最佳实践"},
    {"role": "assistant", "content": "以下是5个Python最佳实践：\n\n1."}
  ]
}
```