¿Qué son los modelos Pydantic en FastAPI?

Question

Accepted Answer

**Los modelos Pydantic** son clases (que heredan de `BaseModel`) que definen la **estructura, tipos y reglas de validación** para los datos. FastAPI los usa en todas partes — para cuerpos de solicitud, formas de respuesta y configuraciones — convirtiéndolos en el corazón de su diseño impulsado por tipos.

## Definiendo un modelo

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

Cada campo declara un tipo y restricciones/valores predeterminados opcionales. Pydantic valida los datos contra esta definición y convierte tipos donde es sensato.

## Validación y análisis automáticos

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

Cuando se usa como un tipo de parámetro, FastAPI analiza el cuerpo de la solicitud JSON en el modelo, **validando** cada campo y devolviendo un error 422 estructurado que lista exactamente qué está mal — todo automático.

## Lo que Pydantic te da

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

## Una única fuente de verdad

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

## Por qué es importante

Los modelos Pydantic son la piedra angular de FastAPI — son cómo defines y validas los datos que tu API acepta y devuelve, y casi todas las características de FastAPI fluyen a través de ellos.

Entenderlos es esencial porque proporcionan **validación** automática (crítica para la seguridad y solidez — nunca confiar en entrada cruda), análisis/coerción, serialización y soporte de editor, todo desde una única clase declarativa.

Sirven como una **única fuente de verdad**: un modelo impulsa la validación de solicitud, la forma de respuesta y la documentación autogenerada.

Este enfoque impulsado por tipos y validar-por-defecto — obtener validación robusta de entrada y mensajes de error claros esencialmente gratis — es una razón importante por la que FastAPI es tan productivo y seguro, lo que hace que los modelos Pydantic sean conocimiento fundamental y de dominio obligatorio.