claude-opus-5-5

Claude Opus 5.5 is the first model in Anthropic's Claude 5.5 family, for coding, research, and knowledge work. Its model ID is claude-opus-5-5. Use the OpenAI-compatible Chat Completions endpoint with your reAPI key and credit balance. Current input and output rates are on the model page.

The model supports a 1,000,000-token context window and 128,000 maximum output tokens, including thinking. Adaptive thinking is always on; Anthropic's native default effort is medium. The examples set it explicitly.

Quick example

curl --no-buffer https://reapi.ai/api/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-5-5",
    "messages": [
      { "role": "user", "content": "Review this module and suggest a minimal fix with a verification plan." }
    ],
    "reasoning_effort": "medium",
    "max_tokens": 4096,
    "stream": true
  }'

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://reapi.ai/api/v1",
)

stream = client.chat.completions.create(
    model="claude-opus-5-5",
    messages=[{"role": "user", "content": "Review this module and suggest a minimal fix with a verification plan."}],
    reasoning_effort="medium",
    max_tokens=4096,
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta.content if chunk.choices else None
    if delta:
        print(delta, end="")

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://reapi.ai/api/v1",
});

const stream = await client.chat.completions.create({
  model: "claude-opus-5-5",
  messages: [{ role: "user", content: "Review this module and suggest a minimal fix with a verification plan." }],
  reasoning_effort: "medium",
  max_tokens: 4096,
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

package main

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

func main() {
    body, _ := json.Marshal(map[string]any{
        "model": "claude-opus-5-5",
        "messages": []map[string]string{
            {"role": "user", "content": "Review this module and suggest a minimal fix with a verification plan."},
        },
        "reasoning_effort": "medium",
        "max_tokens":       4096,
    })
    req, _ := http.NewRequest("POST",
        "https://reapi.ai/api/v1/chat/completions", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    out, _ := io.ReadAll(resp.Body)
    fmt.Println(string(out))
}

Authentication and endpoint

Create a key under API keys in your reAPI dashboard. Keep it server-side and send Authorization: Bearer YOUR_API_KEY.

POST https://reapi.ai/api/v1/chat/completions

For OpenAI-compatible SDKs, use https://reapi.ai/api/v1 as the base URL. This is a synchronous chat API with optional streaming, not a media generation job: there is no task ID to poll or webhook to configure.

Request parameters

The page's text playground exposes the output budget, streaming, effort, and stop controls. Leave room in the output budget for both thinking and the visible answer. The normal chat ceiling does not include Anthropic's batch-only extended output beta.

Verified compatibility

Live parameter checks on September 23, 2026 confirmed ordinary replies, all five documented effort values, SSE completion, output truncation at the requested cap, stop sequences, and automatic function calls. These checks used the serving endpoint directly; they do not constitute a full billing or model-capability certification.

response_format did not enforce a JSON schema: the request succeeded but returned plain text. Native output_config.format on this Chat Completions endpoint also did not enforce the schema. Do not use either field here as a structured-output guarantee.

Anthropic's native Messages format supports different fields, including thinking and output_config. A native-format request succeeding elsewhere does not make those fields usable on this endpoint. Use reasoning_effort here. Follow the model's documented auto / none tool selection rather than relying on acceptance of forced-tool or disabled-thinking values.

Fields that do not control this model

The request conversion strips temperature, top_p, and top_k on this model family. OpenAI-only fields frequency_penalty, presence_penalty, logprobs, n, and seed have no corresponding control on this conversion path. Do not use them to tune generation or request multiple choices. The playground omits these controls. Additional JSON fields are forwarded, but acceptance alone does not establish that they affect the model.

Do not send reasoning_effort: "none" to disable thinking: Opus 5.5 does not support disabling it. Use one of the five supported effort levels instead. Native thinking budgets, computer-use tools, batch options, and beta features are not automatically available through this Chat Completions interface.

Reasoning effort

Start with medium, then compare results on representative tasks. low can suit simpler requests; high, xhigh, and max allow deeper work. Higher effort can increase output-token usage and latency. Thinking tokens count toward both your output allowance and billed output usage.

When migrating from Opus 5, replace the model ID and evaluate your effort settings. The native default changed from high to medium. Do not carry over configurations that disable thinking or force tool selection.

Tool calling

The text playground does not execute tools or display a full tool-use loop. Use the API from your application for tool calling.

Your application supplies function definitions in tools, reads returned tool_calls, executes the approved functions, and sends the tool results back in the conversation. The model does not execute your code or access your files on its own. Use automatic selection; requiring any tool or a particular tool is not supported by Opus 5.5. Validate all arguments before executing a function.

For native Anthropic integrations, follow the vendor's thinking-block preservation rules. Those native message blocks are distinct from the Chat Completions format shown here.

Responses

A non-streaming response follows the Chat Completions shape. This is an illustrative response, not a measured request:

{
  "id": "chatcmpl-example",
  "object": "chat.completion",
  "model": "claude-opus-5-5",
  "choices": [{
    "index": 0,
    "message": {"role": "assistant", "content": "Here is the review."},
    "finish_reason": "stop"
  }],
  "usage": {"prompt_tokens": 100, "completion_tokens": 200, "total_tokens": 300}
}

With stream: true, read data: events containing chat.completion.chunk objects. Text arrives in choices[0].delta.content; tool calls arrive in delta.tool_calls. Handle empty choices arrays and the final data: [DONE] marker. Inspect finish_reason for truncation or refusal instead of treating all HTTP 200 responses as complete answers.

Billing

Requests use your existing reAPI credit balance. Input and output tokens have separate rates, displayed on the model page. Thinking counts as output. The serving system's reported request cost is used for settlement after delivery. The output limit bounds generation; it is not an upfront reservation.

The public catalogue currently lists input and output rates for this model. Do not assume Anthropic's native cache, batch, or fast-mode discounts apply. A Claude Pro or Max subscription does not pay for reAPI usage.

Errors and troubleshooting

See the error reference for the platform error envelope.

References

• Claude Opus 5.5 model page
• Claude Fable 5.1 API
• Claude Opus 5 API
• Authentication
• Anthropic's Opus 5.5 announcement
• What's new in Opus 5.5