Hva er response_model for?

Question

Accepted Answer

Parameteren **`response_model`** erklærer formen på et endepunkts respons. FastAPI bruker den til å **validere, filtrere og serialisere** de returnerte dataene — og til å dokumentere responsen i API-dokumentene. Dens viktigste oppgave: sikre at du bare eksponerer de tiltenkte feltene (for eksempel aldri lekke et passord).

## Problemet: lekking av sensitive felt

```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 responsmodell

```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 returnerer og **filtrerer det ned** til bare feltene som er erklært i `UserOut` — så passordet (og andre ekstra felt) fjernes fra responsen, selv om du returnerte hele objektet.

## Hva response_model gjø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
```

## Moderne alternativ: returtype-annotatsjonen

```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
```

## Hvorfor det er viktig

`response_model` er viktig for både **sikkerhet** og ren API-design.

Den kritiskeste rollen er å forhindre utilsiktet datalekkasje — ved å erklære nøyaktig hvilke felt responsen skal inneholde, filtrerer FastAPI ut alt annet (som passordhasher, interne flagg eller tokens) selv om koden din returnerer et fullstendig databaseobjekt, noe som eliminerer en vanlig og alvorlig sårbarhet.

Utover det validerer den responsene dine mot et erklært skjema (og fanger bugs der du returnerer feil form), sikrer riktig serialisering, og dokumenterer responsen i de auto-genererte API-dokumentene.

Mønsteret med å bruke separate inngångs- og utgangsmodeller (der `response_model` kontrollerer hva som eksponeres) er en beste praksis for sikre, veldefinerte API-er, noe som gjør denne viktige kunnskapen for ethvert endepunkt som returnerer data.