À quoi sert le `response_model` ?

Question

Accepted Answer

Le paramètre **`response_model`** déclare la forme de la réponse d'un endpoint. FastAPI l'utilise pour **valider, filtrer et sérialiser** les données retournées — et pour documenter la réponse dans la documentation de l'API. Son travail le plus important : s'assurer que vous n'exposez que les champs prévus (par ex. ne jamais divulguer un mot de passe).

## Le problème : divulguer des champs sensibles

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

## La solution : un modèle de réponse séparé

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

Avec `response_model=UserOut`, FastAPI prend ce que vous retournez et **le filtre** pour ne garder que les champs déclarés dans `UserOut` — donc le mot de passe (et tout autre champ supplémentaire) est retiré de la réponse, même si vous avez retourné l'objet complet.

## Ce que fait response_model

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

## Alternative moderne : l'annotation du type de retour

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

## Pourquoi c'est important

`response_model` est important pour la **sécurité** et une bonne conception d'API.

Son rôle le plus critique est de prévenir les fuites de données accidentelles — en déclarant exactement quels champs la réponse doit contenir, FastAPI filtre tout le reste (comme les hachages de mots de passe, les drapeaux internes ou les tokens) même si votre code retourne un objet de base de données complet, éliminant une vulnérabilité courante et sérieuse.

Au-delà de cela, il valide vos réponses par rapport à un schéma déclaré (détectant les bogues où vous retournez la mauvaise forme), assure une sérialisation correcte, et documente la réponse dans la documentation API générée automatiquement.

Le motif d'utilisation de modèles d'entrée et de sortie séparés (avec `response_model` contrôlant ce qui est exposé) est une bonne pratique pour des API sûres et bien définies, ce qui rend ces connaissances importantes pour tout endpoint qui retourne des données.