Zum Hauptinhalt springen

​
Fehlerantwort-Format

Alle Fehler geben ein konsistentes JSON-Format zurück: 
{
  "error": {
    "message": "Human-readable error description",
    "type": "error_type",
    "code": "error_code",
    "param": "parameter_name"  // Optional, for validation errors
  }
}

​
HTTP-Statuscodes

CodeBeschreibung
400Bad Request – Ungültige Parameter
401Unauthorized – Ungültiger oder fehlender API-Key
402Payment Required – Unzureichendes Guthaben
403Forbidden – Zugriff verweigert oder Modell nicht erlaubt
404Not Found – Modell oder Ressource nicht gefunden
413Payload Too Large – Eingabe- oder Dateigröße überschritten
429Too Many Requests – Rate-Limit überschritten
500Interner Serverfehler
502Bad Gateway – Fehler beim Upstream-Provider
503Service Unavailable – Alle Kanäle fehlgeschlagen
504Gateway Timeout – Zeitüberschreitung der Anfrage

​
Fehlertypen

​
Authentifizierungsfehler (401)

TypCodeBeschreibung
invalid_api_keyinvalid_api_keyAPI-Key fehlt oder ist ungültig
expired_api_keyexpired_api_keyAPI-Key wurde widerrufen
from openai import OpenAI, AuthenticationError

try:
    response = client.chat.completions.create(...)
except AuthenticationError as e:
    print(f"Authentication failed: {e.message}")

​
Zahlungsfehler (402)

TypCodeBeschreibung
insufficient_quotainsufficient_quotaKontoguthaben ist zu niedrig
quota_exceededquota_exceededNutzungslimit des API-Keys erreicht
from openai import OpenAI, APIStatusError

try:
    response = client.chat.completions.create(...)
except APIStatusError as e:
    if e.status_code == 402:
        print("Please top up your account balance")

​
Zugriffsfehler (403)

TypCodeBeschreibung
access_deniedaccess_deniedZugriff auf Ressource verweigert
access_deniedmodel_not_allowedModell für diesen API-Key nicht erlaubt
{
  "error": {
    "message": "You don't have permission to access this model",
    "type": "access_denied",
    "code": "model_not_allowed"
  }
}

​
Validierungsfehler (400)

TypBeschreibung
invalid_request_errorAnfrageparameter sind ungültig
context_length_exceededEingabe zu lang für das Modell
model_not_foundAngefordertes Modell existiert nicht
{
  "error": {
    "message": "model: 'invalid-model' is not a valid model",
    "type": "model_not_found",
    "param": "model"
  }
}

​
Rate-Limit-Fehler (429)

Wenn Sie Rate-Limits überschreiten: 
{
  "error": {
    "message": "Rate limit exceeded. Please slow down.",
    "type": "rate_limit_error",
    "code": "rate_limit_exceeded"
  }
}
Enthaltene Header: 
X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1234567890
Retry-After: 60

​
Payload Too Large (413)

Wenn die Eingabe- oder Dateigröße die Limits überschreitet: 
{
  "error": {
    "message": "Input size exceeds maximum allowed",
    "type": "invalid_request_error",
    "code": "payload_too_large"
  }
}
Häufige Ursachen:
  • Bilddatei zu groß (max. 20 MB)
  • Audiodatei zu groß (max. 25 MB)
  • Eingabetext überschreitet die Kontextlänge des Modells

​
Upstream-Fehler (502, 503)

TypBeschreibung
upstream_errorProvider hat einen Fehler zurückgegeben
all_channels_failedKeine verfügbaren Provider
timeout_errorZeitüberschreitung der Anfrage

​
Fehlerbehandlung in Python

from openai import OpenAI, APIError, RateLimitError, APIConnectionError

client = OpenAI(
    api_key="sk-your-api-key",
    base_url="https://api.lemondata.cc/v1"
)

def chat_with_retry(messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model="gpt-4o",
                messages=messages
            )
        except RateLimitError as e:
            if attempt < max_retries - 1:
                import time
                time.sleep(2 ** attempt)  # Exponential backoff
                continue
            raise
        except APIConnectionError as e:
            print(f"Connection error: {e}")
            raise
        except APIError as e:
            print(f"API error: {e.status_code} - {e.message}")
            raise

​
Fehlerbehandlung in JavaScript

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'sk-your-api-key',
  baseURL: 'https://api.lemondata.cc/v1'
});

async function chatWithRetry(messages, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await client.chat.completions.create({
        model: 'gpt-4o',
        messages
      });
    } catch (error) {
      if (error instanceof OpenAI.RateLimitError) {
        if (attempt < maxRetries - 1) {
          await new Promise(r => setTimeout(r, 2 ** attempt * 1000));
          continue;
        }
      }
      throw error;
    }
  }
}

​
Best Practices

Warten Sie bei einem Rate-Limit schrittweise länger zwischen den Versuchen:
wait_time = 2 ** attempt  # 1s, 2s, 4s, 8s...
Legen Sie immer angemessene Timeouts fest, um hängende Anfragen zu vermeiden:
client = OpenAI(timeout=60.0)  # 60 second timeout
Protokollieren Sie die vollständige Fehlerantwort einschließlich der Request-ID für den Support:
except APIError as e:
    logger.error(f"API Error: {e.status_code} - {e.message}")
Einige Modelle haben spezifische Anforderungen (z. B. maximale Tokens, Bildformate). Validieren Sie Eingaben, bevor Sie Anfragen stellen.