Orux AI / Modellnotizen
Claude-API-Preise 2026: Opus, Sonnet und Haiku 5.5
Claude API bei Orux AI und Anthropic: Haiku 100K-Grenze, Cache, Batch und 3 Lastprofile. Mit Python-Rechner und Preisen vom 29. Oktober 2026 sowie Grenzen.

In diesem Artikel
Claude-API-Preise: Modelle, Cache und lange Eingaben
Anthropics Listenpreise je Million tokens liegen bei $4 Eingabe/$20 Ausgabe für Opus 5.5, $2/$10 für Sonnet 5.5 und $0.10/$0.50 für Haiku 5.5 bis 100,000 Prompt-tokens. Oberhalb dieser Grenze steigt Haiku auf $0.50/$2.50. Bei Orux AI kosten dieselben Modelle 380/1,900, 190/950 und 10.8/54 Credits ($1.90/$9.50, $0.95/$4.75 und $0.054/$0.27), also rund 47.5–56% des offiziellen Basispreises.
Verglichen werden die hier genannten Opus, Sonnet und Haiku 5.5, nicht der gesamte aktuelle Claude-Katalog.
Es folgen vollständige Tabellen einschließlich Cache-Schreiben und -Lesen sowie zwei Punkte, die der beworbene Grundpreis verdeckt: Haikus 100K-Sprung und die Batch API. Preisstand ist der 29. Oktober 2026.
Claude-API-Preise auf einen Blick
Offizielle Anthropic-Preise in USD je Million tokens von der Claude-Preisseite:
| Modell | Eingabe | Cache-Schreiben 5 Min. | Cache-Schreiben 1 Std. | Cache-Lesen | Ausgabe |
|---|---|---|---|---|---|
| Claude Opus 5.5 | $4 | $5 | $8 | $0.20 | $20 |
| Claude Sonnet 5.5 | $2 | $2.50 | $4 | $0.10 | $10 |
| Claude Haiku 5.5, Prompt ≤100K | $0.10 | $0.125 | $0.20 | $0.01 | $0.50 |
| Claude Haiku 5.5, Prompt >100K | $0.50 | $0.625 | $1 | $0.05 | $2.50 |
Horizontal wischen, um die ganze Tabelle zu sehen.
Orux-AI-Preise derselben Modelle in Credits je Million tokens. 1 Credit=$0.005, also 200 Credits=$1:
| Modell | Eingabe | Cache-Schreiben 5 Min. | Cache-Schreiben 1 Std. | Cache-Lesen | Ausgabe | Orux/offiziell |
|---|---|---|---|---|---|---|
| Claude Opus 5.5 | 380 ($1.90) | 475 ($2.375) | 760 ($3.80) | 22 ($0.11) | 1,900 ($9.50) | 47.5% (Cache-Lesen 55%) |
| Claude Sonnet 5.5 | 190 ($0.95) | 237.5 ($1.19) | 380 ($1.90) | 12 ($0.06) | 950 ($4.75) | 47.5% (Cache-Lesen 60%) |
| Claude Haiku 5.5, ≤100K | 10.8 ($0.054) | 13.75 ($0.069) | 22 ($0.11) | 1.1 ($0.0055) | 54 ($0.27) | 54–55% |
| Claude Haiku 5.5, >100K | 56 ($0.28) | 70 ($0.35) | 112 ($0.56) | 5.6 ($0.028) | 280 ($1.40) | 56% |
Horizontal wischen, um die ganze Tabelle zu sehen.
Zwei Details werden leicht übersehen. Anthropic berechnet Cache-Lesen bei Opus 5.5 und Sonnet 5.5 mit dem 0.05-Fachen des Eingabepreises, nicht dem 0.1-Fachen älterer Modelle. Das macht Caching wertvoller. Außerdem hat jede Orux-Chat-Anfrage ein Minimum von 0.001 Credits, das nur sehr kurze Aufrufe wesentlich beeinflusst.
Haiku 5.5 und die 100K-Promptgrenze
Haiku 5.5 ist das einzige Modell dieser Familie mit Preisstufen nach Promptlänge. Anthropic zählt sämtliche Eingabe-tokens einschließlich Cache-Lesen und -Schreiben und bewertet jede Anfrage separat. Ein token über der Grenze verteuert die gesamte Anfrage, nicht nur den Überschuss.
Bei 1,000 Ausgabe-tokens:
| Promptgröße | Orux AI je Anfrage | Offiziell je Anfrage |
|---|---|---|
| 100,000 tokens | 1.134 Credits ($0.00567) | $0.0105 |
| 100,001 tokens | 5.880056 Credits ($0.0294) | $0.0525 |
Horizontal wischen, um die ganze Tabelle zu sehen.
Ein zusätzliches Eingabe-token macht die Anfrage an beiden Stellen etwa 5.2-mal so teuer. Lange Haiku-Dokumente kürzen oder teilen, um höchstens 100,000 Eingabe-tokens zu senden; auch ein gecachter Systemprompt zählt. Orux AI verwendet dieselbe Grenze: 100,000 eingeschlossen bleibt in der niedrigen Stufe.
Für Opus 5.5 und Sonnet 5.5 hat Anthropic keinen Langprompt-Aufschlag; Orux AI veröffentlicht ebenfalls jeweils einen einheitlichen Tarif.
Wann Prompt-Caching sich lohnt
Beim Caching zahlt man einmal etwas mehr für einen Promptpräfix und bei jeder späteren Wiederverwendung deutlich weniger. Fünf Minuten Cache-Schreiben kosten das 1.25-Fache der Eingabe, eine Stunde das Zweifache. Anthropic-Lesen auf Opus 5.5 und Sonnet 5.5 kostet das 0.05-Fache.
Sonnet-Beispiel: Ein Systemprompt mit 10,000 tokens wird in 1,000 Anfragen verwendet. Der Verkehr ist gleichmäßig genug, damit der Fünf-Minuten-Cache warm bleibt.
| Orux AI | Offiziell | |
|---|---|---|
| Ohne Cache (1,000 × 10,000 Eingabe-tokens) | 1,900 Credits ($9.50) | $20.00 |
| Einmal 5-Min.-Schreiben +999 Lesevorgänge | 122.26 Credits ($0.61) | $1.02 |
Horizontal wischen, um die ganze Tabelle zu sehen.
Der Präfixpreis sinkt in beiden Spalten um 93–95%. Mit den offiziellen Faktoren kostet das Fünf-Minuten-Schreiben zusätzlich 0.25 Eingaben, während jedes Lesen bei Opus/Sonnet 0.95 und bei Haiku 0.9 Eingaben spart. Damit amortisiert es sich bei der ersten Wiederverwendung. Eine Stunde kostet eine zusätzliche Eingabe und braucht zwei Wiederverwendungen. Orux-Beträge werden separat mit den Tabellenpreisen berechnet.
Ausgabe-tokens werden nicht billiger, und ein bei jedem Aufruf veränderter Präfix hilft nicht. Systemprompt, Werkzeugdefinitionen und stabile Dokumente zuerst platzieren, variable Inhalte zuletzt.
Batch API: direkt 50% Rabatt, bei Orux AI nicht verfügbar
Anthropics Batch API verarbeitet asynchron zum halben Standardpreis; der Rabatt lässt sich mit Caching kombinieren. Zum geprüften Zeitpunkt bietet Orux AI für kein Modell Batch-Verarbeitung: Anfragen sind gewöhnlich synchron oder gestreamt.
Vergleich je Million tokens:
| Modell | Anthropic Batch | Orux AI Standard | Günstiger |
|---|---|---|---|
| Opus 5.5 | $2 / $10 | $1.90 / $9.50 | Orux AI, 5% günstiger |
| Sonnet 5.5 | $1 / $5 | $0.95 / $4.75 | Orux AI, 5% günstiger |
| Haiku 5.5, ≤100K | $0.05 / $0.25 | $0.054 / $0.27 | Anthropic Batch, etwa 7% günstiger |
| Haiku 5.5, >100K | $0.25 / $1.25 | $0.28 / $1.40 | Anthropic Batch, etwa 11% günstiger |
Horizontal wischen, um die ganze Tabelle zu sehen.
Bei großen Haiku-Offline-Aufgaben mit Wartezeit ist die direkte Batch API günstiger. Für Opus und Sonnet liegt Orux' Standardpreis etwas unter Anthropics Batch-Preis, ohne auf das Ende eines Stapels warten zu müssen.
Kosten je Aufgabe: drei Lastprofile
Millionenpreise sind abstrakt. Diese drei üblichen Anfrageformen sind deshalb je 1,000 Anfragen ohne Cache berechnet:
| Last je Anfrage | Haiku 5.5 | Sonnet 5.5 | Opus 5.5 |
|---|---|---|---|
| Support:2,000 Eingabe/500 Ausgabe | 48.6 Cr ($0.243) vs $0.45 | 855 Cr ($4.275) vs $9.00 | 1,710 Cr ($8.55) vs $18.00 |
| RAG:20,000 Eingabe/800 Ausgabe | 259.2 Cr ($1.296) vs $2.40 | 4,560 Cr ($22.80) vs $48.00 | 9,120 Cr ($45.60) vs $96.00 |
| Coding-Agent-Runde:50,000 Eingabe/4,000 Ausgabe | 756 Cr ($3.78) vs $7.00 | 13,300 Cr ($66.50) vs $140.00 | 26,600 Cr ($133.00) vs $280.00 |
Horizontal wischen, um die ganze Tabelle zu sehen.
In jeder Zelle ist der erste Betrag Orux AI, der zweite Anthropics Listenpreis.
Die Programmierzeile zeigt den Cache-Nutzen: Agenten senden denselben Repository-Kontext immer wieder. Sind 45,000 von 50,000 Eingabe-tokens bei Sonnet 5.5 Cache-Lesen, sinken 1,000 Runden von 13,300 auf 5,290 Credits ($26.45), beim offiziellen Preis von $140 auf $54.50.
Die Modellwahl zählt mehr als ein Rabatt. Bei der Support-Aufgabe kostet Opus genau doppelt so viel wie Sonnet und rund 35-mal so viel wie Haiku. Einfache Anfragen zu Haiku leiten und Opus für Aufgaben aufheben, die tatsächlich an Sonnet scheitern.
Python-Kostenrechner
Orux AI stellt Claude über den OpenAI-kompatiblen Endpunkt https://orux.top/api/v1 bereit. Im OpenAI-Python-SDK genügt eine andere base_url. Das Skript ruft ein Modell auf und rechnet das zurückgegebene usage mit den veröffentlichten Preisen in Credits um, einschließlich beider Haiku-Stufen.
import os
from openai import OpenAI
client = OpenAI(base_url="https://orux.top/api/v1", api_key=os.environ["ORUX_API_KEY"])
# Credits per 1M tokens on Orux AI, checked 2026-10-29
# (input, output, cache_read, cache_write_5m)
RATES = {
"claude-opus-5-5": [(None, (380, 1900, 22, 475))],
"claude-sonnet-5-5": [(None, (190, 950, 12, 237.5))],
"claude-haiku-5-5": [(100_000, (10.8, 54, 1.1, 13.75)), # prompt <= 100K
(None, (56, 280, 5.6, 70))], # prompt > 100K
}
USD_PER_CREDIT = 0.005
def credits_for(model: str, usage) -> float:
details = getattr(usage, "prompt_tokens_details", None)
cached = getattr(details, "cached_tokens", 0) or 0
written = getattr(details, "cache_creation_tokens", 0) or 0
prompt = usage.prompt_tokens # includes cached + written
for limit, (inp, out, read, write) in RATES[model]:
if limit is None or prompt <= limit:
break
fresh = prompt - cached - written
total = (fresh * inp + cached * read + written * write
+ usage.completion_tokens * out) / 1e6
return max(round(total, 6), 0.001) # 0.001 Credit minimum per request
model = "claude-haiku-5-5"
resp = client.chat.completions.create(
model=model,
messages=[{"role": "user", "content": "Classify this ticket as billing, bug or other: "
"'I was charged twice for October.'"}],
max_tokens=50,
)
c = credits_for(model, resp.usage)
print(resp.choices[0].message.content)
print(f"{resp.usage.prompt_tokens} in / {resp.usage.completion_tokens} out "
f"= {c} Credits (${c * USD_PER_CREDIT:.6f})")Das Ergebnis ist eine Schätzung. Maßgeblich ist der Betrag in der Orux-Nutzungshistorie; Cache-Schreiben wird hier zum Fünf-Minuten-Preis geschätzt. Fehlgeschlagene Anfragen werden nicht berechnet.
Für dieselbe Anfrage einfach model wechseln. Der Sonnet-5.5-API-Einstieg auf Englisch behandelt JSON und Validierung ausführlicher. Der Sonnet-5.5/GPT-6-Luna/Gemini-4-Argon-Vergleich auf Englisch zeigt den gleichen Prompt auf drei Modellen.
Welcher Claude für welche Aufgabe?
Haiku 5.5 passt zu Klassifikation, Extraktion, Routing und kurzen Support-Antworten, solange Prompts unter 100K bleiben. Mit 48.6 Credits je 1,000 Antworten ist es ein Kandidat für jede eingehende Nachricht.
Sonnet 5.5 ist der Standardkandidat für Entwürfe, Debugging und mehrstufige Arbeit. Dieselbe Anfrage kostet 17.6-mal Haiku: Vor einem Upgrade messen, ob Haiku tatsächlich scheitert.
Opus 5.5 ist für lange, urteilsintensive Aufgaben, bei denen ein Fehler mehr kostet als die tokens: große Refactorings, ausführliche Analysen und schwieriges Schlussfolgern. Beim doppelten Sonnet-Preis gezielt einsetzen.
Wenn der Preis entscheidend und Claude nicht erforderlich ist, ordnet unser Vergleich günstiger LLM APIs auf Englisch 14 Modelle mit derselben Last ein.
FAQ
Wie viel kostet Claude API je Million tokens?
Anthropic listet Opus 5.5 mit $4/$20 Eingabe/Ausgabe, Sonnet mit $2/$10 und Haiku bis 100K mit $0.10/$0.50, darüber $0.50/$2.50. Orux AI kostet 380/1,900, 190/950 und 10.8/54 Credits; Stand 29. Oktober 2026.
Ist Claude Haiku 5.5 günstiger als GPT-6 Luna?
Nicht auf Orux AI. GPT-6 Luna kostet unter 270K Eingabe 5.4/27 Credits je Million tokens, exakt die Hälfte von Haikus 10.8/54. Offiziell liegen beide im Basistarif bei $0.10/$0.50. Qualität hängt von der Aufgabe ab; eigene Prompts vor dem Wechsel testen.
Reduziert Prompt-Caching die Claude-Kosten?
Ja, wenn ein langer Präfix wiederkehrt. Fünf-Minuten-Schreiben kostet 1.25 Eingaben, Anthropic-Lesen bei Opus/Sonnet 0.05; die erste Wiederverwendung amortisiert es. Im Beispiel fällt der 10,000-token-Systemprompt über 1,000 Nutzungen bei Orux von 1,900 auf ungefähr 122 Credits.
Gibt es einen kostenlosen Claude-API-Tarif?
Anthropics Preis-FAQ beschreibt ein kleines Testguthaben für neue Nutzer, aber keinen dauerhaften kostenlosen Produktionstarif. Orux AI hat weder Abonnement noch Monatsgebühr: Guthaben aufladen und je Anfrage bezahlen, ohne Gebühr für fehlgeschlagene Anfragen.
Wie unterscheidet sich Orux' Abrechnung von Anthropic?
Orux AI belastet vorausbezahlte Credits, mit 1 Credit=$0.005. Die Claude-5.5-Basistarife entsprechen etwa 47.5–56% der offiziellen Preise. Ein Schlüssel gilt außerdem für GPT, Gemini, DeepSeek, Bild und Video. Eine Batch API fehlt; für große Haiku-Offline-Jobs ist Anthropics Batch günstiger.
Quellen und Preisstand
Preise geprüft am 2026-10-29. Offizielle Tarife, Cache-Faktoren, Haiku-Grenze und Batch: Anthropic-Claude-Preise. Orux: Claude Opus 5.5, Claude Sonnet 5.5, Claude Haiku 5.5 und GPT-6 Luna. Vor dem Budget erneut nachsehen; Preise können sich ändern.
Diese Modelle über eine einzige API nutzen
Eine OpenAI-kompatible API für Chat-, Bild-, Video- und Audiomodelle, abgerechnet in Credits.
Ähnliche Artikel
Alle Artikel ansehen →
Claude Sonnet 5.5 vs GPT-6 Luna vs Gemini 4 Argon
Sonnet, Luna und Argon nach Credits, Cache und Parametern vergleichen. Mit Python, geprüftem JSON-Fall und klaren Grenzen des historischen Vergleichs.

Kling 4.0 API: Preise, Parameter und echte Videos
Kling 4.0 bei Orux und fal: Preise, alle Parameter, Python mit gespeicherter Task-ID und zwei echte Videos samt Grenzen bei Neustart und erneuter Abrechnung.

Claude Sonnet 5.5 API: Preise und geprüftes JSON
Claude Sonnet 5.5 API mit Python: 190/950 Credits je 1M tokens, 2 echte Extraktionen, Node/Python-Prüfer, 9 Ablehnungen und Kosten pro Aufruf.