Vad är response_model till för?

Question

Accepted Answer

Parametern **`response_model`** deklarerar formen på en endpoints svar. FastAPI använder den för att **validera, filtrera och serialisera** den returnerade datan — och för att dokumentera svaret i API-dokumentationen. Dess viktigaste uppgift: att säkerställa att du endast exponerar avsedda fält (t.ex. aldrig läcker ett lösenord).

## Problemet: läck av känsliga fält

```python
class User(BaseModel):
    name: str
    email: str
    password: str        # ⚠️ should NEVER be in the response!

@app.get("/users/{id}")
def get_user(id: int) -> User:
    return db.get_user(id)   # returning the full object would expose the password
```

## Lösningen: en separat svarsmodell

```python
class UserOut(BaseModel):    # the SAFE public shape — no password
    name: str
    email: str

@app.get("/users/{id}", response_model=UserOut)
def get_user(id: int):
    return db.get_user(id)   # returns a full user, but FastAPI FILTERS it to UserOut
# response → { "name": "...", "email": "..." }  — password stripped automatically
```

Med `response_model=UserOut` tar FastAPI det du returnerar och **filtrerar det ner** till bara de fält som deklareras i `UserOut` — så lösenordet (och alla andra extra fält) tas bort från svaret, även om du returnerade det fullständiga objektet.

## Vad response_model gör

```text
✓ FILTERS the output to only the declared fields (key for hiding sensitive data)
✓ VALIDATES that your response matches the declared schema (catches mistakes)
✓ SERIALIZES the data to JSON correctly
✓ DOCUMENTS the response shape in the OpenAPI/Swagger docs
```

## Modern alternativ: return type annotation

```python
@app.get("/users/{id}")
def get_user(id: int) -> UserOut:    # the -> return type works like response_model
    return db.get_user(id)
# response_model_exclude_unset=True → omit fields not explicitly set
```

## Varför det är viktigt

`response_model` är viktigt för både **säkerhet** och ren API-design.

Dess viktigaste roll är att förhindra oavsiktlig datainformation — genom att deklarera exakt vilka fält svaret bör innehålla, filtrerar FastAPI bort allt annat (som lösenordshashar, interna flaggor eller tokens) även om din kod returnerar ett fullt databasobjekt, vilket eliminerar en vanlig och allvarlig sårbarhet.

Utöver det validerar det dina svar mot ett deklarerat schema (hittar buggar där du returnerar fel form), säkerställer korrekt serialisering och dokumenterar svaret i den autogenererade API-dokumentationen.

Mönstret att använda separata indata- och utdatamodeller (med `response_model` som kontrollerar vad som exponeras) är en bästa praxis för säkra, väl definierade API:er, vilket gör denna kunskap viktig för alla endpoints som returnerar data.