Håndtering af fejl og HTTP-koder
På denne side
Opdateret 3. november 2026 baseret på OpenAI-dokumentation:
temperatureogtop_paccepteres kun med en ræsonneringsindsats pånone, hvorimod GPT-5.6-modeller ræsonnerer som standard (medium). Kald, der sætter disse parametre, skal derfor specificerereasoning={"effort": "none"}(Responses API) ellerreasoning_effort="none"(Chat Completions). Kilder: Brug af GPT-6 · GPT-5.6 Terra.
Præciseret 3. november 2026 baseret på OpenAIs side om udfasede funktioner: eksemplet på en fjernet model brugte tidligere
gpt-4o, som stadig er tilgængelig indtil 14. januar 2027; det bruger nugpt-4-turbo, som blev udfaset den 23. oktober 2026 (angivet erstatning:gpt-5.6-sol). Kilde: Udfasede funktioner.
Håndtering af fejl og HTTP-koder
I produktion er fejl uundgåelige. Netværket dratter, en API-nøgle udløber, en kollega deployer en ugyldig parameter, eller selve API’et oplever et tre minutters nedbrud. Det er afgørende at forstå de HTTP-koder, som API’et returnerer, og håndtere dem korrekt for at bygge robuste applikationer. Hele udfordringen koges ned til ét spørgsmål, du skal stille for hver undtagelse: Forsvinder dette, hvis jeg prøver igen, eller ender jeg i en uendelig løkke med et problem, som kun et menneske kan løse?
HTTP-koder i OpenAI API
API’et returnerer standard HTTP-koder for at indikere resultatet af hver anmodning. Python SDK’et lader dig ikke håndtere disse koder manuelt; i stedet oversætter det hver enkelt til en typet undtagelse, som du kan fange separat. Dette giver dig mulighed for at skrive præcise except-blokke i stedet for en generisk except Exception, der ville sløre problemets art.
from openai import OpenAI
from openai import (
APIError,
AuthenticationError,
BadRequestError,
RateLimitError,
APIConnectionError,
InternalServerError,
PermissionDeniedError,
NotFoundError,
UnprocessableEntityError,
)
client = OpenAI()
401 — AuthenticationError
En 401 indikerer, at API-nøglen er ugyldig eller mangler. Du ser typisk dette ved første deployment, når miljøvariablen ikke er blevet propageret til containeren. Det er nytteløst at prøve igen: nøglen vil være lige så ugyldig om ti sekunder.
try:
# Ugyldig eller manglende API-nøgle
bad_client = OpenAI(api_key="sk-invalid")
bad_client.responses.create(
model="gpt-5.6-terra",
input="Test"
)
except AuthenticationError as e:
print(f"Kode: {e.status_code}") # 401
print(f"Besked: {e.message}")
# Handling: verificér API-nøglen, generér om nødvendigt
400 — BadRequestError
En 400 fortæller dig, at anmodningen er misdannet. Her angives en temperatur på 5,0, hvor den maksimalt accepterede værdi er 2,0. Fejlmeddelelsen nævner næsten altid den fejlbehæftede parameter, hvilket gør dette til den hurtigste fejl at rette – forudsat at du logger den korrekt i stedet for at synke den i stilhed.
try:
# Ugyldige parametre
client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperatur kræver indsats none
input="Test",
temperature=5.0 # Ugyldig værdi (maks 2,0)
)
except BadRequestError as e:
print(f"Kode: {e.status_code}") # 400
print(f"Besked: {e.message}")
# Handling: ret anmodningsparametrene
429 — RateLimitError
En 429 indikerer, at du sender for mange anmodninger, eller at du har overskredet din kvote. I modsætning til de to foregående er denne fejl midlertidig af natur: tælleren nulstilles. Dette er skoleeksemplet på et genforsøg, men et genforsøg der venter – og venter længere for hvert forsøg.
try:
# For mange anmodninger eller overskredet kvote
client.responses.create(
model="gpt-5.6-terra",
input="Test"
)
except RateLimitError as e:
print(f"Kode: {e.status_code}") # 429
print(f"Besked: {e.message}")
# Handling: vent og prøv igen med eksponentiel backoff
500/503 — InternalServerError
500- og 503-fejl kommer fra OpenAI, ikke fra dig. Din anmodning var gyldig; infrastrukturen kunne blot ikke behandle den. Prøv igen efter en forsinkelse: i langt de fleste tilfælde lykkes det andet eller tredje forsøg.
try:
client.responses.create(
model="gpt-5.6-terra",
input="Test"
)
except InternalServerError as e:
print(f"Kode: {e.status_code}") # 500 eller 503
print(f"Besked: {e.message}")
# Handling: prøv igen efter en forsinkelse; fejlen ligger hos OpenAI
Omfattende fejlhåndtering
Lad os samle disse adfærdsmønstre i én enkelt funktion. Logikken er triage: fatale fejl konverteres til RuntimeError og kastes øjeblikkeligt, midlertidige fejl udløser et ventetidspunkt, der fordobles for hver omgang, og hvis forsøgsbudgettet er opbrugt, mislykkes kaldet rent i stedet for at returnere en tom værdi, som kalderen måske fortolker forkert.
from openai import OpenAI, APIError, AuthenticationError, RateLimitError
from openai import BadRequestError, APIConnectionError, InternalServerError
import time
client = OpenAI()
def robust_api_call(prompt: str, model: str = "gpt-5.6-terra",
max_retries: int = 3) -> str:
"""API-kald med omfattende fejlhåndtering."""
for attempt in range(max_retries):
try:
response = client.responses.create(
model=model,
input=prompt
)
return response.output_text
except AuthenticationError:
# Prøv ikke igen — nøglen er ugyldig
raise RuntimeError("Ugyldig API-nøgle. Tjek OPENAI_API_KEY.")
except BadRequestError as e:
# Prøv ikke igen — anmodningen er misdannet
raise RuntimeError(f"Ugyldig anmodning: {e.message}")
except RateLimitError:
# Prøv igen med eksponentiel backoff
delay = 2 ** attempt
print(f"Ratelimit nået. Venter {delay}s...")
time.sleep(delay)
except InternalServerError:
# Prøv igen — server-side fejl
delay = 2 ** attempt
print(f"Serverfejl. Forsøg {attempt + 1}/{max_retries}...")
time.sleep(delay)
except APIConnectionError:
# Prøv igen — netværksproblem
delay = 2 ** attempt
print(f"Forbindelsesfejl. Forsøg {attempt + 1}/{max_retries}...")
time.sleep(delay)
raise RuntimeError(f"Mislykkedes efter {max_retries} forsøg")
# Brug
try:
result = robust_api_call("Hej!")
print(result)
except RuntimeError as e:
print(f"Fatal fejl: {e}")
Specifikke fejl i Responses API
To situationer fortjener separat behandling, fordi de optræder under en generisk kode, men kræver en meget specifik løsning.
Kontekst for lang
En prompt, der overskrider kontekstvinduet, returnerer en 400, ligesom en tastefejl i en parameter. For at skelne mellem de to skal du inspicere meddelelsen: tilstedeværelsen af context_length_exceeded peger dig i retning af at trunkere teksten eller skifte til en model med et større kontekstvindue, i stedet for at gennemgå dine parametre.
try:
response = client.responses.create(
model="gpt-5.6-terra",
input="x " * 300000 # Overskrider kontekstvindue
)
except BadRequestError as e:
if "context_length_exceeded" in str(e.message):
print("Prompten er for lang til denne model.")
print("Løsninger: trunkér teksten, eller skift til en model")
print("med et større kontekstvindue.")
Model ikke tilgængelig
Modelidentifikatorer er ikke evige. En deployment, der stadig refererer til en udfaset model, fejler med en 404, hvilket får hele applikationen til at crashe, selvom den virkede dagen før. Håndtér dette tilfælde eksplicit: det er en automatisk påmindelse om at opdatere din konfiguration.
try:
response = client.responses.create(
model="gpt-4-turbo", # udfaset fra API'et den 23. oktober 2026
input="Test"
)
except NotFoundError as e:
print(f"Model ikke fundet: {e.message}")
print("Brug gpt-5.6-sol, erstatningen angivet af OpenAI, eller en nyere model.")
Struktureret fejllogging
En fejl, der ikke logges, er en fejl, du vil opdage via en kundebillet. Logging i JSON i stedet for fri tekst ændrer alt, når du skal aggregere: du kan tælle 429’er per time, filtrere efter response_id eller spore drift i forbruget, hvilket er umuligt med manuelt skrevne loglinjer.
import logging
import json
from datetime import datetime
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("openai_client")
def call_with_log(prompt: str) -> str:
"""API-kald med struktureret logging."""
request_id = None
try:
response = client.responses.create(
model="gpt-5.6-terra",
input=prompt
)
logger.info(json.dumps({
"event": "api_success",
"model": response.model,
"tokens": response.usage.total_tokens,
"response_id": response.id,
"timestamp": datetime.now().isoformat()
}))
return response.output_text
except APIError as e:
logger.error(json.dumps({
"event": "api_error",
"status_code": e.status_code,
"message": e.message,
"timestamp": datetime.now().isoformat()
}))
raise
result = call_with_log("Hej!")
Oversigtstabel
Hold dette skema ved hånden: det opsummerer den beslutning, du skal træffe for hver kode.
| Kode | Undtagelse | Genforsøg? | Handling |
|---|---|---|---|
| 400 | BadRequestError | Nej | Ret anmodningen |
| 401 | AuthenticationError | Nej | Verificér API-nøgle |
| 403 | PermissionDeniedError | Nej | Verificér tilladelser |
| 404 | NotFoundError | Nej | Verificér model/endepunkt |
| 422 | UnprocessableEntityError | Nej | Ret formatet |
| 429 | RateLimitError | Ja | Eksponentiel backoff |
| 500 | InternalServerError | Ja | Vent og prøv igen |
| 503 | InternalServerError | Ja | Tjenesten midlertidigt utilgængelig |
Vigtige pointer
- Kategorisér fejl: genforsøgbare (429, 500, 503) vs fatale (400, 401, 403)
- Brug eksponentiel backoff til genforsøgbare fejl
- Prøv aldrig igen ved autentificeringsfejl eller ugyldige anmodninger
- Log hver fejl med kontekst (kode, besked, tidsstempel)
- SDK’et håndterer automatisk 2 genforsøg – konfigurér
max_retriesom nødvendigt