Anthropic Messages API NEW

Overview

The Anthropic Messages API is an alternative request/response format for interacting with LLM Resayil models. While our OpenAI-compatible /v1/chat/completions endpoint remains fully supported, the Messages API provides a familiar interface for developers already using the Anthropic ecosystem.

Why Use the Messages API?

• Drop-in compatibility: Use the official Anthropic Python or TypeScript SDK by changing only the base URL.
• Same backend: Both endpoints route to the same models, use the same credit system, and share the same authentication.
• Structured tool calling: The Messages API supports the Anthropic tool-use format for function calling.
• Streaming with events: Server-sent events with typed event blocks (message_start, content_block_delta, etc.).

Authentication

The Messages API accepts the same authentication methods as all other LLM Resayil endpoints. You can use either the standard Authorization: Bearer header or the Anthropic-style x-api-key header.

Option 1: Bearer Token (Standard)

Authorization: Bearer YOUR_API_KEY

Option 2: x-api-key Header (Anthropic-style)

x-api-key: YOUR_API_KEY

Both methods are equivalent. The x-api-key header is supported for compatibility with the official Anthropic SDK, which sends credentials this way by default.

Basic Usage

Send a POST request to /v1/messages with a JSON body containing your model selection and messages.

Endpoint

POST https://llmapi.resayil.io/v1/messages

Simple Text Request

curl -X POST https://llmapi.resayil.io/v1/messages \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "mistral",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "What is the capital of France?"}
    ]
  }'

Response

{
  "id": "msg_01XFDUDYJgAACzvnptvVoYEL",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "The capital of France is Paris."
    }
  ],
  "model": "mistral",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 14,
    "output_tokens": 9
  }
}

Request Format

The full request body specification for POST /v1/messages.

System Message

Unlike the OpenAI format where the system prompt is a message with "role": "system", the Anthropic format uses a top-level system field:

{
  "model": "mistral",
  "max_tokens": 1024,
  "system": "You are a helpful assistant who speaks formally.",
  "messages": [
    {"role": "user", "content": "Greet me."}
  ]
}

Multi-turn Conversation

{
  "model": "llama3.1",
  "max_tokens": 2048,
  "messages": [
    {"role": "user", "content": "What is machine learning?"},
    {"role": "assistant", "content": "Machine learning is a subset of AI..."},
    {"role": "user", "content": "Can you give me a practical example?"}
  ]
}

Response Format

Non-streaming responses return a complete message object.

Full Response Example

{
  "id": "msg_01A2B3C4D5E6F7G8H9I0J1K2",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Here is a Python function that calculates factorial:\n\n```python\ndef factorial(n):\n    if n <= 1:\n        return 1\n    return n * factorial(n - 1)\n```"
    }
  ],
  "model": "mistral",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 22,
    "output_tokens": 48
  }
}

Streaming

Set "stream": true to receive the response as a stream of server-sent events (SSE). Each event has an event type and a data payload.

Streaming Request

curl -X POST https://llmapi.resayil.io/v1/messages \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "mistral",
    "max_tokens": 1024,
    "stream": true,
    "messages": [
      {"role": "user", "content": "Write a haiku about coding."}
    ]
  }'

Event Types

Streaming Response Example

event: message_start
data: {"type":"message_start","message":{"id":"msg_01ABC","type":"message","role":"assistant","content":[],"model":"mistral","stop_reason":null,"usage":{"input_tokens":15,"output_tokens":0}}}

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

event: ping
data: {"type":"ping"}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Lines"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" of"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" code"}}

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

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"output_tokens":12}}

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

Tool Calling

The Messages API supports tool (function) calling using the Anthropic tool-use format. Define tools in your request, and the model may respond with a tool_use content block.

Step 1: Define Tools

{
  "model": "mistral",
  "max_tokens": 1024,
  "tools": [
    {
      "name": "get_weather",
      "description": "Get the current weather for a given location.",
      "input_schema": {
        "type": "object",
        "properties": {
          "location": {
            "type": "string",
            "description": "City and country, e.g. London, UK"
          },
          "unit": {
            "type": "string",
            "enum": ["celsius", "fahrenheit"],
            "description": "Temperature unit"
          }
        },
        "required": ["location"]
      }
    }
  ],
  "messages": [
    {"role": "user", "content": "What is the weather in Kuwait City?"}
  ]
}

Step 2: Handle tool_use Response

When the model decides to use a tool, the response includes a tool_use content block:

{
  "id": "msg_01XYZ",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "tool_use",
      "id": "toolu_01ABC",
      "name": "get_weather",
      "input": {
        "location": "Kuwait City, Kuwait",
        "unit": "celsius"
      }
    }
  ],
  "stop_reason": "tool_use",
  "usage": {"input_tokens": 85, "output_tokens": 42}
}

Step 3: Send Tool Result

Execute the tool on your end and send the result back:

{
  "model": "mistral",
  "max_tokens": 1024,
  "messages": [
    {"role": "user", "content": "What is the weather in Kuwait City?"},
    {
      "role": "assistant",
      "content": [
        {
          "type": "tool_use",
          "id": "toolu_01ABC",
          "name": "get_weather",
          "input": {"location": "Kuwait City, Kuwait", "unit": "celsius"}
        }
      ]
    },
    {
      "role": "user",
      "content": [
        {
          "type": "tool_result",
          "tool_use_id": "toolu_01ABC",
          "content": "Currently 38C and sunny in Kuwait City."
        }
      ]
    }
  ]
}

Error Handling

Errors from the Messages API follow the Anthropic error format:

{
  "type": "error",
  "error": {
    "type": "invalid_request_error",
    "message": "max_tokens: field required"
  }
}

OpenAI vs Anthropic: Endpoint Comparison

Both endpoints coexist on the same backend. Here is a side-by-side comparison:

Code Examples

Python (Anthropic SDK)

Install the official Anthropic SDK and point it at LLM Resayil:

pip install anthropic

import anthropic

client = anthropic.Anthropic(
    api_key="YOUR_API_KEY",
    base_url="https://llmapi.resayil.io/v1"
)

message = client.messages.create(
    model="mistral",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain quantum computing in simple terms."}
    ]
)

print(message.content[0].text)

Python (Anthropic SDK with Streaming)

import anthropic

client = anthropic.Anthropic(
    api_key="YOUR_API_KEY",
    base_url="https://llmapi.resayil.io/v1"
)

with client.messages.stream(
    model="mistral",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Write a short story about AI."}
    ]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

Node.js (Anthropic SDK)

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

const client = new Anthropic({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://llmapi.resayil.io/v1'
});

const message = await client.messages.create({
  model: 'mistral',
  max_tokens: 1024,
  messages: [
    { role: 'user', content: 'What are the benefits of TypeScript?' }
  ]
});

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

cURL with System Prompt

curl -X POST https://llmapi.resayil.io/v1/messages \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "llama3.1",
    "max_tokens": 2048,
    "system": "You are a senior software architect. Answer concisely.",
    "messages": [
      {"role": "user", "content": "When should I use microservices vs monolith?"}
    ]
  }'

Feature Support Matrix

What is currently supported and what is not in our Messages API implementation:

Integration Guide

If you already use the Anthropic SDK, switching to LLM Resayil requires minimal changes.

Environment Variable Setup

Set the following environment variables for your application:

ANTHROPIC_BASE_URL=https://llmapi.resayil.io/v1
ANTHROPIC_API_KEY=sk-your-llm-resayil-api-key

Credit System for Anthropic Users

Credits are deducted identically whether you use the OpenAI or Anthropic endpoint. Token usage reported in the response (input_tokens and output_tokens) maps directly to credit consumption based on the model tier:

• Small models (e.g., phi3): 0.5 credits per 1K tokens
• Medium models (e.g., mistral): 1.5 credits per 1K tokens
• Large models (e.g., llama3.1): 3.0 credits per 1K tokens

Check your credit balance on the dashboard or via the Credits documentation.

Switching from Anthropic API

If you are migrating from the official Anthropic API:

1. Create an account at LLM Resayil and generate an API key.
2. Change your base_url to https://llmapi.resayil.io/v1.
3. Replace your Anthropic API key with your LLM Resayil API key.
4. Update model to one of our available models (e.g., "mistral", "llama3.1").
5. Remove any unsupported parameters (cache_control, image blocks).
6. Test your integration on the dev environment at https://llmdev.resayil.io/v1.

Troubleshooting

Common Issues

Frequently Asked Questions

Can I use both endpoints in the same application?

Yes. The OpenAI /v1/chat/completions and Anthropic /v1/messages endpoints coexist independently. You can call either one using the same API key. Credits are shared across both.

Do I need a separate API key for the Messages API?

No. Your existing LLM Resayil API key works for both endpoints. No additional configuration is needed.

Which models can I use with the Messages API?

All models available on LLM Resayil work with both endpoints. The model names are the same (e.g., "mistral", "llama3.1"). Note that Anthropic-specific model names like "claude-3-sonnet" are not available.

Is the credit cost different?

No. Credits are calculated identically regardless of which endpoint you use. The same model with the same token count costs the same credits.

Can I send images or PDFs?

Not currently. Only text content blocks are supported. Image and PDF input will be rejected with an error.

Is the anthropic-version header required?

It is recommended but not strictly required. If omitted, the API defaults to the latest supported version. For production use, pin to 2023-06-01 for consistent behavior.