Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Hantering av fel och HTTP-koder

Lektion 12 av 22 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Hantering av fel och HTTP-koder
  2. HTTP-koder för OpenAI API
  3. Omfattande felhanterare
  4. Specifika fel för Responses API
  5. Strukturerad felloggning
  6. Sammanfattningstabell
  7. Viktiga punkter

Uppdaterat 3 november 2026 baserat på OpenAIs dokumentation: temperature och top_p accepteras 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 specificera reasoning={"effort": "none"} (Responses API) eller reasoning_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 nu gpt-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.

KodUndantagFörsök igen?Åtgärd
400BadRequestErrorNejKorrigera begäran
401AuthenticationErrorNejVerifiera API-nyckel
403PermissionDeniedErrorNejVerifiera behörigheter
404NotFoundErrorNejVerifiera modell/slutpunkt
422UnprocessableEntityErrorNejKorrigera formatet
429RateLimitErrorJaExponentiell backoff
500InternalServerErrorJaVänta och försök igen
503InternalServerErrorJaTjä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_retries vid behov