What are Pydantic models in FastAPI?

Question

Accepted Answer

**Pydantic models** are classes (subclassing `BaseModel`) that define the **structure, types, and validation rules** for data. FastAPI uses them everywhere — for request bodies, response shapes, and settings — making them the heart of its type-driven design.

## Defining a model

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

Each field declares a type and optional constraints/defaults. Pydantic validates data against this definition and converts types where sensible.

## Automatic validation and 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
```

When used as a parameter type, FastAPI parses the JSON request body into the model, **validating** every field and returning a structured 422 error listing exactly what's wrong — all automatic.

## What Pydantic gives you

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

## A single source of truth

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

## Why it matters

Pydantic models are the cornerstone of FastAPI — they're how you define and validate the data your API accepts and returns, and nearly every FastAPI feature flows through them.

Understanding them is essential because they provide automatic **validation** (critical for security and robustness — never trusting raw input), parsing/coercion, serialization, and editor support, all from a single declarative class.

They serve as a **single source of truth**: one model drives request validation, the response shape, and the auto-generated documentation.

This type-driven, validate-by-default approach — getting robust input validation and clear error messages essentially for free — is a major reason FastAPI is so productive and safe, making Pydantic models fundamental, must-master knowledge.