Claude Sonnet 5.5 API: precios y JSON validado

Claude Sonnet 5.5 API: precio, llamadas y extracción JSON validada

La tarifa oficial de Claude Sonnet 5.5 es $2 por millón de tokens de entrada y $10 de salida. En Orux AI, el mismo claude-sonnet-5-5 cuesta 190 Credits ($0.95) de entrada y 950 Credits ($4.75) de salida; se llama con el SDK estándar de OpenAI para Python cambiando base_url. Aquí están la tabla, las solicitudes Python y cURL, una extracción JSON ejecutada dos veces, el validador que detectó la discrepancia inicial y el coste de ambas llamadas.

Claude Sonnet 5.5 API de un vistazo

Claude Sonnet 5.5 es el modelo intermedio de Anthropic, publicado el 28 de septiembre de 2026. Es una opción cuando Haiku no basta y Opus resulta demasiado caro. Tarifas por millón de tokens comprobadas el 29 de octubre de 2026:

Desliza horizontalmente para ver toda la tabla.

Fuentes: tarifas Anthropic y página Claude Sonnet 5.5. Orux AI factura en Credits con 1 Credit=$0.005, o 200 Credits=$1. Los dólares entre paréntesis solo facilitan la comparación.

Hay tres detalles fuera de la tabla:

• Cada solicitud de chat en Orux AI tiene un mínimo de 0.001 Credits.
• La Batch API de Anthropic descuenta el 50%. Orux AI no ofrece procesamiento por lotes para este modelo; la comparación anterior es estándar, sin lotes.
• Las solicitudes fallidas no se cobran. Solo se pagan llamadas completadas desde un saldo prepago, sin cuota mensual.

La guía de precios Claude API, en inglés desglosa los tres niveles, los cálculos de caché y el umbral 100K de Haiku.

Llamar a Claude Sonnet 5.5 con el SDK OpenAI

Orux AI expone Chat Completions compatible con OpenAI en https://orux.top/api/v1. Crea una clave en /keys: su texto completo solo aparece una vez, al crearla, así que guárdala enseguida en una variable de entorno.

# 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")

La misma solicitud con 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. Distingue los errores desde el primer día: 401 indica clave incorrecta, 402 saldo agotado —recarga, no cambies claves— y 429 pide reducir la velocidad con retroceso exponencial y aleatoriedad.

Conviene separar las alternativas. Anthropic tiene su propia capa compatible con OpenAI SDK; la documentación actual explica su uso para probar Claude API y sus limitaciones (documentación oficial, revisada el 1 de noviembre de 2026). El original la describía principalmente para pruebas y comparación; no lo convertimos en una prohibición general de uso en producción. Para funciones nativas, usa el SDK de Anthropic directamente. Orux AI es una pasarela independiente de terceros: una clave, un cliente de estilo OpenAI y un saldo permiten usar Claude junto con GPT, Gemini, DeepSeek y otros. Elige según cuántos modelos necesites.

Obtener JSON verificable de Claude

La documentación de este endpoint Orux incluye messages y max_tokens. La prueba siguiente no utilizó modo JSON ni parámetro schema: generó mediante prompt y validó después con código. Recomendamos distinguirlo con cualquier modelo: devolver JSON analizable no demuestra que los datos sean correctos.

El contrato de extracción

El 29 de octubre de 2026 ejecutamos cuatro registros ficticios de préstamos de museo con max_tokens=1000. Incluyen valoraciones contradictorias no aprobadas, un cero confirmado, una galería ausente y una fecha imposible, 30 de febrero. Buscan revelar una extracción descuidada. Esta es la primera solicitud completa, conservada en inglés:

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.

Primera salida y repetición con una aclaración

La primera respuesta, sin cambios:

{"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}]}

Resolvió los puntos difíciles: conservó el cero de C3 como 0, no eligió 8000 ni 9000 para B2 y convirtió el 30 de febrero en null. Pero acortó “Gallery A” a “A”. Como no pedimos la etiqueta completa, es una carencia del contrato, no una mala lectura de los hechos. Aun así, rompería una importación que use “Gallery A” como clave.

Añadimos una frase y repetimos con los mismos registros y parámetros:

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

La segunda respuesta tampoco se editó. Guárdala 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 terminaron con finish_reason=stop. Un solo null reúne razones distintas: no aprobado, no confirmado o imposible. Una importación real debe mantener el texto fuente y una cola de revisión junto al JSON.

Un validador ejecutable

El validador comprueba clave raíz, campos exactos, ID únicos no vacíos, tipos, cantidades no negativas y fechas reales. Con un segundo archivo compara además cada valor y el orden con una referencia. Un editor transcribió a mano los valores esperados desde la fuente; coinciden con la segunda respuesta, por lo que expected.json tiene el mismo contenido que response.json.

La versión utilizada, Node.js 22, se guarda 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; }
}

El equivalente Python, validate.py, conserva las comprobaciones principales y etiquetas:

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)

Ejecuta cualquiera contra respuesta y referencia:

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

Con solo response.json se revisa estructura, y una cantidad errónea de tipo numérico podría pasar. La comparación con la referencia detecta errores de contenido. Frente a esa referencia, la primera respuesta falló con source_mismatch por las galerías abreviadas y la segunda pasó.

Para llamar y validar en un paso, reutiliza el 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

Nueve muestras alteradas, nueve rechazos

Alteramos la referencia de nueve maneras y ejecutamos el validador: todas fueron rechazadas. Python devuelve las mismas etiquetas que Node salvo el caso Markdown, que informa json en vez de un error JSON.parse. Son pruebas del validador, no nueve fallos del modelo.

• ID duplicado: id
• Clave adicional: keys
• Un elemento eliminado: source_mismatch
• 12000 convertido en la cadena “12000”: insurance_usd
• Valor desconocido cambiado de null a 0: source_mismatch
• Cero confirmado cambiado a null: source_mismatch
• Fecha 2026-02-30: arrival_date
• 12000 cambiado a 12500: source_mismatch
• JSON rodeado de cercas Markdown: rechazo al analizar

Dos llamadas y nueve muestras muestran lo ocurrido aquí, no una tasa de fiabilidad. Si falla la validación, detén la importación y envía el registro a una persona.

Cuánto costaron las dos llamadas

Reportaron 402 tokens de entrada/195 de salida y 446/207, respectivamente:

Desliza horizontalmente para ver toda la tabla.

La operación es cantidad por tarifa: (402×190+195×950)÷1,000,000=0.26163 Credits. La salida cuesta cinco veces más que la entrada, así que suele merecer la pena ajustar primero su formato, antes de acortar el prompt. Con la media de 0.27151 Credits, 10,000 extracciones similares mensuales costarían unos 2,715 Credits ($13.58).

Cuándo elegir Haiku 5.5 u Opus 5.5

Misma carga hipotética, 2,000 tokens de entrada y 500 de salida por llamada, para 1,000 solicitudes a tarifas del 29 de octubre de 2026:

Desliza horizontalmente para ver toda la tabla.

Haiku sube al superar 100,000 tokens de entrada: 56/280 Credits por millón, frente a $0.50/$2.50 oficiales. Prueba primero el validador con Haiku; si pasa tus referencias, el coste de esta carga cae aproximadamente 17 veces. La comparación Claude Sonnet 5.5, GPT-6 Luna y Gemini 4 Argon, en inglés amplía la decisión a otros proveedores.

FAQ

Q.¿Claude Sonnet 5.5 admite modo JSON?

El endpoint Orux documenta messages y max_tokens; esta prueba no usó modo JSON ni schema. Obtuvimos JSON analizable indicando claves, tipos y reglas de null, y comprobándolo con código. Poder analizarlo inicia la revisión, no demuestra exactitud del contenido.

Q.¿Puedo utilizar el SDK Python de OpenAI con Claude?

Sí. Usa https://orux.top/api/v1, tu clave Orux y model="claude-sonnet-5-5"; lo demás en una llamada estándar Chat Completions no cambia. Anthropic también ofrece su capa compatible, cuya documentación actual describe pruebas y limitaciones. Comprueba las diferencias frente a la interfaz nativa.

Q.¿Cuánto cuesta una llamada Claude Sonnet 5.5?

Multiplica uso por tarifa: 190 Credits por millón de entrada y 950 de salida en Orux. La llamada real de 402/195 costó 0.26163 Credits, unos $0.0013, frente a aproximadamente $0.0028 oficiales. Cada chat tiene un mínimo de 0.001 Credits.

Q.¿Orux AI admite caché para Claude Sonnet 5.5?

La página publica lectura a 12 Credits por millón, escritura de cinco minutos a 237.5 y de una hora a 380. Puede ahorrar cuando un prefijo largo e idéntico, como instrucciones de sistema o documentos, se reutiliza varias veces dentro de la ventana.

Q.¿Qué ocurre si falla una solicitud?

Las fallidas no se cobran, solo las completadas. Ante 402, recarga; con 401, revisa la clave; con 429, aplica retroceso exponencial con aleatoriedad. Una respuesta analizable que falla tu validador sigue siendo una llamada completada y facturada: otro motivo para limitar salidas.

Fuentes y siguiente paso

Prueba “Museum inventory · validated extraction” en la página Claude Sonnet 5.5. Cargar el ejemplo rellena el formulario y no inicia una llamada. Precios comprobados el 2026-10-29. Fuentes: Anthropic, compatibilidad OpenAI SDK, precios Orux AI.