Hantering av fel och HTTP-koder
På denna sida
Uppdaterat 3 november 2026 baserat på OpenAIs dokumentation:
temperatureochtop_paccepteras endast med ett resonemangsarbete (reasoning effort) pånone, medan GPT-5.6-modeller resonerar som standard (medium). Anrop som ställer in dessa parametrar måste därför specificerareasoning={"effort": "none"}(Responses API) ellerreasoning_effort="none"(Chat Completions). Källor: Använda GPT-6 · GPT-5.6 Terra.
Förtydligat 3 november 2026 baserat på OpenAIs sida för Avvecklade funktioner (Deprecations): exemplet på den borttagna modellen använde tidigare
gpt-4o, som fortfarande är tillgänglig till den 14 januari 2027; det använder nugpt-4-turbo, som lades ner den 23 oktober 2026 (angiven ersättare:gpt-5.6-sol). Källa: Avvecklade funktioner.
Hantering av fel och HTTP-koder
I produktion är fel oundvikliga. Nätverket kan falla ut, en API-nyckel löper ut, en kollega distribuerar en ogiltig parameter eller så drabbas API:t självt av ett tre minuter långt avbrott. Att förstå de HTTP-koder som API:t returnerar och hantera dem korrekt är avgörande för att bygga robusta applikationer. Hela utmaningen kokar ner till en fråga du måste ställa för varje undantag: kommer detta att försvinna om jag försöker igen, eller kommer jag att hamna i en oändlig loop över ett problem som bara en människa kan lösa?
HTTP-koder för OpenAI API
API:t returnerar standardiserade HTTP-koder för att indikera resultatet av varje begäran. Python SDK:t låter dig inte hantera dessa koder manuellt; istället översätter det var och en till ett typat undantag som du kan fånga separat. Detta gör att du kan skriva precisa except-block istället för ett generellt except Exception som skulle dölja problemets natur.
from openai import OpenAI
from openai import (
APIError,
AuthenticationError,
BadRequestError,
RateLimitError,
APIConnectionError,
InternalServerError,
PermissionDeniedError,
NotFoundError,
UnprocessableEntityError,
)
client = OpenAI()
401 — AuthenticationError
En 401-kod indikerar att API-nyckeln är ogiltig eller saknas. Du ser detta vanligtvis vid den första distributionen när miljövariabeln inte har propagerats till containern. Att försöka igen är meningslöst: nyckeln kommer att vara lika ogiltig om tio sekunder.
try:
# Ogiltig eller saknad API-nyckel
bad_client = OpenAI(api_key="sk-invalid")
bad_client.responses.create(
model="gpt-5.6-terra",
input="Test"
)
except AuthenticationError as e:
print(f"Kod: {e.status_code}") # 401
print(f"Meddelande: {e.message}")
# Åtgärd: verifiera API-nyckeln, återskapa vid behov
400 — BadRequestError
En 400-kod berättar att begäran är felformulerad. Här anges ett temperaturvärde på 5,0 när det maximalt accepterade värdet är 2,0. Felmeddelandet nämner nästan alltid den felaktiga parametern, vilket gör detta till det snabbaste felet att åtgärda – förutsatt att du loggar det korrekt istället för att svälja det tyst.
try:
# Ogiltiga parametrar
client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature kräver effort none
input="Test",
temperature=5.0 # Ogiltigt värde (max 2.0)
)
except BadRequestError as e:
print(f"Kod: {e.status_code}") # 400
print(f"Meddelande: {e.message}")
# Åtgärd: korrigera begärans parametrar
429 — RateLimitError
En 429-kod indikerar att du skickar för många begäranden eller har överskridit din kvot. Till skillnad från de två tidigare fallen är detta fel tillfälligt till sin natur: räknaren nollställs. Detta är skolboksexemplet på ett försök som bör göras om, men ett försök som väntar – och väntar längre för varje försök.
try:
# För många begäranden eller överskriden kvot
client.responses.create(
model="gpt-5.6-terra",
input="Test"
)
except RateLimitError as e:
print(f"Kod: {e.status_code}") # 429
print(f"Meddelande: {e.message}")
# Åtgärd: vänta och försök igen med exponentiell backoff
500/503 — InternalServerError
Felkoderna 500 och 503 kommer från OpenAI, inte från dig. Din begäran var giltig; infrastrukturen kunde helt enkelt inte bearbeta den. Försök igen efter en fördröjning: i de allra flesta fall lyckas det andra eller tredje försöket.
try:
client.responses.create(
model="gpt-5.6-terra",
input="Test"
)
except InternalServerError as e:
print(f"Kod: {e.status_code}") # 500 eller 503
print(f"Meddelande: {e.message}")
# Åtgärd: försök igen efter en fördröjning; felet ligger hos OpenAI
Omfattande felhanterare
Låt oss samla dessa beteenden i en enda funktion. Logiken är triage: ödesdigra fel omvandlas till RuntimeError och kastas omedelbart, övergående fel utlöser en väntan som fördubblas för varje varv, och om försöksbudgeten är uttömd misslyckas anropet rent istället för att returnera ett tomt värde som anroparen kan missförstå.
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-anrop med omfattande felhantering."""
for attempt in range(max_retries):
try:
response = client.responses.create(
model=model,
input=prompt
)
return response.output_text
except AuthenticationError:
# Försök inte igen — nyckeln är ogiltig
raise RuntimeError("Ogiltig API-nyckel. Kontrollera OPENAI_API_KEY.")
except BadRequestError as e:
# Försök inte igen — begäran är felformulerad
raise RuntimeError(f"Ogiltig begäran: {e.message}")
except RateLimitError:
# Försök igen med exponentiell backoff
delay = 2 ** attempt
print(f"Hastighetsbegränsning nådd. Väntar {delay}s...")
time.sleep(delay)
except InternalServerError:
# Försök igen — fel på serversidan
delay = 2 ** attempt
print(f"Serverfel. Försök {attempt + 1}/{max_retries}...")
time.sleep(delay)
except APIConnectionError:
# Försök igen — nätverksproblem
delay = 2 ** attempt
print(f"Anslutningsfel. Försök {attempt + 1}/{max_retries}...")
time.sleep(delay)
raise RuntimeError(f"Misslyckades efter {max_retries} försök")
# Användning
try:
result = robust_api_call("Hej!")
print(result)
except RuntimeError as e:
print(f"Ödesdigert fel: {e}")
Specifika fel för Responses API
Två situationer förtjänar separat behandling eftersom de dyker upp under en generisk kod men kräver en mycket specifik åtgärd.
Kontexten för lång
En prompt som överskrider kontextfönstret returnerar en 400-kod, precis som ett stavfel i en parameter. För att skilja mellan de två måste du inspektera meddelandet: förekomsten av context_length_exceeded pekar dig mot att trunkera texten eller byta till en modell med ett större kontextfönster, snarare än att granska dina parametrar.
try:
response = client.responses.create(
model="gpt-5.6-terra",
input="x " * 300000 # Överskrider kontextfönstret
)
except BadRequestError as e:
if "context_length_exceeded" in str(e.message):
print("Prompten är för lång för denna modell.")
print("Lösningar: trunkera texten eller byt till en modell")
print("med ett större kontextfönster.")
Modellen inte tillgänglig
Modellidentifierare är inte eviga. En distribution som fortfarande refererar till en avvecklad modell misslyckas med en 404-kod, vilket får hela applikationen att krascha även om den fungerade dagen innan. Hantera detta fall explicit: det är en automatisk påminnelse om att uppdatera din konfiguration.
try:
response = client.responses.create(
model="gpt-4-turbo", # avvecklad från API:t den 23 oktober 2026
input="Test"
)
except NotFoundError as e:
print(f"Modellen hittades inte: {e.message}")
print("Använd gpt-5.6-sol, ersättaren som anges av OpenAI, eller en nyare modell.")
Strukturerad felloggning
Ett fel som inte loggas är ett fel du kommer att upptäcka via ett kundärende. Att logga i JSON istället för fri text ändrar allt när du behöver aggregera data: du kan räkna 429-fel per timme, filtrera efter response_id eller spåra förändringar i konsumtion, vilket är omöjligt med manuellt skrivna loggrader.
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-anrop med strukturerad loggning."""
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!")
Sammanfattningstabell
Ha detta rutnät till hands: det sammanfattar beslutet som ska fattas för varje kod.
| Kod | Undantag | Försök igen? | Åtgärd |
|---|---|---|---|
| 400 | BadRequestError | Nej | Korrigera begäran |
| 401 | AuthenticationError | Nej | Verifiera API-nyckel |
| 403 | PermissionDeniedError | Nej | Verifiera behörigheter |
| 404 | NotFoundError | Nej | Verifiera modell/slutpunkt |
| 422 | UnprocessableEntityError | Nej | Korrigera formatet |
| 429 | RateLimitError | Ja | Exponentiell backoff |
| 500 | InternalServerError | Ja | Vänta och försök igen |
| 503 | InternalServerError | Ja | Tjänsten tillfälligt otillgänglig |
Viktiga punkter
- Kategorisera fel: återförsökbara (429, 500, 503) kontra ödesdigra (400, 401, 403)
- Använd exponentiell backoff för återförsökbara fel
- Försök aldrig igen vid autentiseringsfel eller ogiltiga begäranden
- Logga varje fel med kontext (kod, meddelande, tidsstämpel)
- SDK:t hanterar automatiskt 2 återförsök – konfigurera
max_retriesvid behov