AI-agenter · Lektion

Hantera API-svar och fel

Parsa JSON-svar, hantera felkoder och använd mönster för undantagshantering.

Lektion 3 av 413 steg

Hantera API-svar och fel är en gratis lektion i AI-agenter på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för AI-agenter, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i AI-agenter innehåller totalt 4 lektioner.

Response-objektet

Varje anrop med requests returnerar ett Response-objekt. Det innehåller allt som servern skickade tillbaka: statuskoden, headers och brödtexten. Inspektera alltid statuskoden innan ni bearbetar brödtexten – ett svar med status 500 innehåller fortfarande en brödtext, men den innehåller inte de data ni ville ha.

import requests

response = requests.get('https://api.example.com/data')

# Key attributes of the response
print(response.status_code)       # e.g. 200
print(response.headers)           # dict of response headers
print(response.headers.get('Content-Type'))  # 'application/json'
print(response.text)              # raw response body as string
print(response.content)           # raw bytes

Parsa JSON med response.json()

Anropa response.json() för att automatiskt parsa svarsbrödtexten som JSON till en Python-dict eller -lista. Detta motsvarar json.loads(response.text), men validerar även att Content-Type är lämplig.

Anropa endast .json() när ni vet att svaret faktiskt är JSON – kontrollera Content-Type-huvudet först.

import requests

response = requests.get(
    'https://api.example.com/users/42',
    headers={'Authorization': 'Bearer YOUR_KEY'}
)

# Parse JSON body
user = response.json()

# Access fields safely with .get()
name = user.get('name', 'Unknown')
email = user.get('email', '')
roles = user.get('roles', [])

print(f'User: {name} ({email})')
print(f'Roles: {roles}')

Kontrollera status_code före parsning

Anropa aldrig response.json() utan att först bekräfta att begäran lyckades. Felsvar (4xx/5xx) innehåller ofta JSON-information om felet – användbart vid felsökning – men det är inte de data ni behöver. Kontrollera alltid status_code först.

import requests

response = requests.post(
    'https://api.example.com/tasks',
    json={'title': 'Write report'},
    headers={'Authorization': 'Bearer YOUR_KEY'}
)

if response.status_code == 201:
    task = response.json()
    print('Task created, ID:', task['id'])
elif response.status_code == 400:
    error = response.json()
    print('Validation error:', error.get('message'))
elif response.status_code == 401:
    print('Auth failed — check your token')
else:
    print(f'Unexpected status {response.status_code}: {response.text[:200]}')

raise_for_status() – automatiskt felkastande

response.raise_for_status() kastar automatiskt ett HTTPError-undantag om statuskoden är 4xx eller 5xx. Detta är ett enkelt sätt att omvandla felaktiga HTTP-svar till Python-undantag, så att ni kan använda try/except i stället för långa if/elif-kedjor.

import requests
from requests.exceptions import HTTPError

try:
    response = requests.get(
        'https://api.example.com/users/9999',
        headers={'Authorization': 'Bearer YOUR_KEY'}
    )
    response.raise_for_status()  # raises if status >= 400
    user = response.json()
    print('Found user:', user['name'])

except HTTPError as e:
    print(f'HTTP error: {e.response.status_code}')
    print('Details:', e.response.text[:300])

Hantera JSONDecodeError

Ibland returnerar ett API ett svar som inte är JSON när ni förväntar er JSON – en HTML-sida med serverfel, en tom brödtext eller en binär fil. Om ni anropar response.json() på dessa svar kastas json.JSONDecodeError. Fånga alltid detta för att undvika att agenten kraschar obemärkt.

import requests
import json

response = requests.get(
    'https://api.example.com/report',
    headers={'Authorization': 'Bearer YOUR_KEY'}
)

try:
    data = response.json()
except json.JSONDecodeError as e:
    print(f'Response is not valid JSON: {e}')
    print('Content-Type:', response.headers.get('Content-Type'))
    print('First 200 chars:', response.text[:200])
    # Decide: is this an HTML error page? A CSV file?
    data = None

if data is None:
    print('Falling back to text processing')

ConnectionError – nätverksproblem

Ett ConnectionError inträffar när agenten inte kan nå servern alls – DNS-upplösningsfel, servern är offline eller en brandvägg blockerar begäran. Det är ett fel på nätverksnivå som inträffar innan någon HTTP-kommunikation ens sker.

Till skillnad från ett 5xx-svar är detta inte serverns svar – anslutningen upprättades aldrig.

import requests
from requests.exceptions import ConnectionError

try:
    response = requests.get('https://api.example.com/data')
    data = response.json()
except ConnectionError as e:
    print('Cannot reach server. Possible causes:')
    print('- DNS failure (bad hostname)')
    print('- Server is down')
    print('- No internet connection')
    print('- Firewall blocking the port')
    print(f'Error detail: {e}')
    # Consider: queue the request for retry when connectivity returns

Timeout – förhindra att agenter fastnar

Som standard väntar requests för evigt på ett svar. En långsam server eller en server som har hängt sig gör att agenten fryser på obestämd tid. Ange alltid en timeout: en tupel med (connect_timeout, read_timeout) i sekunder. Ett Timeout-undantag kastas om servern inte svarar i tid.

import requests
from requests.exceptions import Timeout

try:
    response = requests.get(
        'https://api.example.com/slow-endpoint',
        headers={'Authorization': 'Bearer YOUR_KEY'},
        timeout=(5, 30)  # 5s to connect, 30s to read
    )
    data = response.json()
except Timeout:
    print('Request timed out after 30 seconds')
    print('Options: retry, use cached result, or alert operator')

Omfattande undantagshantering

I produktionsagenter ska ni fånga alla requests-undantag i en konsekvent hierarki. requests.exceptions.RequestException är basklassen för alla requests-fel – om ni fångar den får ni ett skyddsnät mot oväntade nätverksproblem.

import requests
import json
from requests.exceptions import (
    ConnectionError, Timeout, HTTPError, RequestException
)

def safe_api_call(url, headers):
    try:
        r = requests.get(url, headers=headers, timeout=(5, 30))
        r.raise_for_status()
        return r.json()
    except Timeout:
        print('ERROR: Request timed out')
    except ConnectionError:
        print('ERROR: Cannot reach server')
    except HTTPError as e:
        print(f'ERROR: HTTP {e.response.status_code}')
        try:
            print('API error:', e.response.json().get('message'))
        except json.JSONDecodeError:
            print('Non-JSON error body')
    except RequestException as e:
        print(f'ERROR: Unexpected request error: {e}')
    return None

Logga svar för felsökning

När en agent inte beter sig som den ska behöver ni tillräckligt med sammanhang för att diagnostisera problemet. Logga begärans metod, URL, statuskod och relevanta svarsdetaljer – men logga aldrig API-nycklar. Använd Pythons inbyggda modul logging i stället för utskrifter med print i produktionsagenter.

import logging
import requests

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('agent.api')

def logged_request(method, url, **kwargs):
    logger.info(f'-> {method.upper()} {url}')
    response = requests.request(method, url, **kwargs)
    logger.info(
        f'<- {response.status_code} '
        f'({len(response.content)} bytes) '
        f'{response.elapsed.total_seconds():.2f}s'
    )
    if response.status_code >= 400:
        logger.error(f'Error body: {response.text[:500]}')
    return response

Hantera paginerade svar

Många API:er returnerar data i sidor. Agenten måste följa pagineringslänkar för att hämta alla resultat. Leta efter en next-URL i svaret eller ett page/cursor-fält och upprepa tills det inte finns fler sidor.

import requests

def get_all_items(base_url, headers):
    all_items = []
    url = f'{base_url}/items?page=1&limit=100'

    while url:
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        data = response.json()

        all_items.extend(data.get('items', []))

        # Follow 'next' link if present
        url = data.get('next_page_url')  # None stops the loop

        print(f'Fetched {len(all_items)} items so far...')

    print(f'Total: {len(all_items)} items')
    return all_items

Strömma stora svar

För stora svar (filer, långa AI-utdata) ska ni använda stream=True för att undvika att hela svaret läses in i minnet på en gång. Läs svaret i delar. Detta är avgörande när agenten bearbetar stora datamängder eller strömmar AI-genererad text.

import requests

response = requests.get(
    'https://api.example.com/large-report',
    headers={'Authorization': 'Bearer YOUR_KEY'},
    stream=True
)

response.raise_for_status()

# Write streamed content to file
with open('report.json', 'wb') as f:
    for chunk in response.iter_content(chunk_size=8192):
        if chunk:
            f.write(chunk)

print('Download complete')

# For streaming JSON lines (NDJSON):
for line in response.iter_lines():
    if line:
        import json
        record = json.loads(line)
        print(record)

Snabbtest: raise_for_status

Testa er förståelse av svarshantering vid fel.

Besvara frågan i den interaktiva lektionen

Sammanfattning av svarshantering

Robust svarshantering är det som skiljer en skör agent från en tillförlitlig:

Kontrollera alltid status_code innan ni parsar brödtexten
Använd response.json() för parsning och fånga JSONDecodeError om brödtexten kanske inte är JSON
Använd raise_for_status() för att omvandla HTTP-fel till undantag
Fånga ConnectionError vid nätverksfel och Timeout vid långsamma servrar
Ange alltid en timeout=(connect, read)-tupel för varje begäran
Logga begäranden och svar (utan nycklar) för att underlätta felsökning

Gratis att börja

Lär dig AI-agenter med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 60
Lektioner: 239

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Hantera API-svar och fel” gratis?

Ja – hela texten till ”Hantera API-svar och fel” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i AI-agenter, kan Ni uppgradera till CoddyKit PRO. Kursen i AI-agenter innehåller totalt 4 lektioner.

Vad lär jag mig i ”Hantera API-svar och fel”?

Parsa JSON-svar, hantera felkoder och använd mönster för undantagshantering. Ni övar på AI-agenter med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig AI-agenter?

Du behöver inga förkunskaper. Utbildningen i AI-agenter på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Hantera API-svar och fel”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här AI-agenter-lektionen?

Ja. Varje AI-agenter-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till AI-agenter