Comment recevez-vous un corps de requête JSON ?

Question

Accepted Answer

Pour recevoir un corps de requête JSON dans FastAPI, vous déclarez un paramètre de fonction typé comme **modèle Pydantic**. FastAPI lit le corps, analyse le JSON, le valide contre le modèle, et vous transmet un objet typé — automatiquement.

## Le pattern

```python
from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    description: str | None = None      # optional field

@app.post("/items")
def create_item(item: Item):             # `item: Item` → read & validate the JSON body
    # `item` is a fully-validated Item object here
    return {"name": item.name, "total": item.price * 1.1}
```

```json
// request body the client sends:
{ "name": "Phone", "price": 999.0 }
```

Déclarer `item: Item` indique à FastAPI de lire le corps de la requête comme JSON, de l'analyser en un `Item`, et de le **valider** — votre fonction reçoit un objet typé et valide. Les mauvaises entrées sont rejetées automatiquement :

```json
// POST { "name": "Phone" }  (missing price) → automatic 422:
{ "detail": [{ "loc": ["body", "price"], "msg": "field required" }] }
```

## Body + path + query ensemble

```python
@app.put("/items/{item_id}")
def update(item_id: int, item: Item, notify: bool = False):
    # item_id = path param, item = JSON body (Pydantic model), notify = query param
    # FastAPI distinguishes them by type/location automatically
```

FastAPI achemine intelligemment les paramètres : un placeholder de path → paramètre de path, un modèle Pydantic → corps de la requête, un paramètre simplement typé → paramètre de query.

## Plusieurs paramètres body / mises à jour partielles

```python
@app.patch("/items/{id}")
def patch(id: int, item: ItemUpdate):       # use a model with all-optional fields for PATCH
    update_data = item.model_dump(exclude_unset=True)   # only fields the client sent
```

## Pourquoi c'est important

Recevoir et valider les corps de requête est essentiel — presque chaque API qui crée ou met à jour des données en a besoin, et FastAPI le rend remarquablement propre : déclarer un paramètre modèle Pydantic vous donne l'analyse JSON automatique, la **validation** complète (avec des erreurs 422 claires au niveau des champs), et un objet typé, éliminant l'analyse manuelle fastidieuse et sujette aux erreurs et la validation que d'autres frameworks exigent.

La validation est aussi un avantage clé en matière de **sécurité/robustesse** — les entrées mal formées sont rejetées avant d'atteindre votre logique.

Comprendre comment définir un modèle body, comment FastAPI distingue automatiquement body des paramètres path/query, et les patterns comme `exclude_unset` pour les mises à jour partielles est une connaissance fondamentale du quotidien pour construire tout endpoint d'écriture.