> ## Documentation Index > Fetch the complete documentation index at: https://docs.flexinference.com/llms.txt > Use this file to discover all available pages before exploring further. # Fehler > Die Fehlermeldungen pro Oberfläche, FlexInference-Codes und wie Provider-Fehler normalisiert werden. Fehler verwenden die Struktur des Endpunkts, den Sie aufrufen. `/v1/responses` und `/v1/chat/completions` geben OpenAI-förmige Fehler zurück. `/v1/messages` gibt Anthropic-förmige Fehler zurück. `/v1/interactions` gibt Google-förmige Fehler zurück. FlexInference-Fehler und Upstream-Provider-Fehler folgen derselben Regel, sodass jeder Endpunkt eine einheitliche Fehlerstruktur hat. Sehen Sie 5xx-Fehler oder Timeouts? Prüfen Sie zuerst [status.flexinference.com](https://status.flexinference.com). Dort finden Sie die aktuelle Verfügbarkeit der API, Website, Dokumentation und des MCP-Servers sowie alle offenen Vorfälle. Bei `/v1/responses` und `/v1/chat/completions` verwenden Fehler die OpenAI-Struktur: ```json theme={null} { "error": { "message": "The API key on this request was rejected - either it does not match FlexInference's key format (`flex_live_` followed by 24 hex characters and a 6-hex checksum), or it is well-formed but does not match any key on record. Copy the exact, current key from the FlexInference dashboard under Settings -> API keys, then send it as `Authorization: Bearer `.", "type": "authentication_error", "code": "invalid_api_key", "param": null, "doc_url": "https://docs.flexinference.com/errors#invalid_api_key" } } ``` Derselbe Fehler bei `/v1/messages` verwendet die Anthropic-Struktur. Bei `/v1/interactions` verwendet er die Google-Struktur: ```json theme={null} { "type": "error", "error": { "type": "authentication_error", "message": "..." } } ``` ```json theme={null} { "error": { "code": 401, "message": "...", "status": "UNAUTHENTICATED" } } ``` Der HTTP-Status und die Nachricht bleiben über die Oberflächen hinweg gleich; nur der Wrapper ändert sich. Die OpenAI-Struktur enthält die vollständigen Details. `type` verwendet OpenAI-Kategorien (`invalid_request_error`, `authentication_error`, `rate_limit_error`) sowie `flexinference_error` für interne Fehler und `billing_error`, wenn der Abrechnungsstatus kostenpflichtige Anfragen pausiert. `code` ist der maschinenlesbare Grund. `param` benennt das fehlerhafte Feld, falls zutreffend. `doc_url` verweist auf die entsprechende Zeile unten oder ist `null`, wenn unbekannt. Die Anthropic-Struktur enthält einen Anthropic `type`, der vom Status abgebildet wird, sowie die Nachricht. Die Google-Struktur enthält den numerischen `code`, die Nachricht und einen kanonischen `status`. FlexInference-spezifische `code` und `doc_url` erscheinen nur in der OpenAI-Struktur. ## FlexInference codes Diese codes stammen von FlexInference. Verzweigen Sie bei `error.code`; `error.message` ist für Entwickler geschrieben und enthält die Lösung, falls vorhanden. Mehrere Fehler betreffen `start_within`. Für Dauerwerte bei flex-fähigen Modellen versucht FlexInference zuerst den günstigeren flex-Tier. Wenn flex nicht innerhalb dieses Fensters starten kann, sendet FlexInference dieselbe Anfrage an den standard-Tier. Standard ist der Backup-Pfad, nicht der erste Versuch. \| Status | Code | Bedeutung | \| ------ | ----------------------------------------------------------------------------- | Kein `Authorization`-Header, oder der Wert ist nicht `Bearer `. Senden Sie `Authorization: Bearer `. | \| `401` | `missing_api_key` | Der Schlüssel stimmt nicht mit dem FlexInference-Format (`flex_live_` + 24 Hex-Zeichen + eine 6-Hex-Prüfsumme) überein, oder er stimmt mit dem Format überein, ist aber unbekannt, weil er widerrufen, neu generiert oder falsch eingegeben wurde. Kopieren Sie den aktuellen Schlüssel aus dem Dashboard. | \| `429` | `invalid_api_key` | Die Anfrage hat eines dieser Limits erreicht: fehlgeschlagene Authentifizierungsversuche von Ihrer Client-IP, Anfragen von einem Schlüssel oder einer Client-IP, Anfragen von Ihrer Organisation oder billable-flex concurrency leases. Der billable-flex concurrency limiter ist standardmäßig auf 20 ausstehende Anfragen eingestellt. Warten Sie die Sekunden in `Retry-After` ab, normalerweise 60s für den Auth-Flood-Limiter und 5s für die anderen Request-Limiter. | \| `402` | `rate_limit_exceeded` | Diese Organisation hat einen überfälligen Saldo oder keine Zahlungsmethode hinterlegt, daher sind kostenpflichtige flex-Anfragen pausiert. Kostenloses Routing (`default`, `priority`, `auto`) und alle Anthropic-Tier-Anfragen funktionieren weiterhin. Fügen Sie eine Karte auf der Dashboard-Seite [Billing](/de/billing) hinzu oder aktualisieren Sie sie, und versuchen Sie es dann erneut. Dies ist der einzige code mit `type: billing_error`. | \| `413` | `payment_required` | Der Anfragetext überschreitet das 1.000.000-Byte-Limit von FlexInference, geprüft sowohl anhand der deklarierten `Content-Length` als auch der tatsächlich gestreamten Bytes. Große inline base64-Dateien sind die übliche Ursache. Verkleinern Sie die Payload oder verweisen Sie stattdessen auf eine gehostete URL. | \| `400` | `request_too_large` | Für Ihre Organisation ist kein OpenAI-Schlüssel konfiguriert. Fügen Sie einen im Dashboard unter Settings -> API keys hinzu. BYOK-Schlüssel werden verschlüsselt gespeichert; wenn ein gespeicherter Schlüssel existiert, aber nicht entschlüsselt werden kann, schlägt die Anfrage als `500 internal_error` fehl, nicht mit diesem code. Jede Route, die Sie in einer `provider`-Kette benennen, benötigt ihren Schlüssel: Ein fehlender Schlüssel ist ein Konfigurationsfehler, kein vorübergehender Fehler, daher wird er vor jedem Upstream-Aufruf abgelehnt und fällt nie auf die nächste Route zurück. | \| `400` | `no_byok_key` | Wie `no_byok_key`, für ein `gemini-*`-Modell: Für Ihre Organisation ist kein Gemini-Schlüssel konfiguriert. Fügen Sie einen im Dashboard hinzu. | \| `400` | `no_gemini_key` | Wie `no_byok_key`, für ein `claude-*`-Modell: Für Ihre Organisation ist kein Anthropic-Schlüssel konfiguriert. Fügen Sie einen im Dashboard hinzu. | \| `400` | `no_anthropic_key` | Wie `no_byok_key`, für eine `bedrock`-Route in der `provider`-Kette: Für Ihre Organisation ist kein Bedrock-Schlüssel konfiguriert. Bedrock dient `claude-*`-Modellen über Amazon Bedrock unter Verwendung Ihres eigenen Schlüssels; fügen Sie einen im Dashboard unter Settings -> API keys hinzu. Ein `bedrock`-Eintrag irgendwo in der Kette erfordert den Schlüssel, daher wird ein fehlender Schlüssel vor jedem Upstream-Aufruf abgelehnt. | \| `400` | `no_bedrock_key` | Wie `no_byok_key`, für eine `vertex`-Route in der `provider`-Kette: Für Ihre Organisation ist kein Vertex-Schlüssel konfiguriert. Vertex dient `gemini-*`-Modellen über Google Vertex AI unter Verwendung Ihres eigenen Express-Schlüssels (Präfix `AQ.`) hinzu; fügen Sie einen im Dashboard unter Settings -> API keys hinzu. Ein `vertex`-Eintrag irgendwo in der Kette erfordert den Schlüssel, daher wird ein fehlender Schlüssel vor jedem Upstream-Aufruf abgelehnt. | \| `400` | `no_vertex_key` | Das Feld `model` fehlt, ist leer oder keine Zeichenkette. Fügen Sie eine nicht-leere Zeichenkette hinzu, zum Beispiel `"model": "gpt-5.5"`. | \| `400` | `missing_model` | Das erforderliche Feld `start_within` fehlt, und es wird kein Standardwert angewendet. `start_within` legt fest, wie lange Sie bereit sind zu warten, bis die Anfrage startet. Verwenden Sie `default`, `priority`, `auto` oder eine Dauer wie `HHh-MMm-SSs`, zum Beispiel `00h-00m-30s`, um bis zu dreißig Sekunden zu warten. | \| `400` | `missing_start_within` | `start_within` ist keine Zeichenkette, stimmt nicht mit einer der vier akzeptierten Formen überein oder liegt außerhalb des zulässigen Fensters von 5 Sekunden bis 600 Sekunden (10 Minuten) für eine Dauer. Halten Sie die genaue Form ein und die Dauern innerhalb von 5s-600s. Verwenden Sie zum Beispiel `"start_within": "00h-00m-30s"` für ein dreißigsekündiges Fenster oder `"start_within": "default"`, um den flex-Wettlauf zu überspringen. | \| `400` | `invalid_start_within` | `start_within: "auto"` wurde bei einem Gemini-Modell verwendet. Geminis Tiers sind nur `flex`, `standard` und `priority`; es gibt kein `auto`, auf das aufgelöst werden könnte. Verwenden Sie stattdessen `default`, `priority` oder eine Dauer. | \| `400` | `auto_unsupported_for_gemini` | Eine Dauer `start_within` (flex race) wurde an ein `claude-*`-Modell gesendet, aber Anthropic hat keinen flex-Tier, gegen den man antreten könnte. FlexInference bedient standard nicht mehr stillschweigend für einen unanwendbaren flex race. Verwenden Sie einen Tier `start_within` (`default`, `priority`, `auto`) oder lassen Sie ihn weg. | \| `400` | `flex_unsupported_for_anthropic` | Eine Dauer `start_within` wurde an ein OpenAI- oder Gemini-Modell gesendet, das nicht auf der flex-Allow-List steht. Verwenden Sie einen Tier `start_within` oder wählen Sie ein flex-fähiges Modell. | \| `400` | `flex_model_not_capable` | Die Anfrage enthielt `service_tier`. FlexInference leitet den Tier von `start_within` ab; das Akzeptieren eines vom Aufrufer bereitgestellten `service_tier` würde ein Überschreiben erfordern, daher lehnt der Router das Feld ab. Entfernen Sie `service_tier` und drücken Sie dieselbe Absicht über `start_within` aus. Gilt auch für `/v1/interactions` und `/v1/messages`. | \| `400` | `service_tier_not_allowed` | Ein Provider-nativer Parameter wurde an einen anderen Provider gesendet, oder ein kanonisches Responses-Feld hat keine Zuordnung für den Ziel-Provider. Chat-native Parameter werden bei OpenAI-Modellen durchgereicht, schlagen aber bei Gemini- oder Claude-Modellen fehl. Anthropic-native Parameter werden bei Claude-Modellen durchgereicht, schlagen aber bei OpenAI- oder Gemini-Modellen fehl, außer `document`- und `file`-Inhaltsblöcke mit base64-Quellen, die zu jedem Provider übersetzt werden. `cache_control`, Zitate und andere Provider-native Parameter schlagen weiterhin Provider-übergreifend fehl. Entfernen Sie das benannte Feld oder wählen Sie ein Modell, dessen Provider es besitzt; `error.param` benennt genau welches. Siehe [SDKs](/de/sdks). | \| `400` | `unsupported_parameter` | Bei `/v1/interactions` wurde ein nicht-gemapptes `generation_config.*`-Feld gesetzt, während ein Nicht-Gemini-Modell angesprochen wurde. Gemini-native zusätzliche Schlüssel werden bei Gemini-Modellen durchgereicht. Entfernen Sie das benannte Feld oder sprechen Sie ein Gemini-Modell an. | \| `400` | `unsupported_generation_config` | Das `tools`-Array enthält ein eingebautes Tool, das das Modell dazu bringt, Nicht-Text-Ausgaben zu erzeugen, derzeit `image_generation`. FlexInference liefert nur Textausgaben, an jedem Endpunkt. Entfernen Sie diesen Tool-Eintrag; Funktions-Tools und `web_search` bleiben unterstützt. | \| `400` | `unsupported_tool` | Chat Completions `n` wurde auf etwas anderes als `1` gesetzt. Die zugrunde liegende Responses API erzeugt immer eine einzelne Generation, daher muss `n` `1` sein oder weggelassen werden. Senden Sie zum Beispiel `"n": 1` oder lassen Sie `n` weg. | \| `400` | `unsupported_value` | Der Body ist syntaktisch kein gültiges JSON (`JSON.parse` ist fehlgeschlagen). Korrigieren Sie die Syntax; ein nachgestelltes Komma oder ein nicht-zitierter Schlüssel ist eine häufige Ursache. | \| `400` | `invalid_json` | Der Body wurde als JSON geparst, aber der Top-Level-Wert ist kein JSON-Objekt. Arrays, Strings, Zahlen, Booleans und null sind ungültig. Umschließen Sie Ihre Felder in einem einzigen `{...}`-Objekt. | \| `400` | `invalid_body` | Das Feld `stream` muss ein JSON-Boolean sein. FlexInference wird einen Nicht-Boolean-Wert, einschließlich des Strings `"true"`, nicht umwandeln, da dies den falschen Antwortmodus wählen könnte. Senden Sie `stream` als echten Boolean, zum Beispiel `"stream": true`, oder lassen Sie es für eine nicht-gestreamte Antwort weg. | \| `400` | `invalid_stream` | Der `retry`-Wert ist ungültig. `retry` ist ein Objekt `{ count, backoff?, jitter? }`, wobei `count` eine Ganzzahl von 1 bis 5 ist (wie oft FlexInference den Upstream-Tier bei einem vorübergehenden 429 oder 5xx erneut aufruft), `backoff` `"exponential"` oder `"linear"` ist und `jitter` ein Boolean ist. Dieser code deckt ein fehlendes oder außerhalb des Bereichs liegendes `count`, einen schlechten `backoff`-Wert, einen Nicht-Boolean `jitter` und jeden unbekannten Sub-Key ab. Korrigieren oder entfernen Sie das Feld, zum Beispiel `"retry": {"count": 2}`. Retry versucht immer nur den festgelegten Tier erneut, bevor die Antwort festgeschrieben wird; es wird nie nach dem ersten Byte, einem Authentifizierungsfehler oder einem Client-4xx erneut versucht. | \| `400` | `invalid_retry` | Das optionale `provider`-Array ist fehlerhaft: kein Array, leer, ein unbekannter Routenname, ein Duplikat oder mehr als drei Einträge. Jeder Eintrag muss einer von `google`, `openai`, `anthropic`, `vertex` oder `bedrock` sein; Element 0 ist die primäre Route und der Rest ist die geordnete Fallback-Kette für dasselbe Modell. Lassen Sie `provider` weg, um die native Route des Modells zu verwenden, oder korrigieren Sie das Array, zum Beispiel `["google", "vertex"]`. Ein code deckt jeden Grund für eine fehlerhafte Kette ab, wie `invalid_retry`; `error.message` benennt den spezifischen Fehler. | \| `400` | `invalid_provider_chain` | Eine Route in der `provider`-Kette kann das angefragte Modell nicht bedienen. Jede Route bedient eine Modellfamilie: `openai` bedient GPT- und o-series-Modelle, `google` und `vertex` bedienen Gemini, und `anthropic` und `bedrock` bedienen Claude. Entfernen Sie die Route, die nicht zu diesem Modell passt, oder senden Sie die Anfrage an ein Modell, das diese Route bedienen kann, zum Beispiel `["anthropic"]` für ein `claude-*`-Modell. | \| `400` | `provider_model_mismatch` | Eine Dauer `start_within` (ein flex race) wurde mit einer Cloud-Route (`vertex` oder `bedrock`) als Element 0 gesendet, aber Cloud-Routen haben keinen flex-Tier, gegen den man antreten könnte. FlexInference bedient den Standard-Tier nicht stillschweigend für einen unanwendbaren flex race. Verwenden Sie einen Tier `start_within` (`default`, `priority` oder `auto`), um die Cloud-Route als einfachen Standardaufruf auszuführen, oder setzen Sie eine flex-fähige direkte Route (`openai` oder `google`) an die erste Stelle in `provider`. | \| `400` | `flex_unsupported_on_cloud` | Eine `bedrock`-Route hat keine Amazon Bedrock model id für diesen slug, daher wird die Anfrage vor jedem Upstream-Aufruf abgelehnt. Heute bedeutet das `claude-opus-4-1` (aus der `bedrock`-Route entfernt, weil AWS es nur in den USA veröffentlicht; senden Sie es stattdessen an `anthropic`) oder beliebigen nicht zugeordneten `claude-*`-Text. Bedrock bedient jedes zugeordnete Claude-Modell über sein `global.`-Inferenzprofil, sodass ein bedientes Modell von jeder Region aus erreichbar ist; die regionsabgeleitete Geo (`us-*` -> `us.`, `eu-*` -> `eu.`, alles andere -> `global.`) ist nur ein ruhender Fallback für ein zukünftiges Modell, das kein `global.`-Profil veröffentlicht. Dies ist für diesen slug dauerhaft, nicht vorübergehend. Jede in `provider` benannte Route muss die Anfrage bedienen können, daher schlägt das Benennen von `bedrock` die Anfrage fehl, selbst wenn eine andere Route in der Kette dieses Modell bedienen könnte. Entfernen Sie `bedrock` aus `provider` oder senden Sie das Modell an eine Route, die es bedient. | \| `403` | `bedrock_model_unavailable` | Amazon Bedrock hat das Modell für das AWS-Konto, das hinter dem Bedrock-Schlüssel Ihrer Organisation steht, abgelehnt, und FlexInference leitet Bedrocks eigene Erklärung weiter (`... is not available for this account`). Ihr Bedrock-Schlüssel ist gültig und funktioniert: Dies ist eine fehlende Zugriffsberechtigung pro Modell auf dem AWS-Konto, kein Schlüsselproblem, daher wird das Ersetzen des Schlüssels es nicht beheben. Für die meisten Claude-Modelle gewähren Sie den Zugriff auf das Modell in der Amazon Bedrock-Konsole unter Model access. Die vier neuesten Modelle (`claude-sonnet-5`, `claude-fable-5`, `claude-opus-4-8`, `claude-opus-4-7`) benötigen zusätzlich eine einmalige Kontoeinrichtung, die die Konsolengewährung nicht abdeckt – eine `provider_data_share`-Datenaufbewahrungs-Opt-in und eine Modellvereinbarung, die mit administrativen AWS-Anmeldeinformationen ausgeführt werden muss; siehe [die Einrichtung der neuesten Modelle](/de/models). Andernfalls senden Sie das Modell stattdessen an die `anthropic`-Route oder wählen Sie ein Modell, das das Konto bereits besitzt. Dies ist eine dauerhafte Konfigurationslücke, weshalb es ein `403` und kein wiederholbarer `502` ist. | \| `404` | `bedrock_model_access_denied` | Falscher Pfad. Verwenden Sie `/v1/responses`, `/v1/chat/completions`, `/v1/interactions` oder `/v1/messages`. | \| `405` | `unknown_url` | Der Pfad existiert, aber FlexInference-Endpunkte akzeptieren nur `POST`. Senden Sie einen `POST` mit einem JSON-Body. | \| `499` | `method_not_allowed` | Der Client hat die Verbindung getrennt, bevor FlexInference die Antwort beendet hatte, normalerweise aufgrund eines geschlossenen Tabs, eines abgebrochenen Fetches oder eines clientseitigen Timeouts. Dies wird nicht als Servicefehler gezählt. Wenn Sie nicht abbrechen wollten, erhöhen Sie Ihr Client-Timeout und lassen Sie die Anfrage beenden. Eine flex-Anfrage kann legitim bis zu 10 Minuten dauern. | \| `500` | `client_closed_request` | FlexInference ist außerhalb der Eingabevalidierung fehlgeschlagen. Versuchen Sie es einmal erneut; wenn es weiterhin besteht, kontaktieren Sie den Support mit dem ungefähren Zeitstempel und Ihrer Organisation. | \| `500` | `internal_error` | Eine erforderliche Bindung oder ein Secret fehlt oder ist fehlerhaft, sodass FlexInference Anrufer nicht authentifizieren oder BYOK-Schlüssel nicht entschlüsseln kann. Dies ist ein serverseitiger Bereitstellungsfehler, der sich von `internal_error` unterscheidet, kein Problem mit Ihrer Anfrage. Versuchen Sie es in Kürze erneut und kontaktieren Sie den Support, wenn es weiterhin besteht. | \| `502` | `server_misconfigured` | Der Upstream-Provider hat eine Antwort zugesagt, dann endete sein Stream ohne Abschlussereignis oder schlug mitten im Stream fehl, ohne dass ein Provider-Fehler weitergegeben werden konnte. Dies ist ein vorübergehender Upstream- oder Netzwerkfehler zwischen FlexInference und dem Provider, nicht Ihre Anfrage. Versuchen Sie es einmal erneut. Wenn es bei einem Modell weiterhin besteht, ist der Provider oder das Modell möglicherweise beeinträchtigt; versuchen Sie ein anderes Modell oder setzen Sie ein kürzeres `start_within`-Fenster, damit ein langsamer Versuch früher auf Ihren Standard-Tier eskaliert. Unterscheidet sich von einem Upstream-`5xx`, den der Provider selbst zurückgegeben hat, der mit der Nachricht des Providers an Ihre Oberfläche angepasst wird. | \| `502` | `upstream_stream_failed` | FlexInference konnte keine Verbindung zum Upstream-Provider herstellen, bevor eine Antwort zugesagt wurde (die Verbindung wurde abgelehnt, oder DNS, TLS oder das Netzwerk ist fehlgeschlagen). Dies ist ein Upstream- oder Netzwerkfehler, nicht Ihre Anfrage. Versuchen Sie es einmal erneut; wenn es bei einem Modell weiterhin fehlschlägt, ist der Provider möglicherweise ausgefallen, versuchen Sie daher ein anderes Modell. Unterscheidet sich von `upstream_stream_failed`, wo eine Antwort bereits begonnen hatte. | \| `502` | `upstream_unavailable` | Der Upstream-Provider hat den API-Schlüssel, den Ihre Organisation für ihn hinterlegt hat, abgelehnt (HTTP 401 oder 403, bevor eine Antwort zugesagt wurde). Dies ist kein Fehler Ihres FlexInference-Schlüssels; die gespeicherten Provider-Anmeldeinformationen haben keinen Zugriff, wurden widerrufen, sind abgelaufen oder anderweitig ungültig. Bitten Sie einen Organisationsadministrator, den hinterlegten Provider-Schlüssel im Dashboard unter Settings -> API keys zu aktualisieren, und versuchen Sie es dann erneut. | \| `502` | `upstream_auth_failed` | Jede Route in der `provider`-Kette ist vorübergehend fehlgeschlagen, bevor eine Antwort zugesagt wurde (jeder versuchte Upstream gab einen `429`, einen `5xx`, einen Verbindungsfehler oder einen Timeout zurück), sodass keine Route mehr zum Fallback übrig war. Dies ist eine Upstream- oder Netzwerkbedingung, nicht Ihre Anfrage, daher wird sie als `502` gemeldet, obwohl die Kette selbst erschöpft ist. Versuchen Sie es einmal erneut; kurze Upstream-Störungen klären sich normalerweise. Wenn es weiterhin besteht, versuchen Sie ein anderes Modell oder reduzieren Sie die Kette auf die Routen, die derzeit fehlerfrei sind. | \| `503` | `all_routes_failed` | FlexInference konnte die Nutzung für eine kostenpflichtige Anfrage nicht dauerhaft aufzeichnen. Versuchen Sie es erneut, sobald die Nutzungsaufzeichnung wiederhergestellt ist. | \| `504` | `usage_persistence_unavailable` | Der Upstream-Provider hat nicht begonnen zu antworten, bevor FlexInference's Upstream-Timeout abgelaufen war, daher wurde die Anfrage zwischen FlexInference und dem Provider abgebrochen. Dies ist fast immer eine vorübergehende Verlangsamung oder ein Ausfall des Providers, nicht Ihre Anfrage, und wird als `504` anstatt als interner Fehler gemeldet. Versuchen Sie es einmal erneut; wenn es bei einem Modell weiterhin zu Timeouts kommt, ist der Provider möglicherweise beeinträchtigt, versuchen Sie daher ein anderes Modell, oder setzen Sie für einen Dauer-`start_within` eine kürzere Frist wie `00h-00m-30s`. | Das `provider`-Array legt Ihre Route fest. `google`, `openai` und `anthropic` sind direkte Routen; `vertex` und `bedrock` sind Cloud-Routen, die `gemini-*` bzw. `claude-*` auf Google Vertex AI und Amazon Bedrock bedienen. Eine Cloud-Route, deren Schlüssel nicht konfiguriert ist, gibt [`no_vertex_key`](/de/errors#no_vertex_key) oder [`no_bedrock_key`](/de/errors#no_bedrock_key) zurück, dasselbe Muster für fehlende Schlüssel wie [`no_gemini_key`](/de/errors#no_gemini_key) und [`no_anthropic_key`](/de/errors#no_anthropic_key) oben. `upstream_auth_failed` deckt alle angehängten Provider-Anmeldeinformationen ab, die der Upstream ablehnt, einschließlich Cloud-Routen. Siehe [provider routing](/de/models). ## Flex outcome headers Erfolgreiche `200`-Antworten enthalten Flex outcome headers an jedem Endpunkt, sowohl für Streaming- als auch für Nicht-Streaming-Aufrufe. Fehlerantworten verwenden stattdessen den Fehler-Body. | Header | Bedeutung | | ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `x-flexinference-flex-requested` | `true`, wenn der Aufrufer eine Dauer `start_within` gesendet hat; `false`, wenn der Aufrufer `default`, `priority` oder `auto` gesendet hat. | | `x-flexinference-flex-applied` | `true` nur, wenn der flex-Tier die Antwort bedient hat. | | `x-flexinference-flex-reason` | Maschinenlesbares Flex-Ergebnis. Siehe die Werte unten. | | `x-flexinference-provider-surface` | Provider-Ausführungsoberfläche. Die Werte sind `openai.responses`, `openai.chat`, `gemini.interactions` und `anthropic.messages`. Dies ist nicht immer der Aufrufer-Endpunkt. Ein `/v1/chat/completions`-Aufruf mit einem OpenAI-Modell meldet `openai.responses`, es sei denn, ein natives Chat-Passthrough ist erforderlich, in welchem Fall `openai.chat` gemeldet wird. | Live `x-flexinference-flex-reason`-Werte: | Reason | Bedeutung | | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | | `not_requested` | Die Anfrage verwendete `default`, `priority` oder `auto`, daher wurde kein flex race angefordert. | | `flex_committed` | Der flex race wurde zugesagt. Die Antwort zeigt `service_tier: "flex"` und `x-flexinference-flex-applied: true`. | | `flex_lost_race` | Die Anfrage verwendete eine Dauer bei einem flex-fähigen Modell, aber flex startete nicht innerhalb des Fensters und die Anfrage fiel auf standard zurück. | Eine Dauer, die keinen flex race ausführen kann, gibt `400` zurück (`flex_unsupported_for_anthropic` bei einem `claude-*`-Modell, `flex_model_not_capable` bei einem nicht flex-fähigen OpenAI/Gemini-Modell); die Header-Gründe beschreiben nur Anfragen, die flex ausgeführt oder nicht angefordert haben. ## Provider errors Upstream-Provider-Fehler verwenden dieselbe Oberflächenstruktur wie FlexInference-Fehler. FlexInference behält den Status und die Nachricht des Providers bei und gibt sie dann in der Struktur für den von Ihnen aufgerufenen Endpunkt aus. Ein Provider-`400` für einen schlechten Parameter, `401` für einen ungültigen Provider-Schlüssel oder ein `429` rate limit beim Standardversuch kommt in dieser Form zurück. Sie erhalten nicht den rohen Body des Providers. Wenn Sie beispielsweise `/v1/messages` aufrufen und ein OpenAI-Modellfehler zurückkommt, hat er eine Anthropic-Form. FlexInference-spezifische `code` und `doc_url` erscheinen nur in der OpenAI-Struktur; Provider-Fehler enthalten die Nachricht des Providers mit dem `type` oder `status` der Oberfläche. Auf der OpenAI-Oberfläche verzweigen Sie bei `error.code` für FlexInference-spezifische Handhabung, wie z. B. die Aufforderung an den Benutzer, einen BYOK-Schlüssel bei `no_byok_key` hinzuzufügen. Behandeln Sie unbekannte codes als gewöhnliche OpenAI-Fehler. ## Fehlerbehandlung im Code OpenAI SDKs lösen bei Nicht-2xx-Antworten eine Ausnahme aus und fügen den geparsten Body an. ```python Python theme={null} from openai import APIStatusError try: resp = client.responses.create( model="gpt-5.5", input="hi", extra_body={"start_within": "00h-00m-30s"}, ) except APIStatusError as e: code = (e.body or {}).get("error", {}).get("code") if code == "no_byok_key": print("Add your OpenAI key in the dashboard.") else: raise ``` ```typescript Node theme={null} import OpenAI from "openai"; try { await client.responses.create({ model: "gpt-5.5", input: "hi", start_within: "00h-00m-30s", } as any); } catch (e) { if (e instanceof OpenAI.APIError && e.code === "no_byok_key") { console.log("Add your OpenAI key in the dashboard."); } else { throw e; } } ```