Anthropic: Claude Opus 5

Claude Opus 5 destina-se a desenvolvimento cuidadoso, análise de informação e trabalho profissional com várias etapas. Suporta raciocínio adaptativo e verificação de resultados através das ferramentas da aplicação.

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions claude-opus-5-thinking

Sobre o modelo

Esta descrição apresenta as capacidades do modelo. As entradas, saídas e opções disponíveis no Ailoot para o método selecionado estão indicadas abaixo.

Claude Opus 5 é um modelo da Anthropic para trabalho profissional regular que exige estudar informação, fazer uma escolha fundamentada e executar a tarefa sequencialmente. O fabricante destaca engenharia de software, cenários empresariais com várias etapas, trabalho científico e análise de dados visuais. A sua apresentação centra-se numa execução cuidadosa e na verificação do próprio resultado.

Identificar a causa, verificar e corrigir

No desenvolvimento, Opus 5 pode investigar a causa principal de um erro e utilizar verificações para avaliar uma alteração proposta. Se o material disponível para comparação for insuficiente, os cenários descritos incluem a criação de uma verificação própria, por exemplo, para o comportamento de um analisador sintático. O trabalho organiza-se em torno dos dados obtidos: o modelo lê-os, escolhe uma ação, observa o resultado e corrige os problemas identificados.

Para executar comandos, editar ficheiros e realizar verificações, a aplicação precisa das ferramentas correspondentes. A iniciativa do modelo refere-se à escolha e à sequência de ações no ambiente disponibilizado; não implica acesso autónomo ao projeto nem capacidade para realizar operações fora da aplicação.

A imagem como dados para um programa

Opus 5 recebe texto e imagens e produz texto. Nos cenários visuais, o fabricante apresenta a extração de geometria de uma imagem e a reconstrução de uma peça através de código escrito. Outros exemplos incluem uma simulação aerodinâmica interativa e uma ilustração de uma célula criadas por programação.

Os formatos de entrada visual comum do fabricante são JPEG/PNG/GIF/WebP, utilizando-se o primeiro fotograma das animações. Na análise nativa, o lado mais comprido é de 2576 píxeis, com 4784 tokens visuais; as imagens grandes são reduzidas antes da análise. O suporte de ficheiros e parâmetros depende do método da aplicação.

Estas tarefas demonstram o trabalho conjunto de análise e engenharia: a imagem pode ser utilizada como material, e o resultado textual, como código ou descrição da solução. Executar a simulação, construir gráficos e produzir o ficheiro pronto exige ferramentas do ambiente; o modelo não dispõe de uma saída integrada separada de imagem ou vídeo.

Profundidade controlável

O raciocínio adaptativo está ativado por predefinição, e o nível normal de effort é high. São suportados low, medium, high, xhigh e max. Nos níveis high e inferiores, o raciocínio pode ser desativado; em xhigh e max, é obrigatório. Esta versão não prevê extended thinking manual com um orçamento separado.

Alterar o esforço influencia o volume do raciocínio, mas não é uma forma fiável de definir o comprimento do texto visível. Se for pretendida uma resposta breve ou uma estrutura específica, isso deve ser indicado na própria instrução. O contexto é de 1 milhão de tokens e, no modo normal, a resposta máxima é de 128 mil tokens; numa análise aprofundada, é necessário deixar espaço para o raciocínio e o conteúdo final.

Tarefas científicas e sensíveis

A data de corte fiável do conhecimento integrado é maio de 2026. Entre as áreas científicas, a Anthropic descreve biologia estrutural, química orgânica e bioinformática. O fabricante assinala, porém, limitações relevantes em investigação biológica autónoma prolongada; a capacidade de discutir materiais científicos não implica concluir autonomamente qualquer investigação.

Os mecanismos de proteção permitem procurar erros no código de origem, mas restringem algumas tarefas sensíveis. Informação atual exige materiais fornecidos ou pesquisa, e o resultado técnico ou científico requer verificação no seu domínio específico.

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions claude-opus-5-thinking

claude-opus-5-thinking

Anthropic /claude-opus-5-thinking

Introdução

Entradas aceites: Texto
Resultados: Texto

Disponível no Ailoot · entradas e métodos

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions

Entrada: text
Saída: text
Formato de saída: json ou SSE

Campo	Tipo	Requisito	Valores e limites	Predefinição
Campo`model`	Tipo`string`	RequisitoObrigatório	Valores e limites claude-opus-5-thinking	Predefinição—
Campo`messages`	Tipo`message[]`	RequisitoObrigatório	Valores e limites Número mínimo de elementos: 1	Predefinição—
Campo`messages[].role`	Tipo`string`	RequisitoObrigatório	Valores e limites Depende do modelo	Predefinição—
Campo`messages[].content`	Tipo`string`	RequisitoOpcional	Valores e limites Aplica-se quando: Conversação textual	Predefinição—
Campo`stream`	Tipo`boolean`	RequisitoOpcional	Valores e limites	Predefiniçãofalse

Combinações de materiais de entrada

Texto · Texto UTF8

messages[].content

Parâmetros e ciclo de vida do método

Parâmetro	Contrato
Parâmetro`content_type`	Contratoapplication/json
Parâmetro`required`	Contratomodel, messages
Parâmetro`material_types`	Contratotext
Parâmetro`messages`	ContratoLista de mensagens com estrutura role/content
Parâmetro`file_material`	ContratoDocumento UTF-8 real inserido como texto literal; nenhum ID de ficheiro inferido
Parâmetro`optional_controls`	Contratostream
Parâmetro`control_scope`	ContratoConversação textual; stream é um booleano e tem false como predefinição.
Parâmetro`output_modalities`	Contratotext
Parâmetro`hosted_operations`	Contratofalse
Parâmetro`multimodal_input_binding`	Contratonull

Aliases do método: /chat/completions

Ciclo de vida: synchronous_or_streamed

Envie o ID exato do modelo com messages.

O comprimento do contexto não é um limite de saída.

Um ficheiro de texto pode fornecer texto literal; as entradas de imagem/áudio/objeto de ficheiro exigem uma associação exata.

Tarifários

As referências tarifárias não acrescentam opções ao pedido. Os parâmetros suportados constam do método selecionado.

Modo rápido: Não especificado Quando o modo rápido está selecionado
Modo flex: Não especificado Quando o modo flex está selecionado
Esforço máximo de raciocínio: Não especificado Quando o esforço máximo de raciocínio usa o ajuste predefinido (default)

Tarifas Ailoot

Preços por configuração

Configuração	Tabela de tarifas	Custo
ConfiguraçãoTarifas base dos tokens	Tabela de tarifasTarifa base	Custo Entrada · Tokens de entrada $0.01 / 1K tokens Saída · Tokens de saída $0.05 / 1K tokens Entrada · Leitura da cache $0.001 / 1K tokens Entrada · Escrita na cache $0.0125 / 1K tokens Entrada · Escrita na cache, 1 hora — / 1K tokens

O Ailoot reserva um montante estimado antes de um pedido. Após o resultado, liquida o custo final com base na utilização medida. No streaming, a liquidação usa o registo final de utilização. Como funcionam a reserva e a liquidação →

Exemplos de pedidos

Ailoot Ultra · OpenAI Chat

curlPython SDK

set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model":"claude-opus-5-thinking","messages":[{"role":"user","content":"hello"}],"stream":false}')

Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
r=json.loads(Path("result.json").read_text())
for x in r.get("choices",[]):
    if x.get("message",{}).get("content"): print(x["message"]["content"])
PY_RESULT

from openai import OpenAI
import os

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.chat.completions.create(model="claude-opus-5-thinking", messages=[{"role":"user","content":"hello"}], stream=False)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

save_result(result.to_dict(mode="json"))

Receber e guardar os resultados

Ailoot Ultra · OpenAI Chat

json ou SSE

Guardar todos os resultados concluídos

Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.

Conserve cada opção com o conteúdo, as chamadas de ferramentas e o raciocínio. Em SSE, junte os deltas por índice de opção e ferramenta e mantenha o motivo final de conclusão e os dados de utilização.

Se for necessário verificar a resposta original

Conserve os ID e cabeçalhos de pedido/resposta. Não é fornecido um URL genérico para obter uma tarefa textual.

Campos da resposta

Campo	Tipo
Campo`choices[].index`	Tipointeger
Campo`choices[].message.content`	Tipostring\|null
Campo`choices[].message.tool_calls`	Tipotool_call[]
Campo`choices[].message.reasoning_content`	Tipostring
Campo`choices[].message.reasoning_details`	Tipoobject\|array
Campo`choices[].finish_reason`	Tipostring\|null
Campo`usage`	Tipoobject

Erros e passos seguintes

Resposta	Condição	Passo seguinte
Resposta400 · `invalid_request_error`	CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos	Passo seguinteCorrija os campos indicados antes de um novo pedido de criação.

Aliases

Aliases do modelo

Ailoot Ultra claude-opus-5-thinking

Aliases dos caminhos dos métodos

/chat/completions

IDs de chamada relacionados

claude-opus-5-thinking

FAQ · Anthropic: Claude Opus 5

Que entradas e resultados estão disponíveis?: POST /v1/chat/completions · claude-opus-5-thinking: text → text
Que campos utiliza o pedido?: POST /v1/chat/completions · claude-opus-5-thinking: model, messages, stream
Que limites se aplicam?: POST /v1/chat/completions · claude-opus-5-thinking: messages.min_items: 1

Anthropic: Claude Opus 5