Claude Sonnet 5.5 API: preços e JSON validado

Claude Sonnet 5.5 API: preços, chamadas e extração JSON validada

A tarifa oficial de Claude Sonnet 5.5 é $2 por milhão de tokens de entrada e $10 de saída. No Orux AI, o mesmo claude-sonnet-5-5 custa 190 Credits ($0.95) de entrada e 950 Credits ($4.75) de saída. Basta ajustar base_url no SDK Python padrão da OpenAI. A seguir estão preços, chamadas Python e cURL, uma extração executada duas vezes, o validador que encontrou a divergência inicial e o custo das duas chamadas.

Claude Sonnet 5.5 API em resumo

Claude Sonnet 5.5 é o modelo intermediário da Anthropic, lançado em 28 de setembro de 2026. É um candidato quando Haiku não basta e Opus custa demais. Tarifas por milhão de tokens, verificadas em 29 de outubro de 2026:

Deslize para os lados para ver toda a tabela.

Fontes: preços Anthropic e página Claude Sonnet 5.5. Orux AI cobra em Credits com 1 Credit=$0.005, ou 200 Credits=$1. Os dólares entre parênteses são auxiliares de comparação.

Há três pontos fora da tabela:

• Cada solicitação de chat Orux AI tem mínimo de 0.001 Credits.
• A Batch API Anthropic dá 50% de desconto. Orux AI não oferece lotes para este modelo; a tabela compara preços padrão, sem lote.
• Solicitações que falham não são cobradas. Só se paga por chamadas concluídas, com saldo pré-pago e sem mensalidade.

O guia de preços Claude API, em inglês detalha os três níveis, cálculos de cache e o limite 100K de Haiku.

Chamar Claude Sonnet 5.5 com o SDK OpenAI

Orux AI expõe Chat Completions compatível com OpenAI em https://orux.top/api/v1. Crie uma chave em /keys. O texto completo só aparece uma vez, na criação: guarde-o imediatamente em uma variável de ambiente.

# pip install openai
import os
from openai import OpenAI

client = OpenAI(base_url="https://orux.top/api/v1", api_key=os.environ["ORUX_API_KEY"])

resp = client.chat.completions.create(
    model="claude-sonnet-5-5",
    messages=[{"role": "user", "content": "Summarize this in 3 bullet points: ..."}],
    max_tokens=500,
)
print(resp.choices[0].message.content)

# Estimate the charge in Credits from the published rates (Credits per 1M tokens)
IN_RATE, OUT_RATE = 190, 950  # claude-sonnet-5-5, checked 2026-10-29
u = resp.usage
print(f"~ {(u.prompt_tokens * IN_RATE + u.completion_tokens * OUT_RATE) / 1e6:.6f} Credits")

A mesma solicitação via cURL:

curl https://orux.top/api/v1/chat/completions \
  -H "Authorization: Bearer $ORUX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "claude-sonnet-5-5", "max_tokens": 500,
       "messages": [{"role": "user", "content": "Summarize this in 3 bullet points: ..."}]}'

stream=True permite streaming. Cuide dos erros desde o início: 401 indica chave incorreta, 402 saldo vazio — recarregue, não troque chaves — e 429 pede reduzir a velocidade com espera exponencial e variação aleatória.

Separe também as alternativas. Anthropic oferece sua própria camada de compatibilidade OpenAI SDK; a documentação atual descreve uso para testar Claude API e limitações de recursos (documentação oficial, revisada em 1º de novembro de 2026). O original a descrevia principalmente para teste e comparação; não transformamos isso em proibição geral de produção. Se precisa dos recursos nativos, use diretamente o SDK Anthropic. Orux AI é uma passagem independente de terceiros: uma chave, cliente no estilo OpenAI e saldo dão acesso a Claude, GPT, Gemini, DeepSeek e outros. Escolha pelo conjunto de modelos necessário.

Obter JSON verificável de Claude

O endpoint Orux documenta messages e max_tokens. O teste abaixo não usou modo JSON nem parâmetro schema: gerou por prompt e validou por código. A distinção vale para qualquer modelo: JSON analisável e dados corretos são afirmações diferentes.

O contrato de extração

Em 29 de outubro de 2026 usamos quatro registros fictícios de empréstimos de museu e max_tokens=1000. Há estimativas conflitantes não aprovadas, zero confirmado, galeria ausente e uma data impossível, 30 de fevereiro. Esses casos revelam extração descuidada. A primeira solicitação completa permanece no inglês original:

Extract this fictional museum loan inventory. Return JSON only, without Markdown. The root has exactly one key, items. Each item has exactly id, title, gallery, insurance_usd, arrival_date. Preserve the stated item order. insurance_usd is a nonnegative JSON number or null; an explicitly confirmed zero is 0, not null. arrival_date is an actual calendar date in YYYY-MM-DD or null. Missing, unapproved, conflicting or impossible values must be null. Never choose between conflicting unapproved estimates. Do not infer facts.

A1: Brass compass. Gallery A. Approved insurance USD 12000. Arrival 2026-11-14.
B2: Silk route map. Gallery B. Draft insurance estimates: USD 8000 in one note and USD 9000 in another; neither approved. Arrival 2026-11-16.
C3: Ceramic sherd. Insurance is explicitly confirmed as USD 0. Gallery and arrival date are unconfirmed.
D4: Glass lens. Gallery D. Approved insurance USD 500. Arrival is written as 2026-02-30; the actual date has not been confirmed.

Primeira saída e repetição com esclarecimento

Primeira resposta, sem alterações:

{"items":[{"id":"A1","title":"Brass compass","gallery":"A","insurance_usd":12000,"arrival_date":"2026-11-14"},{"id":"B2","title":"Silk route map","gallery":"B","insurance_usd":null,"arrival_date":"2026-11-16"},{"id":"C3","title":"Ceramic sherd","gallery":null,"insurance_usd":0,"arrival_date":null},{"id":"D4","title":"Glass lens","gallery":"D","insurance_usd":500,"arrival_date":null}]}

Os pontos difíceis foram corretos: o zero confirmado de C3 permaneceu 0, B2 não escolheu 8000 nem 9000 e 30 de fevereiro virou null. Porém “Gallery A” virou “A”. O prompt não exigia rótulo completo, então é uma lacuna contratual, não erro de fatos. Mesmo assim, uma importação indexada por “Gallery A” quebraria.

Acrescentamos uma frase e repetimos com os mesmos registros e parâmetros:

For gallery, preserve the full source label exactly (for example, "Gallery A", not "A"). Never shorten or translate these labels.

A segunda resposta também não foi editada. Salve como response.json:

{
  "items": [
    {"id": "A1", "title": "Brass compass", "gallery": "Gallery A", "insurance_usd": 12000, "arrival_date": "2026-11-14"},
    {"id": "B2", "title": "Silk route map", "gallery": "Gallery B", "insurance_usd": null, "arrival_date": "2026-11-16"},
    {"id": "C3", "title": "Ceramic sherd", "gallery": null, "insurance_usd": 0, "arrival_date": null},
    {"id": "D4", "title": "Glass lens", "gallery": "Gallery D", "insurance_usd": 500, "arrival_date": null}
  ]
}

Ambas terminaram com finish_reason=stop. Um único null junta razões como não aprovado, não confirmado ou impossível. Uma importação real deve manter fonte e fila de revisão humana junto ao JSON.

Um validador executável

Verifica chave raiz, campos exatos, IDs únicos não vazios, tipos, valores não negativos e datas reais. Com outro arquivo também compara cada valor e a ordem com uma referência. Um editor transcreveu os valores esperados manualmente da fonte; coincidem com a segunda resposta, por isso expected.json e response.json têm o mesmo conteúdo.

A versão usada, Node.js 22, deve ser salva como validate.mjs:

import fs from 'node:fs';
import {pathToFileURL} from 'node:url';
import {isDeepStrictEqual} from 'node:util';
export function validate(raw, expected) {
  const x = JSON.parse(raw), keys = ['id','title','gallery','insurance_usd','arrival_date'];
  const object = v => v !== null && typeof v === 'object' && !Array.isArray(v);
  const sameKeys = (v, k) => object(v) && Object.keys(v).sort().join('|') === [...k].sort().join('|');
  if (!sameKeys(x, ['items']) || !Array.isArray(x.items) || !x.items.length) throw Error('items');
  const seen = new Set();
  for (const item of x.items) {
    if (!sameKeys(item, keys)) throw Error('keys');
    if (typeof item.id !== 'string' || !item.id.trim() || seen.has(item.id)) throw Error('id');
    seen.add(item.id);
    for (const k of ['title','gallery']) {
      if (item[k] !== null && (typeof item[k] !== 'string' || !item[k].trim())) throw Error(k);
    }
    const n = item.insurance_usd;
    if (n !== null && (typeof n !== 'number' || !Number.isFinite(n) || n < 0)) throw Error('insurance_usd');
    const d = item.arrival_date;
    if (d !== null) {
      if (typeof d !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(d)) throw Error('arrival_date');
      const parsed = new Date(d + 'T00:00:00Z');
      if (!Number.isFinite(parsed.getTime()) || parsed.toISOString().slice(0,10) !== d) throw Error('arrival_date');
    }
  }
  if (expected !== undefined && !isDeepStrictEqual(x, expected)) throw Error('source_mismatch');
  return x;
}
if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
  try {
    const expected = process.argv[3] ? JSON.parse(fs.readFileSync(process.argv[3],'utf8')) : undefined;
    const data = validate(fs.readFileSync(process.argv[2],'utf8'), expected);
    console.log(`PASS ${data.items.length} items; source fixture ${expected ? 'checked' : 'NOT checked'}`);
  } catch (error) { console.error('REJECT', error.message); process.exitCode = 1; }
}

O equivalente Python, validate.py, mantém as verificações centrais e rótulos de erro:

import json, math, re, sys
from datetime import date

KEYS = {"id", "title", "gallery", "insurance_usd", "arrival_date"}


def validate(raw, expected=None):
    x = json.loads(raw)  # Markdown fences or prose around the JSON fail here
    if not isinstance(x, dict) or set(x) != {"items"} or not isinstance(x["items"], list) or not x["items"]:
        raise ValueError("items")
    seen = set()
    for item in x["items"]:
        if not isinstance(item, dict) or set(item) != KEYS:
            raise ValueError("keys")
        item_id = item["id"]
        if not isinstance(item_id, str) or not item_id.strip() or item_id in seen:
            raise ValueError("id")
        seen.add(item_id)
        for k in ("title", "gallery"):
            v = item[k]
            if v is not None and (not isinstance(v, str) or not v.strip()):
                raise ValueError(k)
        n = item["insurance_usd"]
        if n is not None and (isinstance(n, bool) or not isinstance(n, (int, float))
                              or not math.isfinite(n) or n < 0):
            raise ValueError("insurance_usd")
        d = item["arrival_date"]
        if d is not None:
            if not isinstance(d, str) or not re.fullmatch(r"[0-9]{4}-[0-9]{2}-[0-9]{2}", d):
                raise ValueError("arrival_date")
            try:
                date.fromisoformat(d)  # rejects 2026-02-30
            except ValueError:
                raise ValueError("arrival_date") from None
    if expected is not None and x != expected:
        raise ValueError("source_mismatch")
    return x


if __name__ == "__main__":
    try:
        expected = json.load(open(sys.argv[2])) if len(sys.argv) > 2 else None
        data = validate(open(sys.argv[1]).read(), expected)
        checked = "checked" if expected is not None else "NOT checked"
        print(f"PASS {len(data['items'])} items; source fixture {checked}")
    except json.JSONDecodeError:
        print("REJECT json", file=sys.stderr)
        sys.exit(1)
    except ValueError as e:
        print("REJECT", e, file=sys.stderr)
        sys.exit(1)

Execute qualquer um com resposta e referência:

node validate.mjs response.json expected.json
python validate.py response.json expected.json
# PASS 4 items; source fixture checked

Apenas response.json verifica estrutura e pode aceitar um valor errado com tipo numérico válido. A comparação de referência encontra o erro de conteúdo. Contra ela, a primeira resposta falhou com source_mismatch pelos nomes abreviados de galerias, e a segunda passou.

Para chamar e validar no mesmo fluxo, reutilize o cliente inicial:

import json
from validate import validate

PROMPT = open("prompt.txt").read()        # the contract and records above, plus the gallery rule
expected = json.load(open("expected.json"))

resp = client.chat.completions.create(
    model="claude-sonnet-5-5",
    messages=[{"role": "user", "content": PROMPT}],
    max_tokens=1000,
)
data = validate(resp.choices[0].message.content, expected)  # raises on any mismatch

Nove amostras corrompidas, nove rejeições

Alteramos a referência de nove maneiras e executamos o validador em cada uma. Todas foram rejeitadas. Python retorna os mesmos rótulos que Node, exceto Markdown, que informa json em vez de erro JSON.parse. São testes do validador, não nove falhas do modelo.

• ID repetido: id
• Chave extra em um item: keys
• Um item removido: source_mismatch
• 12000 convertido na string “12000”: insurance_usd
• Valor desconhecido de null para 0: source_mismatch
• Zero confirmado para null: source_mismatch
• Data 2026-02-30: arrival_date
• 12000 para 12500: source_mismatch
• JSON envolvido em cercas Markdown: rejeição na análise

Duas chamadas e nove amostras mostram o que aconteceu aqui, não uma taxa de confiabilidade. Se a validação falha, interrompa a importação e encaminhe para uma pessoa.

O custo real das duas chamadas

Foram reportados 402 tokens de entrada/195 de saída e 446/207:

Deslize para os lados para ver toda a tabela.

O cálculo é quantidade×tarifa: (402×190+195×950)÷1,000,000=0.26163 Credits. A saída custa cinco vezes mais que a entrada; restringir o formato de saída costuma ser o primeiro ajuste, antes de encurtar o prompt. Pela média 0.27151 Credits, 10,000 extrações semelhantes por mês custariam cerca de 2,715 Credits ($13.58).

Quando escolher Haiku 5.5 ou Opus 5.5

Mesma hipótese de 2,000 tokens de entrada e 500 de saída por chamada, para 1,000 solicitações às tarifas de 29 de outubro de 2026:

Deslize para os lados para ver toda a tabela.

Haiku tem um degrau acima de 100,000 tokens de entrada: 56/280 Credits por milhão, contra $0.50/$2.50 oficiais. Teste primeiro Haiku com o validador; se passar nas suas referências, o custo dessa carga cai aproximadamente 17 vezes. A comparação Claude Sonnet 5.5, GPT-6 Luna e Gemini 4 Argon, em inglês amplia a escolha para outros fornecedores.

FAQ

Q.Claude Sonnet 5.5 aceita modo JSON?

Orux documenta messages e max_tokens; este teste não usou modo JSON nem schema. Indicamos chaves, tipos e regras de null no prompt e validamos com código. Conseguir analisar o JSON inicia a verificação, não prova a correção dos dados.

Q.Posso usar o SDK Python OpenAI com Claude?

Sim. Defina https://orux.top/api/v1, a chave Orux e model="claude-sonnet-5-5". O resto de uma chamada padrão Chat Completions não muda. Anthropic também tem camada compatível, cuja documentação atual explica testes e limitações. Confira diferenças em relação à interface nativa.

Q.Quanto custa uma chamada Claude Sonnet 5.5?

Multiplique uso por 190 Credits por milhão de entrada e 950 de saída no Orux. A chamada real 402/195 custou 0.26163 Credits, cerca de $0.0013, contra aproximadamente $0.0028 oficiais. Cada chat tem mínimo de 0.001 Credits.

Q.Orux AI oferece cache para Claude Sonnet 5.5?

A página publica leitura de 12 Credits por milhão, escrita de cinco minutos 237.5 e de uma hora 380. Cache pode compensar quando um prefixo longo e idêntico, como instruções de sistema ou documentos, é reutilizado várias vezes na janela válida.

Q.O que acontece se uma solicitação falha?

As falhas não são cobradas, somente chamadas concluídas. Em 402, recarregue; em 401, confira a chave; em 429, use espera exponencial com aleatoriedade. Uma resposta analisável que falha no seu validador continua sendo chamada concluída e cobrada: mais um motivo para limitar saídas.

Fontes e próximo passo

Na página Claude Sonnet 5.5, escolha “Museum inventory · validated extraction”. Carregar o exemplo apenas preenche o formulário, sem iniciar uma chamada. Preços verificados em 2026-10-29. Fontes: Anthropic, compatibilidade OpenAI SDK, preços Orux AI.