Nested models in FastAPI - Deep Dive

Overview - Nested models

What is it?

Nested models in FastAPI are a way to organize data by embedding one data model inside another. This helps represent complex data structures clearly and cleanly. Instead of putting all data fields in one big model, you group related fields into smaller models and nest them. This makes your code easier to read and maintain.

Why it matters

Without nested models, your data structures become large and confusing, making it hard to understand or change them. Nested models solve this by breaking data into logical parts, just like organizing files in folders. This improves code clarity, reduces errors, and helps FastAPI automatically validate and document your API inputs and outputs correctly.

Where it fits

Before learning nested models, you should understand basic FastAPI models using Pydantic and how to define simple data schemas. After mastering nested models, you can explore advanced validation, custom data types, and complex API design patterns in FastAPI.

Mental Model

Core Idea

Nested models let you build complex data structures by putting smaller models inside bigger ones, like building blocks.

Think of it like...

Think of nested models like a filing cabinet with folders inside it. Each folder holds related papers, and the cabinet organizes all folders neatly. This way, you find and manage information easily without mixing everything together.

┌───────────────┐
│  Main Model   │
│ ┌───────────┐ │
│ │ Sub Model │ │
│ │  Fields   │ │
│ └───────────┘ │
└───────────────┘

Build-Up - 6 Steps

1

Foundation

Understanding basic FastAPI models

Concept: Learn how to create simple data models using Pydantic in FastAPI.

In FastAPI, you define data models by creating classes that inherit from Pydantic's BaseModel. Each class attribute represents a data field with a type. For example, a User model might have 'name' as a string and 'age' as an integer. FastAPI uses these models to validate incoming data and generate API docs automatically.

Result

You can create and use simple models that validate data and describe API inputs and outputs.

Understanding how to define basic models is essential because nested models build directly on this concept.

2

Foundation

Creating multiple independent models

Concept: Learn to define several separate models to represent different data parts.

You can create multiple Pydantic models for different data groups. For example, an Address model with 'street' and 'city', and a User model with 'name' and 'age'. These models are independent and can be used separately in your API endpoints.

Result

You have clear, reusable models representing distinct data parts.

Separating data into multiple models prepares you to combine them logically using nesting.

3

Intermediate

Embedding one model inside another

🤔Before reading on: do you think you can use a model as a field type inside another model? Commit to yes or no.

Concept: Learn how to nest one Pydantic model inside another by using it as a field type.

In FastAPI, you can use a Pydantic model as a type for a field inside another model. For example, in a User model, you can have an 'address' field whose type is the Address model. This creates a nested structure where the User model contains the Address model data.

Result

Your models can represent complex data with nested parts, and FastAPI validates all nested fields automatically.

Knowing that models can be fields inside other models unlocks the ability to represent real-world data structures naturally.

4

Intermediate

Handling lists of nested models

🤔Before reading on: can you guess how to represent a list of nested models inside another model? Commit to your answer.

Concept: Learn to nest lists of models inside another model to represent multiple related items.

You can define a field as a list of models by using Python's List type with a model inside. For example, a User model can have a 'friends' field which is a list of User models or another model type. FastAPI validates each item in the list according to the nested model.

Result

Your API can accept and return complex lists of nested data, like multiple addresses or friends.

Understanding lists of nested models allows you to model one-to-many relationships in your data.

5

Advanced

Using nested models in request and response

🤔Before reading on: do you think nested models work the same way for both input (request) and output (response)? Commit to yes or no.

Concept: Learn how nested models are used in FastAPI endpoints for both receiving data and sending responses.

When you use nested models as request bodies, FastAPI validates all nested fields automatically. Similarly, when returning nested models as responses, FastAPI generates correct JSON with nested structure and documents it in the API docs. This consistency helps keep your API clear and reliable.

Result

Your API endpoints handle complex nested data smoothly in both directions.

Knowing that nested models work seamlessly for input and output helps you design consistent APIs.

6

Expert

Customizing nested model behavior and validation

🤔Before reading on: can you customize validation inside nested models independently? Commit to yes or no.

Concept: Learn how to add custom validation and control serialization inside nested models for advanced use cases.

Each nested model can have its own validators and custom methods. You can use Pydantic's @validator decorators inside nested models to enforce rules on nested fields. Also, you can control how nested models serialize to JSON by overriding methods or using Pydantic's config options. This allows fine-tuning validation and output formatting.

Result

You can build robust APIs with precise control over nested data validation and serialization.

Understanding that nested models are independent units lets you customize complex data handling without affecting the whole structure.

Under the Hood

FastAPI uses Pydantic models to parse and validate data. When a nested model is used, Pydantic recursively processes each nested model instance. It checks types, runs validators, and converts data to Python objects. This recursive validation ensures every nested field meets its rules before your code runs. FastAPI then uses these validated objects to handle requests or generate responses.

Why designed this way?

This design leverages Pydantic's powerful validation and serialization features to keep FastAPI simple and efficient. Nesting models allows modular, reusable code and clear API schemas. Alternatives like flat models would be harder to maintain and less expressive. Recursive validation ensures data integrity at every level, reducing bugs and improving developer experience.

┌─────────────┐
│  Request    │
└─────┬───────┘
      │ JSON data
      ▼
┌─────────────┐
│ Pydantic    │
│ Validator   │
│ (recursive) │
└─────┬───────┘
      │ Validated Python objects
      ▼
┌─────────────┐
│ FastAPI     │
│ Endpoint    │
└─────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think nested models automatically merge all fields into one flat structure? Commit to yes or no.

Common Belief: Nested models flatten all fields into the parent model's fields during validation.

Reality: Nested models keep their structure separate and validate each nested model independently, preserving hierarchy.

Why it matters: Assuming flattening happens can lead to incorrect data handling and confusion about where fields belong, causing bugs.

Quick: Do you think you must manually validate nested models inside the parent model? Commit to yes or no.

Common Belief: You need to write extra code to validate nested models inside a parent model.

Reality: Pydantic automatically validates nested models recursively without extra code.

Why it matters: Not knowing this leads to redundant code and missed opportunities to rely on FastAPI's built-in validation.

Quick: Do you think nested models slow down FastAPI significantly? Commit to yes or no.

Common Belief: Using nested models causes major performance issues in FastAPI.

Reality: While nested validation adds some overhead, Pydantic and FastAPI are optimized to handle nested models efficiently for typical API use.

Why it matters: Fearing performance problems might prevent developers from using nested models, leading to messy, unmaintainable code.

Quick: Do you think nested models always serialize all fields in responses? Commit to yes or no.

Common Belief: Nested models always include every field when converted to JSON in responses.

Reality: You can customize which fields appear using Pydantic's config or response_model_exclude options.

Why it matters: Assuming all fields are always included can cause accidental data leaks or bloated responses.

Expert Zone

1

Nested models can have different validation contexts, allowing you to reuse the same model with different rules depending on usage.

2

Using Optional fields inside nested models requires careful handling to avoid unexpected None values breaking validation.

3

Pydantic's smart caching of model schemas improves performance when using deeply nested models repeatedly.

When NOT to use

Avoid nested models when your data is very flat or when performance is critical and you can validate manually with simpler structures. For extremely dynamic or loosely structured data, consider using plain dictionaries or custom validation logic instead.

Production Patterns

In production, nested models are used to represent complex entities like users with addresses, orders with items, or configurations with nested settings. They enable clear API contracts, automatic docs generation, and consistent validation across microservices.

Connections

Object-oriented programming (OOP)

Nested models are similar to objects containing other objects as attributes.

Understanding nested models is easier if you know how classes can hold instances of other classes, reflecting real-world relationships.

JSON data format

Nested models map directly to nested JSON objects used in APIs.

Knowing JSON structure helps you visualize how nested models translate to actual data sent over the network.

Database normalization

Nested models resemble normalized database tables linked by relationships.

Recognizing this connection helps in designing APIs that align well with database schemas and avoid data duplication.

Common Pitfalls

#1 Forgetting to import nested model classes before using them inside another model.

Wrong approach:

class User(BaseModel):
address: Address # Address not imported or defined yet

Correct approach:

from models import Address

class User(BaseModel):
address: Address

Root cause:

Python needs to know the nested model class before it can be used as a type hint.

#2 Using mutable default arguments for nested models causing shared state.

Wrong approach:

class User(BaseModel):
address: Address = Address() # mutable default instance

Correct approach:

class User(BaseModel):
address: Address # no default or use None with Optional

Root cause:

Mutable defaults are shared across instances, leading to unexpected data sharing.

#3 Passing incomplete nested data without required fields causing validation errors.

Wrong approach:

POST /users with body {"name": "Alice", "address": {"city": ""}} # missing street

Correct approach:

POST /users with body {"name": "Alice", "address": {"street": "Main St", "city": ""}}

Root cause:

Nested models enforce their own required fields; missing them breaks validation.

Key Takeaways

Nested models let you organize complex data by embedding smaller models inside bigger ones, making your API data clear and maintainable.

FastAPI and Pydantic automatically validate nested models recursively, so you get reliable data checks without extra code.

You can nest single models or lists of models to represent one-to-one and one-to-many relationships naturally.

Custom validation and serialization inside nested models give you fine control over your API's behavior and output.

Understanding nested models connects to concepts like object-oriented programming, JSON structure, and database design, enriching your overall software skills.

Practice

1. What is the main purpose of using nested models in FastAPI?

easy

A. To represent complex data structures by embedding one model inside another

B. To speed up the API response time

C. To automatically generate HTML pages

D. To replace database models with simpler ones

Solution

1. Step 1: Understand nested models concept

   Nested models allow you to include one Pydantic model inside another to represent complex or hierarchical data.

2. Step 2: Identify the main purpose in FastAPI

   FastAPI uses nested models to validate and structure complex JSON data clearly and maintainably.

3. Final Answer:

   To represent complex data structures by embedding one model inside another -> Option A

4. Quick Check:

   Nested models = complex data representation [OK]

Hint: Nested models = models inside models for complex data [OK]

Common Mistakes:

• Thinking nested models improve speed
• Confusing nested models with HTML generation
• Assuming nested models replace databases

2. Which of the following is the correct way to define a nested model in FastAPI using Pydantic?

easy

A. class User(BaseModel): name: str; address: str

B. class Address(BaseModel): street: str; class User(BaseModel): name: str; address: Address

C. class User(BaseModel): name: str; address = Address()

D. class Address: street: str; class User: name: str; address: Address

Solution

1. Step 1: Check Pydantic model syntax

   Models must inherit from BaseModel and use type annotations for fields.

2. Step 2: Verify nested model usage

   Nested models are declared by using the nested model class as a type annotation for a field.

3. Final Answer:

   class Address(BaseModel): street: str; class User(BaseModel): name: str; address: Address -> Option B

4. Quick Check:

   Nested model as type annotation = correct syntax [OK]

Hint: Use nested model class as field type with BaseModel inheritance [OK]

Common Mistakes:

• Not inheriting from BaseModel
• Assigning nested model instance instead of type
• Using plain classes without BaseModel

3. Given the following FastAPI models:

class Item(BaseModel): name: str; price: float
class Order(BaseModel): id: int; item: Item

What will be the output of Order(id=1, item={'name': 'Book', 'price': 12.5}).item.price?

medium

A. None

B. '12.5'

C. Error: item must be an Item instance

D. 12.5

Solution

1. Step 1: Understand nested model instantiation

   FastAPI/Pydantic automatically converts nested dicts to model instances when creating the parent model.

2. Step 2: Access nested attribute

   Accessing item.price returns the float value 12.5 from the nested Item model.

3. Final Answer:

   12.5 -> Option D

4. Quick Check:

   Nested dict converts to model, attribute accessed = 12.5 [OK]

Hint: Nested dicts auto-convert to models, access attributes normally [OK]

Common Mistakes:

• Expecting string instead of float
• Thinking nested dicts cause errors
• Assuming nested model must be instance, not dict

4. Identify the error in this FastAPI nested model code:

class Profile(BaseModel): age: int
class User(BaseModel): username: str; profile = {"age": 30}

medium

A. Missing type annotation for profile field

B. Profile class must inherit from BaseSettings, not BaseModel

C. Default value for nested model must be a Profile instance, not a dict

D. username field should be Optional[str]

Solution

1. Step 1: Check field type annotations

   All Pydantic model fields require type annotations (: Type) for proper validation, especially for nested models.

2. Step 2: Identify the missing annotation

   The profile field lacks type annotation: it should be profile: Profile = {"age": 30} or profile: Profile = Profile(age=30) to enable nested model validation.

3. Final Answer:

   Missing type annotation for profile field -> Option A

4. Quick Check:

   Type annotation required for nested model fields [OK]

Hint: All model fields must have type annotations: field: Type [OK]

Common Mistakes:

• Using dict instead of model instance as default
• Ignoring type annotations
• Confusing BaseModel with BaseSettings

5. You want to create a FastAPI model for a blog post with nested author info. The author has name and email. The post has title, content, and author. Which code correctly defines these nested models and validates that the author's email is a valid email address?

hard

A. class Author(BaseModel): name: str; email: str
class Post(BaseModel): title: str; content: str; author: Author

@validator('email')
def check_email(cls, v): return v

B. class Author(BaseModel): name: str; email: str
class Post(BaseModel): title: str; content: str; author: dict

C. class Author(BaseModel): name: str; email: EmailStr
class Post(BaseModel): title: str; content: str; author: Author

D. class Author(BaseModel): name: str; email: EmailStr
class Post(BaseModel): title: str; content: str; author: dict

Solution

1. Step 1: Use EmailStr for email validation

   Pydantic provides EmailStr type to validate email addresses automatically.

2. Step 2: Define nested models correctly

   Author model uses EmailStr, Post model nests Author as a field with correct type annotation.

3. Final Answer:

   class Author(BaseModel): name: str; email: EmailStr class Post(BaseModel): title: str; content: str; author: Author -> Option C

4. Quick Check:

   EmailStr + nested Author model = correct validation [OK]

Hint: Use EmailStr type and nested model as field type [OK]

Common Mistakes:

• Using plain str for email without validation
• Setting author field as dict instead of Author model
• Trying to validate email with incorrect validator placement