Why validation prevents bad data in FastAPI - See It in Action

Why validation prevents bad data

📖 Scenario: You are building a simple FastAPI app that accepts user data for a newsletter subscription. You want to make sure the data is correct before saving it.

🎯 Goal: Create a FastAPI app that uses Pydantic models to validate incoming user data and prevents bad data from being accepted.

📋 What You'll Learn

Create a Pydantic model called User with fields name (str) and email (str)

Add a FastAPI app instance called app

Create a POST endpoint /subscribe that accepts a User model

Return a success message with the user's name if data is valid

💡 Why This Matters

🌍 Real World

Validating user input is crucial in web apps to avoid errors and security issues. FastAPI with Pydantic makes this easy and reliable.

💼 Career

Backend developers often build APIs that must validate data before processing. Knowing how to use FastAPI and Pydantic validation is a valuable skill.

1

Create the User data model

Create a Pydantic model called User with two fields: name of type str and email of type str. Import BaseModel from pydantic.

FastAPI

from pydantic import BaseModel

# Define the User model here
# Your code here

Hint

Use class User(BaseModel): and define name and email as string fields.

2

Create the FastAPI app instance

Import FastAPI from fastapi and create an app instance called app.

FastAPI

from pydantic import BaseModel
from fastapi import FastAPI

class User(BaseModel):
    name: str
    email: str

# Create FastAPI app instance
# Your code here

Hint

Use app = FastAPI() to create the app instance.

3

Create the POST endpoint with validation

Create a POST endpoint /subscribe using @app.post("/subscribe"). Define a function subscribe that accepts a parameter user of type User. This will automatically validate the incoming JSON data.

FastAPI

from pydantic import BaseModel
from fastapi import FastAPI

class User(BaseModel):
    name: str
    email: str

app = FastAPI()

# Create POST endpoint /subscribe
# Your code here

Hint

Use @app.post("/subscribe") and define an async function subscribe(user: User) that returns a message with the user's name.

4

Add response model and complete the app

Add a response model to the /subscribe endpoint by specifying response_model=dict in the decorator. This completes the FastAPI app that validates user data and returns a success message.

FastAPI

from pydantic import BaseModel
from fastapi import FastAPI

class User(BaseModel):
    name: str
    email: str

app = FastAPI()

# Add response_model to the /subscribe endpoint
# Your code here

Hint

Add response_model=dict inside the @app.post decorator.

Practice

1. Why does FastAPI use validation on incoming data?

easy

A. To make the app run slower

B. To ignore user input errors

C. To ensure data is correct before using it

D. To skip checking data types

Solution

1. Step 1: Understand the purpose of validation

   Validation checks if the data matches expected rules before the app uses it.

2. Step 2: Identify the benefit in FastAPI

   FastAPI uses validation to catch bad data early and avoid errors later.

3. Final Answer:

   To ensure data is correct before using it -> Option C

4. Quick Check:

   Validation = Ensures correct data [OK]

Hint: Validation means checking data before use [OK]

Common Mistakes:

• Thinking validation slows the app down
• Believing validation ignores errors
• Assuming validation skips data checks

2. Which of these is the correct way to declare a Pydantic model field with validation in FastAPI?

easy

A. name = str(min_length=3)

B. name: str = Field(min_length=3)

C. name: Field = str(min_length=3)

D. Field(name: str, min_length=3)

Solution

1. Step 1: Recall Pydantic field syntax

   Fields are declared with type hints and Field() for validation, like name: str = Field(...).

2. Step 2: Match correct syntax

   name: str = Field(min_length=3) uses name: str = Field(min_length=3), which is correct.

3. Final Answer:

   name: str = Field(min_length=3) -> Option B

4. Quick Check:

   Field syntax = type hint + Field() [OK]

Hint: Use type hint plus Field() for validation [OK]

Common Mistakes:

• Putting validation inside type hint
• Calling Field() without assignment
• Using wrong order of parameters

3. Given this FastAPI endpoint using a Pydantic model with age: int = Field(gt=0), what happens if a client sends {"age": -5}?

medium

A. The request succeeds and age is set to -5

B. The server crashes with an exception

C. The age field is ignored and set to 0

D. FastAPI returns a validation error response

Solution

1. Step 1: Understand the validation rule

   The field age must be greater than 0 (gt=0).

2. Step 2: Check input against rule

   Input -5 violates this rule, so validation fails.

3. Final Answer:

   FastAPI returns a validation error response -> Option D

4. Quick Check:

   Invalid data triggers validation error [OK]

Hint: Invalid data triggers error response [OK]

Common Mistakes:

• Assuming invalid data is accepted
• Thinking invalid fields get default values
• Believing server crashes on validation failure

4. What is wrong with this FastAPI Pydantic model if it does not reject empty strings for a required username: str field?

class User(BaseModel):
    username: str

medium

A. Missing validation to prevent empty strings

B. Field type should be int, not str

C. BaseModel is not imported

D. username should be Optional[str]

Solution

1. Step 1: Analyze the model field

   The field username: str accepts any string, including empty ones.

2. Step 2: Identify missing validation

   To reject empty strings, add validation like min_length=1 in Field().

3. Final Answer:

   Missing validation to prevent empty strings -> Option A

4. Quick Check:

   Empty strings need explicit validation [OK]

Hint: Add min_length to reject empty strings [OK]

Common Mistakes:

• Assuming str type rejects empty strings
• Changing type to int incorrectly
• Making field optional instead of validating

5. You want to prevent bad data by validating a nested Pydantic model in FastAPI. Which approach correctly ensures the nested data is validated?

hard

A. Use a Pydantic model as a field type inside another model

B. Use a plain dict type for nested data without a model

C. Validate nested data manually after receiving it

D. Skip validation for nested data to improve speed

Solution

1. Step 1: Understand nested model validation

   FastAPI validates nested models automatically if you use Pydantic models as field types.

2. Step 2: Compare options

   Using a Pydantic model inside another model ensures nested validation, unlike plain dict or manual checks.

3. Final Answer:

   Use a Pydantic model as a field type inside another model -> Option A

4. Quick Check:

   Nested Pydantic models validate nested data [OK]

Hint: Nest Pydantic models for automatic validation [OK]

Common Mistakes:

• Using dict instead of model for nested data
• Skipping nested validation for speed
• Validating nested data manually outside model