Wat zijn Pydantic-modellen in FastAPI?

Question

Accepted Answer

**Pydantic-modellen** zijn klassen (subklassen van `BaseModel`) die de **structuur, typen en validatieregels** voor gegevens definiëren. FastAPI gebruikt ze overal — voor request bodies, response shapes en instellingen — waardoor ze het hart van het type-driven design zijn.

## Een model definiëren

```python
from pydantic import BaseModel, EmailStr, Field

class User(BaseModel):
    name: str
    email: EmailStr                          # validates email format
    age: int = Field(ge=0, le=120)            # constraint: 0 <= age <= 120
    is_active: bool = True                    # default value
    tags: list[str] = []                      # typed list with a default
```

Elk veld declareert een type en optionele beperkingen/defaults. Pydantic valideert gegevens tegen deze definitie en converteert typen waar logisch.

## Automatische validatie en parsing

```python
@app.post("/users")
def create_user(user: User):                  # FastAPI builds & validates a User from the body
    return user                               # already validated here
# valid JSON → a typed User object; invalid → automatic 422 with field-level errors
```

Wanneer gebruikt als parametertype, parseert FastAPI de JSON request body in het model, **valideert** elk veld en retourneert een gestructureerde 422-fout met exact wat fout is — allemaal automatisch.

## Wat Pydantic je geeft

```text
✓ Validation — type checks + constraints (lengths, ranges, formats), clear errors
✓ Parsing/coercion — "5" → 5, ISO string → datetime, etc.
✓ Serialization — model.model_dump() / model_dump_json() → dict/JSON
✓ Editor support — full autocomplete & type checking on model attributes
✓ Self-documenting — the model defines the schema used in the auto-generated docs
```

## Een enkele bron van waarheid

```text
One Pydantic model drives: request validation, the response schema, the OpenAPI docs,
and typed access in your code → define the data shape ONCE.
```

## Waarom het belangrijk is

Pydantic-modellen zijn de hoeksteen van FastAPI — ze definiëren en valideren de gegevens die je API accepteert en retourneert, en bijna elke FastAPI-functie stroomt erdoorheen.

Het is essentieel om ze te begrijpen omdat ze automatische **validatie** bieden (kritiek voor veiligheid en robuustheid — nooit ruw invoer vertrouwen), parsing/coercion, serialisatie en editor-ondersteuning, alles vanuit een enkele declaratieve klasse.

Ze fungeren als **een enkele bron van waarheid**: één model drijft request-validatie, response shape en de automatisch gegenereerde documentatie aan.

Deze type-driven, validate-by-default benadering — robuuste inputvalidatie en duidelijke foutmeldingen praktisch gratis krijgen — is een grote reden waarom FastAPI zo productief en veilig is, waardoor Pydantic-modellen fundamentele, must-master kennis zijn.