Claude Sonnet 5.5 API: Preise und geprüftes JSON

Claude Sonnet 5.5 API: Preise, Aufrufe und validierte JSON-Extraktion

Claude Sonnet 5.5 kostet bei Anthropic $2 je Million Eingabetokens und $10 für Ausgabe. Auf Orux AI kostet dasselbe Modell claude-sonnet-5-5 190 Credits ($0.95) für Eingabe und 950 Credits ($4.75) für Ausgabe. Mit geänderter base_url lässt es sich über das normale OpenAI-Python-SDK aufrufen. Hier folgen Preistabelle, Python und cURL, ein zweimal tatsächlich ausgeführter JSON-Fall, der Validierer für den ersten Unterschied und die Kosten beider Aufrufe.

Claude Sonnet 5.5 API im Überblick

Claude Sonnet 5.5 erschien am 28. September 2026 als Anthropic-Modell der mittleren Klasse. Es ist ein Kandidat, wenn Haiku nicht genügt und Opus zu teuer ist. Preise je Million tokens, geprüft am 29. Oktober 2026:

Horizontal wischen, um die ganze Tabelle zu sehen.

Quellen: Anthropic-Preise und Claude Sonnet 5.5. Orux AI rechnet in Credits ab: fest 1 Credit=$0.005 beziehungsweise 200 Credits=$1. Dollarwerte in Klammern dienen dem Vergleich.

Drei Dinge stehen nicht in der Tabelle:

• Jeder Orux-Chat hat mindestens 0.001 Credits Gebühr.
• Anthropic Batch API bietet 50% Rabatt. Orux AI bietet für dieses Modell keine Stapelverarbeitung, daher vergleicht die Tabelle normale Nicht-Batch-Preise.
• Fehlgeschlagene Anfragen werden nicht berechnet. Bezahlt werden nur abgeschlossene Aufrufe aus vorausbezahltem Guthaben, ohne Monatsgebühr.

Der Claude-Preisleitfaden auf Englisch erklärt alle drei Klassen, Cache-Arithmetik und Haikus 100K-Grenze.

Claude Sonnet 5.5 mit dem OpenAI-SDK aufrufen

Orux AI stellt OpenAI-kompatible Chat Completions unter https://orux.top/api/v1 bereit. Erstellen Sie einen Schlüssel auf /keys. Sein Klartext erscheint nur einmal bei Erstellung und sollte sofort in einer Umgebungsvariablen gespeichert werden.

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

Dieselbe Anfrage als 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 ermöglicht Streaming. Fehler früh unterscheiden: 401 bedeutet falscher Schlüssel, 402 leeres Guthaben — aufladen statt Schlüssel wechseln — und 429 verlangt langsameres Senden mit exponentiellem Backoff und Jitter.

Auch die Alternativen unterscheiden sich. Anthropic bietet eine eigene OpenAI-SDK-Kompatibilitätsschicht; die aktuelle Dokumentation beschreibt Claude-API-Tests und Funktionseinschränkungen (offizielle Dokumentation, erneut geprüft am 1. November 2026). Der Originaltext beschrieb sie vor allem für Tests und Vergleiche; daraus folgt kein allgemeines offizielles Produktionsverbot. Für native Funktionen das Anthropic-SDK direkt verwenden. Orux AI ist ein unabhängiges Drittanbieter-Gateway: Ein Schlüssel, OpenAI-artiger Client und Guthaben erschließen Claude, GPT, Gemini, DeepSeek und weitere Modelle. Nach dem benötigten Modellumfang entscheiden.

JSON von Claude überprüfen

Orux dokumentiert für diesen Endpunkt messages und max_tokens. Im folgenden Test kamen weder JSON-Modus noch Schema-Parameter zum Einsatz: Prompt-basierte Generierung, danach Codevalidierung. Das ist modellunabhängig sinnvoll, denn parsebares JSON und korrekte Daten sind unterschiedliche Aussagen.

Der Extraktionsvertrag

Am 29. Oktober 2026 wurden vier fiktive Museumsleihgaben mit max_tokens=1000 verarbeitet. Sie enthalten widersprüchliche unbestätigte Bewertungen, ausdrücklich bestätigte Null, fehlende Galerie und den unmöglichen 30. Februar. Diese Fälle sollen unachtsame Extraktion sichtbar machen. Die erste vollständige Anfrage bleibt im englischen 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.

Erste Ausgabe und Wiederholung mit Klarstellung

Unveränderte erste Antwort:

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

Die schwierigen Fälle waren richtig: C3 behielt die bestätigte Null als 0, B2 wählte weder 8000 noch 9000, und der 30. Februar wurde null. Doch „Gallery A“ wurde zu „A“. Da der Prompt keine vollständigen Labels forderte, war das eine Vertragslücke, keine Faktenverwechslung. Ein Import mit „Gallery A“ als Schlüssel würde trotzdem scheitern.

Wir ergänzten einen Satz und wiederholten mit denselben Daten und Parametern:

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

Auch die zweite Antwort ist unverändert. Als response.json speichern:

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

Beide endeten mit finish_reason=stop. Ein einzelnes null fasst unbestätigt, nicht genehmigt und unmöglich zusammen. Ein echter Import sollte Quelltext und menschliche Prüfwarteschlange neben dem JSON erhalten.

Ein ausführbarer Validierer

Er kontrolliert Wurzelschlüssel, exakte Felder, eindeutige nicht leere IDs, Typen, nicht negative Beträge und echte Kalenderdaten. Mit zweiter Datei vergleicht er Werte und Reihenfolge mit der Referenz. Ein Redakteur übertrug die Sollwerte manuell aus der Quelle; sie entsprechen der zweiten Antwort, weshalb expected.json denselben Inhalt wie response.json hat.

Verwendete Node.js-22-Fassung, als validate.mjs speichern:

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; }
}

Das Python-Gegenstück validate.py nutzt dieselben wesentlichen Prüfungen und Fehlernamen:

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)

Eine Fassung mit Antwort und Referenz starten:

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

Nur response.json prüft lediglich Struktur und könnte einen falschen Betrag mit richtigem Zahlentyp akzeptieren. Der Referenzvergleich findet Inhaltsfehler. Die erste Antwort scheiterte wegen verkürzter Galerielabels mit source_mismatch, die zweite bestand.

Für Aufruf und Validierung in einem Ablauf den Client aus dem Einstieg wiederverwenden:

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

Neun beschädigte Fixtures, neun Ablehnungen

Die Referenz wurde absichtlich auf neun Arten beschädigt und jeweils geprüft. Alle wurden abgelehnt. Python nutzt dieselben Labels wie Node, nur Markdown meldet json statt eines JSON.parse-Fehlers. Das sind Validierertests, keine neun Modellfehler.

• Doppelte ID: id
• Zusätzlicher Schlüssel: keys
• Ein Datensatz entfernt: source_mismatch
• 12000 als Zeichenkette „12000“: insurance_usd
• Unbekannter Wert von null auf 0: source_mismatch
• Bestätigte Null auf null: source_mismatch
• Datum 2026-02-30: arrival_date
• 12000 auf 12500: source_mismatch
• JSON in Markdown-Codezäunen: Ablehnung beim Parsen

Zwei Modellaufrufe und neun Fixtures zeigen diesen Fall, keine Zuverlässigkeitsrate. Bei Fehlern Import stoppen und einen Menschen prüfen lassen.

Tatsächliche Kosten der zwei Aufrufe

Gemeldet wurden 402 Eingabe-/195 Ausgabetokens und 446/207:

Horizontal wischen, um die ganze Tabelle zu sehen.

Die Rechnung ist Menge×Preis: (402×190+195×950)÷1,000,000=0.26163 Credits. Ausgabe kostet fünfmal so viel wie Eingabe. Daher lohnt zuerst oft ein engeres Ausgabeformat statt eines kürzeren Prompts. Zum Mittelwert 0.27151 Credits würden 10,000 ähnliche Extraktionen monatlich etwa 2,715 Credits ($13.58) kosten.

Wann Haiku 5.5 oder Opus 5.5 wählen?

Dieselbe angenommene Last von 2,000 Eingabe- und 500 Ausgabetokens pro Anfrage, für 1,000 Aufrufe zu Preisen vom 29. Oktober 2026:

Horizontal wischen, um die ganze Tabelle zu sehen.

Haiku hat ab mehr als 100,000 Eingabetokens einen Preissprung auf 56/280 Credits je Million, offiziell $0.50/$2.50. Zuerst Haiku mit dem Validierer an den Referenzfällen testen. Besteht es, sinken die Kosten dieser Last ungefähr um Faktor 17. Claude Sonnet 5.5 vs GPT-6 Luna vs Gemini 4 Argon auf Englisch erweitert den Vergleich auf andere Anbieter.

FAQ

Q.Unterstützt Claude Sonnet 5.5 JSON-Modus?

Orux dokumentiert messages und max_tokens; unser Test nutzte weder JSON-Modus noch Schema. Exakte Schlüssel, Typen und null-Regeln im Prompt sowie Codevalidierung lieferten parsebares JSON. Parsen beginnt die Prüfung und beweist keine korrekten Inhalte.

Q.Kann das OpenAI-Python-SDK Claude aufrufen?

Ja: https://orux.top/api/v1, Orux-Schlüssel und model="claude-sonnet-5-5". Der Rest eines normalen Chat-Completions-Aufrufs bleibt gleich. Anthropic hat ebenfalls eine Kompatibilitätsschicht; aktuelle Dokumentation nennt Tests und Einschränkungen. Unterschiede zur nativen API vorab prüfen.

Q.Was kostet ein Claude-Sonnet-5.5-Aufruf?

Verbrauch mit 190 Credits je Million Eingabe und 950 Ausgabe auf Orux multiplizieren. Der gemessene 402/195-Aufruf kostete 0.26163 Credits, etwa $0.0013, gegenüber etwa $0.0028 offiziell. Jeder Chat hat mindestens 0.001 Credits Gebühr.

Q.Unterstützt Orux AI Prompt-Caching für Sonnet 5.5?

Die Modellseite nennt je Million tokens 12 Credits fürs Lesen, 237.5 für fünf Minuten Schreiben und 380 für eine Stunde. Caching kann sparen, wenn lange identische Präfixe wie Systemprompt oder Dokumente mehrfach innerhalb des Fensters wiederverwendet werden.

Q.Was passiert bei fehlgeschlagenen Anfragen?

Fehler werden nicht berechnet, nur abgeschlossene Aufrufe. Bei 402 aufladen, bei 401 Schlüssel prüfen, bei 429 exponentiellen Backoff mit Jitter einsetzen. Parsebare Antworten, die am eigenen Validierer scheitern, sind trotzdem abgeschlossen und kostenpflichtig: ein weiterer Grund für kurze Ausgaben.

Quellen und nächster Schritt

Auf der Claude-Sonnet-5.5-Seite steht „Museum inventory · validated extraction“ bereit. Laden füllt nur das Formular und startet keinen Aufruf. Preise geprüft am 2026-10-29. Quellen: Anthropic, OpenAI-SDK-Kompatibilität, Orux-AI-Preise.