Claude Sonnet 5.5 API : tarifs et JSON validé

Claude Sonnet 5.5 API : tarifs, appels et extraction JSON validée

Le tarif officiel de Claude Sonnet 5.5 est de $2 par million de tokens entrants et $10 sortants. Sur Orux AI, le même claude-sonnet-5-5 coûte 190 Credits ($0.95) en entrée et 950 Credits ($4.75) en sortie. Le SDK Python standard d’OpenAI fonctionne en changeant base_url. Voici les tarifs, les appels Python et cURL, une extraction exécutée deux fois, le validateur ayant détecté le premier écart et le coût des deux appels.

Claude Sonnet 5.5 API en bref

Claude Sonnet 5.5 est le modèle intermédiaire d’Anthropic, publié le 28 septembre 2026. Il constitue un candidat lorsque Haiku ne suffit pas et qu’Opus coûte trop cher. Tarifs par million de tokens vérifiés le 29 octobre 2026 :

Faites défiler horizontalement pour voir tout le tableau.

Sources : tarifs Anthropic et page Claude Sonnet 5.5. Orux AI facture en Credits avec 1 Credit=$0.005, soit 200 Credits=$1. Les dollars entre parenthèses servent à comparer.

Trois points ne figurent pas dans le tableau :

• Chaque requête de chat Orux AI a un minimum de 0.001 Credits.
• La Batch API Anthropic offre 50% de remise. Orux AI ne propose pas de traitement par lots pour ce modèle : le tableau compare les tarifs standards, sans lots.
• Les requêtes échouées ne sont pas facturées. Seuls les appels terminés sont payés depuis un solde prépayé, sans abonnement mensuel.

Le guide des prix Claude API, en anglais détaille les trois niveaux, le calcul du cache et le seuil 100K de Haiku.

Appeler Claude Sonnet 5.5 avec le SDK OpenAI

Orux AI expose Chat Completions compatible OpenAI à https://orux.top/api/v1. Créez une clé sur /keys. Sa valeur complète apparaît une seule fois, à la création : enregistrez-la immédiatement dans une variable d’environnement.

# 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 même demande en 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 active le streaming. Prévoyez les erreurs dès le début : 401 signifie clé incorrecte, 402 solde épuisé — rechargez plutôt que changer les clés — et 429 nécessite de ralentir avec un délai exponentiel et une composante aléatoire.

Distinguez aussi les solutions. Anthropic possède sa propre couche compatible avec le SDK OpenAI ; sa documentation actuelle décrit son usage pour tester Claude API et ses limitations (document officiel, revu le 1er novembre 2026). L’original la présentait surtout comme outil de test et de comparaison ; nous n’en déduisons pas une interdiction générale en production. Pour les fonctions natives, utilisez directement le SDK Anthropic. Orux AI est une passerelle indépendante : une clé, un client de style OpenAI et un solde donnent accès à Claude, GPT, Gemini, DeepSeek et d’autres. Choisissez selon votre besoin de modèles.

Obtenir du JSON vérifiable de Claude

L’endpoint Orux documente messages et max_tokens. Le test ci-dessous n’emploie ni mode JSON ni paramètre schema : génération par prompt, puis validation en code. Cette distinction vaut pour tout modèle : un JSON analysable n’est pas nécessairement correct.

Le contrat d’extraction

Le 29 octobre 2026, nous avons traité quatre prêts de musée fictifs avec max_tokens=1000. Les pièges sont une estimation contradictoire non approuvée, un zéro confirmé, une galerie manquante et une date impossible, le 30 février. Ils révèlent une extraction négligente. La première demande complète reste en anglais :

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.

Premier résultat et nouvelle exécution clarifiée

Première réponse inchangée :

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

Les points difficiles sont corrects : zéro confirmé de C3 conservé en 0, aucune sélection arbitraire de 8000 ou 9000 pour B2, 30 février remplacé par null. Mais « Gallery A » devient « A ». Le prompt n’exigeait pas le libellé complet : c’est une lacune du contrat, pas une erreur factuelle. Une table d’import indexée par « Gallery A » serait pourtant cassée.

Nous avons ajouté une phrase et relancé avec les mêmes données et paramètres :

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

Deuxième réponse également non éditée, à enregistrer sous 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}
  ]
}

Les deux appels se sont terminés avec finish_reason=stop. Un seul null fusionne plusieurs raisons : non approuvé, non confirmé ou impossible. Un import réel doit conserver le texte source et une file de revue humaine avec le JSON.

Un validateur exécutable

Il contrôle clé racine, champs exacts, identifiants uniques non vides, types, montants non négatifs et dates réelles. Avec un second fichier, il compare aussi valeurs et ordre à une référence. Un éditeur a transcrit les valeurs attendues depuis la source ; elles correspondent à la seconde réponse, donc expected.json et response.json ont le même contenu.

La version utilisée, Node.js 22, s’enregistre sous 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; }
}

L’équivalent Python validate.py reprend les contrôles essentiels et les mêmes étiquettes :

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)

Lancez l’un des deux avec réponse et référence :

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

Avec seulement response.json, la validation est structurelle : un montant faux, mais numérique, peut passer. La référence permet de détecter les erreurs de contenu. La première réponse échoue avec source_mismatch pour les galeries abrégées ; la seconde réussit.

Pour appeler puis valider dans le même flux, réutilisez le client initial :

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

Neuf fixtures altérées, neuf refus

Nous avons modifié la référence de neuf façons puis testé chacune. Toutes sont refusées. Python retourne les mêmes étiquettes que Node, sauf Markdown : json remplace une erreur JSON.parse. Ce sont des tests du validateur, pas neuf échecs de modèle.

• Identifiant répété : id
• Clé supplémentaire : keys
• Élément supprimé : source_mismatch
• 12000 devient la chaîne « 12000 » : insurance_usd
• Valeur inconnue, null devient 0 : source_mismatch
• Zéro confirmé devient null : source_mismatch
• Date 2026-02-30 : arrival_date
• 12000 devient 12500 : source_mismatch
• JSON entouré de délimiteurs Markdown : refus à l’analyse

Deux appels et neuf fixtures décrivent cette observation, pas un taux de fiabilité. En cas d’échec, arrêtez l’import et transmettez le dossier à une personne.

Le coût réel des deux appels

Ils ont déclaré 402 tokens entrants/195 sortants, puis 446/207 :

Faites défiler horizontalement pour voir tout le tableau.

Le calcul est quantité×tarif : (402×190+195×950)÷1,000,000=0.26163 Credits. Le tarif de sortie est cinq fois celui d’entrée ; limiter le format de sortie est souvent un meilleur premier levier que raccourcir le prompt. Avec la moyenne de 0.27151 Credits, 10,000 extractions semblables par mois coûteraient environ 2,715 Credits ($13.58).

Quand choisir Haiku 5.5 ou Opus 5.5

Même hypothèse de 2,000 tokens entrants et 500 sortants par appel, pour 1,000 requêtes aux prix du 29 octobre 2026 :

Faites défiler horizontalement pour voir tout le tableau.

Haiku change de palier au-delà de 100,000 tokens entrants : 56/280 Credits par million, contre $0.50/$2.50 officiels. Essayez d’abord Haiku avec le validateur : s’il passe vos références, cette charge coûte environ 17 fois moins. Le comparatif Claude Sonnet 5.5, GPT-6 Luna et Gemini 4 Argon, en anglais élargit le choix à d’autres fournisseurs.

FAQ

Q.Claude Sonnet 5.5 dispose-t-il d’un mode JSON ?

L’endpoint Orux documente messages et max_tokens ; notre essai n’utilisait ni mode JSON ni schema. Nous avons défini clés, types et règles de null dans le prompt puis validé par code. Pouvoir analyser le JSON commence le contrôle, sans garantir les faits.

Q.Peut-on appeler Claude avec le SDK Python OpenAI ?

Oui : https://orux.top/api/v1, clé Orux et model="claude-sonnet-5-5". Le reste d’un appel Chat Completions standard ne change pas. Anthropic a aussi sa couche compatible, dont la documentation actuelle décrit les tests et limitations. Vérifiez ses différences avec l’API native.

Q.Combien coûte un appel Claude Sonnet 5.5 ?

Multipliez l’usage par 190 Credits le million entrant et 950 sortant sur Orux. L’appel réel de 402/195 coûte 0.26163 Credits, environ $0.0013, contre environ $0.0028 au tarif Anthropic. Le minimum par chat est de 0.001 Credits.

Q.Orux AI propose-t-il le cache pour Claude Sonnet 5.5 ?

La page publie 12 Credits par million en lecture, 237.5 en écriture cinq minutes et 380 pour une heure. Le cache peut économiser lorsqu’un long préfixe identique, tel qu’une instruction système ou des documents, est réutilisé dans la fenêtre de validité.

Q.Que se passe-t-il si une requête échoue ?

Les échecs ne sont pas facturés, seuls les appels terminés. 402 demande une recharge, 401 une vérification de clé et 429 un délai exponentiel avec aléa. Une réponse analysable qui échoue à votre validateur reste un appel terminé et facturé : une raison de limiter les sorties.

Sources et prochaine étape

Choisissez « Museum inventory · validated extraction » sur la page Claude Sonnet 5.5. Le chargement remplit le formulaire sans lancer de requête. Prix vérifiés le 2026-10-29. Sources : Anthropic, compatibilité OpenAI SDK, tarifs Orux AI.