Why request bodies carry structured data in FastAPI - See It in Action

Why request bodies carry structured data

📖 Scenario: You are building a simple web API using FastAPI. Your API needs to receive user information like name and age in a structured way so it can process it correctly.

🎯 Goal: Build a FastAPI endpoint that accepts a JSON request body with user data structured as a dictionary with name and age keys.

📋 What You'll Learn

Create a Pydantic model called User with fields name (string) and age (integer).

Create a FastAPI app instance called app.

Create a POST endpoint at /users/ that accepts a User object as the request body.

Return the received user data as JSON in the response.

💡 Why This Matters

🌍 Real World

APIs often receive data from clients in structured formats like JSON. Using models helps keep data organized and validated.

💼 Career

Understanding how to handle structured request bodies is essential for backend developers building reliable web APIs.

1

Create the User data model

Write code to import BaseModel from pydantic and create a class called User that inherits from BaseModel. Add two fields: name of type str and age of type int.

FastAPI

# Your code here to create User model

Hint

Think of User as a form with two fields: name and age. Use BaseModel to define it.

2

Create the FastAPI app instance

Write code to import FastAPI from fastapi and create an instance called app.

FastAPI

from pydantic import BaseModel

class User(BaseModel):
    name: str
    age: int

# Create FastAPI app instance

Hint

FastAPI apps start by creating an app object from the FastAPI class.

3

Create the POST endpoint to receive User data

Write a function called create_user decorated with @app.post("/users/"). The function should accept one parameter called user of type User. The function should return the user object.

FastAPI

from pydantic import BaseModel
from fastapi import FastAPI

class User(BaseModel):
    name: str
    age: int

app = FastAPI()

# Create POST endpoint to receive User data

Hint

Use @app.post("/users/") to create a POST endpoint. The function should accept user: User and return it.

4

Complete the FastAPI app with structured request body

Ensure the full code includes the User model, the app instance, and the create_user POST endpoint that accepts a User object and returns it.

FastAPI

from pydantic import BaseModel
from fastapi import FastAPI

class User(BaseModel):
    name: str
    age: int

app = FastAPI()

@app.post("/users/")
async def create_user(user: User):
    # Return the user object
    return user

Hint

Check that all parts are present: model, app, and endpoint returning the user.

Practice

1. Why do request bodies in FastAPI usually carry structured data like JSON objects?

easy

A. To make the request body smaller in size

B. To allow the server to understand and validate the data easily

C. To hide the data from the client

D. To speed up the network connection

Solution

1. Step 1: Understand the purpose of structured data in requests

   Structured data like JSON helps the server know exactly what information it is receiving.

2. Step 2: Recognize the benefit of validation

   Using structured data allows FastAPI to validate the data automatically, ensuring it is correct and complete.

3. Final Answer:

   To allow the server to understand and validate the data easily -> Option B

4. Quick Check:

   Structured data = clear server understanding [OK]

Hint: Structured data helps servers read and check data easily [OK]

Common Mistakes:

• Thinking structured data hides information
• Believing it reduces request size
• Assuming it speeds up network

2. Which of the following is the correct way to declare a request body using a Pydantic model in FastAPI?

easy

A. def create_item(item: dict):

B. def create_item(item: int):

C. def create_item(item: str):

D. def create_item(item: Item):

Solution

1. Step 1: Identify the use of Pydantic models

   FastAPI uses Pydantic models to define structured request bodies, so the parameter type should be a model class like Item.

2. Step 2: Check the parameter type

   Using a dict or primitive types like str or int does not provide validation or structure automatically.

3. Final Answer:

   def create_item(item: Item): -> Option D

4. Quick Check:

   Use Pydantic model type for request body [OK]

Hint: Use Pydantic model class as parameter type [OK]

Common Mistakes:

• Using dict instead of a Pydantic model
• Using primitive types for complex data
• Not importing or defining the model

3. Given this FastAPI endpoint and Pydantic model:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    name: str
    age: int

@app.post('/users/')
async def create_user(user: User):
    return {"message": f"User {user.name} is {user.age} years old"}

What will be the response if the client sends:

{"name": "Alice", "age": 30}

medium

A. Validation error because age is not a string

B. {"message": "User 30 is Alice years old"}

C. {"message": "User Alice is 30 years old"}

D. Empty response with status 204

Solution

1. Step 1: Understand the model and endpoint

   The User model expects a name (string) and age (integer). The endpoint returns a message using these values.

2. Step 2: Check the input data

   The input JSON matches the model: name is "Alice" (string), age is 30 (int), so validation passes.

3. Final Answer:

   {"message": "User Alice is 30 years old"} -> Option C

4. Quick Check:

   Valid input returns formatted message [OK]

Hint: Match input types to model fields for success [OK]

Common Mistakes:

• Confusing field order in output
• Expecting validation error for correct types
• Assuming empty or error response

4. What is wrong with this FastAPI endpoint that expects a request body?

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Product(BaseModel):
    id: int
    name: str

@app.post('/products/')
def add_product(product: Product):
    return product

medium

A. There is no problem; the code is correct

B. The Product model fields are not typed correctly

C. The endpoint function is missing async keyword

D. The endpoint function should be async to handle requests properly

Solution

1. Step 1: Check function signature

   FastAPI supports both async and normal functions for endpoints. Missing async is allowed.

2. Step 2: Verify model and return

   The Product model is correctly typed, and returning the model instance is valid and will be serialized.

3. Final Answer:

   There is no problem; the code is correct -> Option A

4. Quick Check:

   Sync endpoint with Pydantic model is valid [OK]

Hint: Async is optional; sync functions work too [OK]

Common Mistakes:

• Thinking async is mandatory for endpoints
• Assuming model fields need special types
• Expecting error when returning model instance

5. You want to create a FastAPI endpoint that accepts a request body with a list of items, each having a name and quantity. Which approach correctly uses structured data to achieve this?

hard

A. Define a Pydantic model for an item and use List[Item] as the parameter type

B. Use a plain list of dictionaries without a Pydantic model

C. Accept a single string with comma-separated item names

D. Use multiple query parameters for each item

Solution

1. Step 1: Understand the need for structured data

   Each item has multiple fields (name and quantity), so a Pydantic model defines this structure clearly.

2. Step 2: Use a list of these models for multiple items

   Using List[Item] as the parameter type allows FastAPI to validate each item in the list properly.

3. Final Answer:

   Define a Pydantic model for an item and use List[Item] as the parameter type -> Option A

4. Quick Check:

   List of models = structured, validated data [OK]

Hint: Use List of Pydantic models for multiple structured items [OK]

Common Mistakes:

• Skipping Pydantic models for complex data
• Using plain lists without validation
• Trying to pass complex data via query parameters