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

# Claude Messages API Ansökan och Användning

> Claude AI 集成指南 - XHuoAPI

Anthropic Claude är ett mycket kraftfullt AI-konversationssystem som kan generera flytande och naturliga svar på bara några sekunder genom att mata in en prompt. Claude Messages API är Anthropics officiella inbyggda API-format, som skiljer sig från OpenAI:s kompatibla format (Chat Completion) genom att använda Anthropics egna begäran och svarstruktur, vilket gör det möjligt att bättre utnyttja Claudes unika förmågor, såsom multimodal innehållsinmatning, verktygsanrop, djup tänkande (Extended Thinking) och andra avancerade funktioner.

Detta dokument beskriver huvudsakligen användningsflödet för Claude Messages API, vilket gör att vi kan använda ett inbyggt gränssnitt som är i linje med Anthropics officiella för att anropa Claudes konversationsfunktioner.

## Ansökningsprocess

För att använda Claude Messages API kan du först gå till [Claude Messages API](https://api.xhuoapi.ai/documents/280928a2-2dce-419c-adb5-1ea835e8183a) sidan och klicka på "Acquire"-knappen för att få de nödvändiga autentiseringsuppgifterna:

![](https://cdn.xhuoapi.ai/nyq0xz.png)

Om du inte har loggat in eller registrerat dig kommer du automatiskt att omdirigeras till inloggningssidan där du uppmanas att registrera dig och logga in. Efter att ha loggat in eller registrerat dig kommer du automatiskt att återvända till den aktuella sidan.

Vid första ansökan kommer det att finnas en gratis kvot som gör att du kan använda API:et kostnadsfritt.

## Grundläggande Användning

Begärans väg för Claude Messages API är `/v1/messages`, vilket är i linje med Anthropics officiella API. Vi behöver minst tillhandahålla tre obligatoriska parametrar:

* `model`: Välj vilken Claude-modell som ska användas, som `claude-opus-4-20250514`, `claude-sonnet-4-20250514` etc.
* `messages`: Inmatningsmeddelande-array, där varje meddelande innehåller `role` (roll) och `content` (innehåll), där `role` stöder `user` och `assistant`.
* `max_tokens`: Maximalt antal utdata-token, som används för att begränsa längden på ett enstaka svar.

Vanliga valfria parametrar:

* `system`: Systemprompt, som används för att ställa in modellens beteende och roll.
* `temperature`: Genereringsslumptal, mellan 0-1, där ett högre värde ger mer spridda svar.
* `stream`: Om strömmande svar ska användas, sätts till `true` för att uppnå ett ord-för-ord-returresultat.
* `stop_sequences`: Anpassade stoppsekvenser, modellen slutar generera när den stöter på dessa texter.
* `top_p`: Kärnprovningsparameter, som tillsammans med temperature kontrollerar den genererade slumpmässigheten.
* `top_k`: Prover endast från de K mest sannolika alternativen.
* `tools`: Verktygsdefinition, som gör att modellen kan anropa externa funktioner.
* `tool_choice`: Kontrollerar hur modellen använder de tillhandahållna verktygen.

### cURL Exempel

```bash theme={null}
curl -X POST 'https://api.xhuoapi.ai/v1/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": "Hello, Claude"
      }
    ]
  }'
```

### Python Exempel

```python theme={null}
import requests

url = "https://api.xhuoapi.ai/v1/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": "Hello, Claude"}
    ]
}

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

Efter anropet returneras följande resultat:

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

Förklaring av returresultatsfält:

* `id`: Den unika identifieraren för detta meddelande.
* `type`: Alltid `message`.
* `role`: Alltid `assistant`.
* `content`: Svarsinnehållsarray, där varje element innehåller `type` (som `text`) och motsvarande innehåll.
* `model`: Namnet på modellen som hanterar begäran.
* `stop_reason`: Anledningen till att det stoppades, möjliga värden inkluderar `end_turn` (normal avslutning), `max_tokens` (nått maximal längd), `stop_sequence` (stött på stoppsekvens), `tool_use` (verktygsanrop).
* `stop_sequence`: Om det stoppades på grund av en anpassad stoppsekvens, visas den matchande stoppsekvensens text.
* `usage`: Token-användningsstatistik, inklusive `input_tokens` (antal inmatningstoken) och `output_tokens` (antal utmatningstoken).

## Systemprompt

Claude Messages API stöder att ställa in systemprompt genom `system`-fältet, vilket används för att definiera modellens beteende, roll och kontext.

### Python Exempel

```python theme={null}
import requests

url = "https://api.xhuoapi.ai/v1/v1/messages"

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

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "system": "Du är en professionell kinesisk översättningsassistent, vänligen översätt användarens inmatade engelska till kinesiska.",
    "messages": [
        {"role": "user", "content": "The quick brown fox jumps over the lazy dog."}
    ]
}

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

Genom att ställa in `system`-prompten kan man exakt kontrollera Claudes roll och beteende.

## Strömmande Svar

Detta gränssnitt stöder också strömmande svar, genom att sätta `stream`-parametern till `true` kan man få ett steg-för-steg-returresultat, vilket är mycket lämpligt för att implementera ord-för-ord-visning på en webbsida.

### Python Exempel

```python theme={null}
import requests

url = "https://api.xhuoapi.ai/v1/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": "Hello, Claude"}
    ]
}

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

Strömmande svar returneras i Server-Sent Events (SSE) format, där varje rad inleds med `event:` och `data:`. Typer av strömmande händelser inkluderar:

* `message_start`: Meddelande börjar, innehåller grundläggande information om meddelandet och modellens namn.
* `content_block_start`: Innehållsblock börjar.
* `content_block_delta`: Innehållsblockets inkrementella uppdatering, innehåller nygenererade textstycken.
* `content_block_stop`: Innehållsblock slutar.
* `message_delta`: Inkrementell uppdatering på meddelandenivå, innehåller `stop_reason` och slutlig `usage` information.
* `message_stop`: Meddelande slutar.

Utdataeffekten ser ut som följer:

```
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":"Hej"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"! Mitt namn är"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" Claude. Hur kan jag hjälpa dig idag?"}}

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"}
```

Kan ses, att den strömmande responsen innehåller `content_block_delta` händelser som inkluderar stegvis genererat textinnehåll, genom att sammanfoga alla `text_delta` kan man få den fullständiga svaret.

### JavaScript Exempel

```javascript theme={null}
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: "Hej, Claude" }],
  }),
};

const response = await fetch("https://api.xhuoapi.ai/v1/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));
}
```

## Flera rundor av dialog

Om du vill integrera flera rundor av dialogfunktionalitet, behöver du växla mellan `user` och `assistant` roller i `messages` arrayen och inkludera tidigare dialoghistorik.

### Python Exempel

```python theme={null}
import requests

url = "https://api.xhuoapi.ai/v1/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": "Hej, mitt namn är Alice."},
        {"role": "assistant", "content": "Hej Alice! Trevligt att träffas. Hur kan jag hjälpa dig idag?"},
        {"role": "user", "content": "Vad är mitt namn?"}
    ]
}

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

Resultatet blir som följer:

```json theme={null}
{
  "id": "msg_01Y1wfQmd89g968TVbFu57Yc",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Ditt namn är Alice, som du just berättade för mig!"
    }
  ],
  "model": "claude-sonnet-4-20250514",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 40,
    "output_tokens": 14
  }
}
```

Genom att skicka den fullständiga dialoghistoriken i `messages`, kan Claude kombinera kontexten för att ge exakta svar.

## Djup tänkande modell

Claude stöder Extended Thinking (djup tänkande) funktionalitet, vilket gör att modellen kan utföra intern resonemang innan den svarar, vilket ökar noggrannheten vid hantering av komplexa frågor. För att använda denna funktion måste `thinking` parametern skickas.

### Python Exempel

```python theme={null}
import requests

url = "https://api.xhuoapi.ai/v1/v1/messages"

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

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 16000,
    "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
    },
    "messages": [
        {"role": "user", "content": "Vad är sinus av 30 grader? Visa ditt resonemang."}
    ]
}

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

Resultatet blir som följer:

```json theme={null}
{
  "id": "msg_018J4YaRoGHtbsTVb4Vvz7oH",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "thinking",
      "thinking": "Användaren frågar efter sinus av 30 grader. Detta är en grundläggande trigonometrifråga.\n\nI en 30-60-90 triangel är sidorna i förhållandet 1:√3:2.\n\nFör en 30° vinkel:\n- Den motsatta sidan är 1\n- Hypotenusan är 2\n- Så sin(30°) = motsatt/hypotenusa = 1/2 = 0.5"
    },
    {
      "type": "text",
      "text": "Sinus av 30 grader är **1/2** eller **0.5**.\n\nDetta är ett av de grundläggande trigonometriska värdena. I en 30-60-90 triangel är sidorna i förhållandet 1:√3:2, där sidan motsatt till 30° vinkeln har längd 1 och hypotenusan har längd 2, vilket ger oss sin(30°) = 1/2."
    }
  ],
  "model": "claude-sonnet-4-20250514",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 28,
    "output_tokens": 239
  }
}
```

Det kan ses att `content` arrayen innehåller två innehållsblock:

* `type: "thinking"`: modellens interna tänkande process, som visar resonemanget.
* `type: "text"`: det slutliga svaret.

Viktiga punkter:

* När `thinking` används, måste `max_tokens` vara större än `budget_tokens`, eftersom `budget_tokens` är den tokenbudget som tilldelas tänkande processen.
* Ju större `budget_tokens`, desto mer utrymme har modellen för djupare resonemang, vilket är lämpligt för att hantera komplexa frågor.

## Visuell modell

Claude stöder multimodal inmatning och kan samtidigt hantera text och bilder. I Messages API kan du använda visuella funktioner genom att ställa in `content` som en array och inkludera bildinnehållsblock.

### Använda Base64-kodad bild

```python theme={null}
import base64
import requests

url = "https://api.xhuoapi.ai/v1/v1/messages"

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

# Läs och koda bilden
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": "Vad finns i denna bild?"
                }
            ]
        }
    ]
}

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

### Använda URL-bild

````
```python
import requests

url = "https://api.xhuoapi.ai/v1/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.xhuoapi.ai/ueugot.png"
                    }
                },
                {
                    "type": "text",
                    "text": "Vad finns i den här bilden?"
                }
            ]
        }
    ]
}

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

### cURL Exempel

```bash theme={null}
curl -X POST 'https://api.xhuoapi.ai/v1/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.xhuoapi.ai/ueugot.png"
            }
          },
          {
            "type": "text",
            "text": "Vad'\''s i den här bilden?"
          }
        ]
      }
    ]
  }'
```

Stödda bildformat inkluderar: `image/jpeg`, `image/png`, `image/gif`, `image/webp`.

Exempel på returresultat:

```json theme={null}
{
  "id": "msg_01NCrxpZmV17bhQJJRQEFEb9",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Den här bilden visar ett API-förfrågningskonfigurationsgränssnitt för vad som verkar vara en AI-chattkompletteringstjänst. Gränssnittet inkluderar parametrar för modellval, meddelanden, strömningläge och inställningar för max tokens."
    }
  ],
  "model": "claude-sonnet-4-20250514",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 1570,
    "output_tokens": 52
  }
}
```

## Verktygsanrop (Tool Use)

Claude Messages API stöder inbyggd verktygsanropsfunktionalitet, vilket gör att modellen kan anropa fördefinierade verktyg/funktioner vid behov.

### Python Exempel

```python theme={null}
import requests

url = "https://api.xhuoapi.ai/v1/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": "Hämta det aktuella vädret på en given plats",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Staden och staten, t.ex. San Francisco, CA"
                    }
                },
                "required": ["location"]
            }
        }
    ],
    "messages": [
        {"role": "user", "content": "Hur är vädret i San Francisco?"}
    ]
}

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

När modellen beslutar att anropa ett verktyg kommer `content` i returresultatet att innehålla en innehållsblock av typen `tool_use`:

```json theme={null}
{
  "id": "msg_01Aq9w938a90dw8q",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Låt mig kolla vädret i San Francisco för dig."
    },
    {
      "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
  }
}
```

Observera att `stop_reason` är `tool_use`, vilket indikerar att modellen behöver anropa ett verktyg. När du får detta resultat måste du utföra verktygsfunktionen och återföra resultatet i form av `tool_result` till modellen:

```python theme={null}
payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "tools": [
        {
            "name": "get_weather",
            "description": "Hämta det aktuella vädret på en given plats",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Staden och staten, t.ex. San Francisco, CA"
                    }
                },
                "required": ["location"]
            }
        }
    ],
    "messages": [
        {"role": "user", "content": "Hur är vädret i San Francisco?"},
        {
            "role": "assistant",
            "content": [
                {"type": "text", "text": "Låt mig kolla vädret i San Francisco för dig."},
                {"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": "Soligt, 22°C"
                }
            ]
        }
    ]
}

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

Modellen kommer att generera det slutliga naturliga språksvaret baserat på resultatet från verktyget.

## Skillnader mellan Chat Completion API

XHuoAPI erbjuder två typer av Claude API-format, de huvudsakliga skillnaderna är som följer:

| Funktion        | Messages API (`/v1/messages`)         | Chat Completion API (`/v1/chat/completions`)                 |
| --------------- | ------------------------------------- | ------------------------------------------------------------ |
| Format          | Anthropic inbyggt format              | OpenAI kompatibelt format                                    |
| Systemprompt    | Separat `system` fält                 | Genom `messages` med `role: "system"`                        |
| Svarstruktur    | `content` array (stödjer flera typer) | `choices` array (innehåller `message`)                       |
| Strömformat     | SSE-händelser (flera händelsetyper)   | SSE `data` rader                                             |
| Djup tänkande   | Inbyggd `thinking` parameter          | Utlöses genom särskilt modellnamn (t.ex. `-thinking` suffix) |
| Verktygsanrop   | Inbyggda `tools` + `input_schema`     | OpenAI kompatibelt `functions` format                        |
| Token statistik | `input_tokens` / `output_tokens`      | `prompt_tokens` / `completion_tokens`                        |

Om ditt system redan är integrerat med OpenAI-formatet kan du använda Chat Completion API för att sömlöst växla. Om du behöver använda Claudes fulla inbyggda kapabiliteter rekommenderas det att använda Messages API.

## Felhantering

Vid anrop av API:et, om ett fel uppstår, kommer API:et att returnera motsvarande felkod och information. Till exempel:

* `400 token_mismatched`: Felaktig begäran, möjligtvis på grund av saknade eller ogiltiga parametrar.
* `400 api_not_implemented`: Felaktig begäran, möjligtvis på grund av saknade eller ogiltiga parametrar.
* `401 invalid_token`: Obemyndigad, ogiltig eller saknad auktoriseringstoken.
* `429 too_many_requests`: För många förfrågningar, du har överskridit hastighetsgränsen.
* `500 api_error`: Internt serverfel, något gick fel på servern.

### Exempel på felrespons

```json theme={null}
{
  "success": false,
  "error": {
    "code": "api_error",
    "message": "hämtning misslyckades"
  },
  "trace_id": "2cf86e86-22a4-46e1-ac2f-032c0f2a4e89"
}
```

## Slutsats

Genom detta dokument har du fått en förståelse för hur man använder Claude Messages API för att anropa Claudes samtalsfunktioner i Anthropic inhemskt format. Messages API stöder grundläggande samtal, systempromptar, strömmande svar, flerrundiga samtal, djupgående tänkande, visuell förståelse och verktygsanrop med flera rika funktioner. Om du har några frågor, tveka inte att kontakta vårt tekniska supportteam.