Wofür ist response_model da?

Question

Accepted Answer

Der Parameter **`response_model`** deklariert die Form der Antwort eines Endpunkts. FastAPI verwendet ihn, um die zurückgegebenen Daten zu **validieren, filtern und serialisieren** — und um die Antwort in der API-Dokumentation zu dokumentieren. Seine wichtigste Aufgabe: sicherstellen, dass Sie nur die beabsichtigten Felder offenlegen (z. B. niemals ein Passwort preisgeben).

## Das Problem: Offenlegung sensibler Felder

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

## Die Lösung: ein separates Response Model

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

Mit `response_model=UserOut` nimmt FastAPI alles, was Sie zurückgeben, und **filtert es** auf nur die in `UserOut` deklarierten Felder — das Passwort (und alle anderen zusätzlichen Felder) wird aus der Antwort entfernt, obwohl Sie das vollständige Objekt zurückgegeben haben.

## Was response_model macht

```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 Alternative: die 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
```

## Warum es wichtig ist

`response_model` ist wichtig für sowohl **Sicherheit** als auch für sauberes API-Design.

Seine kritischste Rolle ist die Verhinderung versehentlicher Datenlecks — durch die Deklaration genau der Felder, die die Antwort enthalten soll, filtert FastAPI alles andere heraus (wie Password Hashes, interne Flags oder Tokens), selbst wenn Ihr Code ein vollständiges Datenbankobjekt zurückgibt, und beseitigt damit eine häufige und ernsthafte Sicherheitslücke.

Darüber hinaus validiert es Ihre Antworten gegen ein deklariertes Schema (fängt Fehler ab, bei denen Sie die falsche Form zurückgeben), gewährleistet die korrekte Serialisierung und dokumentiert die Antwort in der automatisch generierten API-Dokumentation.

Das Muster, separate Eingangs- und Ausgangsmodelle zu verwenden (wobei `response_model` kontrolliert, was offengelegt wird), ist eine Best Practice für sichere, klar definierte APIs und macht dies zu wichtigem Wissen für jeden Endpunkt, der Daten zurückgibt.