Bulk operations in FastAPI - Step-by-Step Execution

Concept Flow - Bulk operations

Receive bulk data request

↓

Validate each item in bulk

↓

Process items one by one or batch

↓

Save all valid items to database

↓

Return summary response

↓

END

The flow shows how FastAPI receives a bulk request, validates each item, processes them, saves to database, and returns a summary.

Execution Sample

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float

@app.post('/items/bulk')
async def create_items(items: list[Item]):
    saved = []
    for item in items:
        saved.append({'name': item.name, 'price': item.price})
    return {'saved_count': len(saved), 'items': saved}

This FastAPI endpoint accepts a list of items, validates each, saves them in memory, and returns a count and list.

Execution Table

Step	Action	Input	Validation Result	Processing	Output
1	Receive request	[{'name':'Pen','price':1.5},{'name':'Book','price':5.0}]	Pending	Pending	Pending
2	Validate first item	{'name':'Pen','price':1.5}	Valid	Append to saved list	saved = [{'name':'Pen','price':1.5}]
3	Validate second item	{'name':'Book','price':5.0}	Valid	Append to saved list	saved = [{'name':'Pen','price':1.5},{'name':'Book','price':5.0}]
4	All items processed	N/A	All valid	Return response	{'saved_count': 2, 'items': [{'name':'Pen','price':1.5},{'name':'Book','price':5.0}]}
5	Exit	N/A	N/A	N/A	Request complete

💡 All items validated and saved, response returned.

Variable Tracker

Variable	Start	After 1	After 2	Final
items	[{'name':'Pen','price':1.5},{'name':'Book','price':5.0}]	[{'name':'Pen','price':1.5},{'name':'Book','price':5.0}]	[{'name':'Pen','price':1.5},{'name':'Book','price':5.0}]	[{'name':'Pen','price':1.5},{'name':'Book','price':5.0}]
saved	[]	[{'name':'Pen','price':1.5}]	[{'name':'Pen','price':1.5},{'name':'Book','price':5.0}]	[{'name':'Pen','price':1.5},{'name':'Book','price':5.0}]

Key Moments - 3 Insights

Why do we validate each item separately instead of the whole list at once?

Each item is validated individually to catch errors precisely and ensure all data matches the expected format, as shown in steps 2 and 3 of the execution_table.

What happens if one item in the bulk list is invalid?

FastAPI will return a validation error immediately and stop processing, so no items are saved. This is implied by the validation step in the execution_table where invalid input would stop further processing.

Why do we return a summary response instead of the full saved data?

Returning a summary like count and saved items helps clients confirm what was processed without sending unnecessary data, as shown in step 4 of the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'saved' after processing the first item?

A []

B [{'name':'Book','price':5.0}]

C [{'name':'Pen','price':1.5}]

D None

💡 Hint

Check the 'Processing' column at Step 2 in the execution_table.

At which step does the API return the final response?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look for the 'Return response' action in the execution_table.

If the input list was empty, how would the 'saved_count' in the output change?

A It would cause an error

B It would be 0

C It would be 1

D It would be null

💡 Hint

Refer to the variable_tracker for 'saved' starting value and final count logic.

Concept Snapshot

FastAPI bulk operations accept a list of items.
Each item is validated by Pydantic.
Process items in a loop or batch.
Save all valid items.
Return a summary response with count and saved data.
Validation errors stop processing immediately.

Full Transcript

This visual execution trace shows how FastAPI handles bulk operations by receiving a list of items, validating each item individually, processing them by appending to a saved list, and finally returning a summary response with the count of saved items and their details. The execution table walks through each step from receiving the request to returning the response. Variables like 'items' and 'saved' are tracked to show their values after each processing step. Key moments clarify common confusions such as why individual validation is important and what happens on errors. The visual quiz tests understanding of the saved list state and response timing. The concept snapshot summarizes the bulk operation pattern in FastAPI for quick reference.

Practice

1. What is the main benefit of using bulk operations in FastAPI?

easy

A. They limit the number of items processed to one per request.

B. They automatically generate HTML forms for data input.

C. They encrypt data before sending it to the client.

D. They allow handling many items in a single request, reducing server calls.

Solution

1. Step 1: Understand bulk operations purpose

   Bulk operations let you send many items at once instead of one by one.

2. Step 2: Identify the main benefit

   This reduces the number of server calls and speeds up processing.

3. Final Answer:

   They allow handling many items in a single request, reducing server calls. -> Option D

4. Quick Check:

   Bulk operations = fewer server calls [OK]

Hint: Bulk means many items at once, not one by one [OK]

Common Mistakes:

• Thinking bulk operations encrypt data
• Confusing bulk with form generation
• Assuming bulk limits to one item

2. Which of the following is the correct way to accept multiple items in a FastAPI endpoint using Pydantic models?

easy

A. def create_items(items: ItemModel[]):

B. def create_items(item: ItemModel):

C. def create_items(items: List[ItemModel]):

D. def create_items(items: Dict[ItemModel]):

Solution

1. Step 1: Recall FastAPI typing for multiple items

   FastAPI uses Python typing List[Model] to accept multiple objects.

2. Step 2: Check each option's syntax

   def create_items(items: List[ItemModel]): uses List[ItemModel], which is correct. def create_items(item: ItemModel): accepts one item only. def create_items(items: ItemModel[]): uses invalid syntax. def create_items(items: Dict[ItemModel]): uses Dict which is not for lists.

3. Final Answer:

   def create_items(items: List[ItemModel]): -> Option C

4. Quick Check:

   Multiple items = List[Model] [OK]

Hint: Use List[Model] to accept many items in FastAPI [OK]

Common Mistakes:

• Using ItemModel[] which is invalid syntax
• Using Dict instead of List for multiple items
• Forgetting to import List from typing

3. Given this FastAPI endpoint:

from fastapi import FastAPI
from pydantic import BaseModel
from typing import List

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float

@app.post('/items/')
async def create_items(items: List[Item]):
    return {'count': len(items), 'names': [item.name for item in items]}

What will be the response if the client sends this JSON body?

[{"name": "apple", "price": 1.2}, {"name": "banana", "price": 0.5}]

medium

A. Validation error due to missing fields

B. {"count": 2, "names": ["apple", "banana"]}

C. {"count": 1, "names": ["apple"]}

D. {"count": 0, "names": []}

Solution

1. Step 1: Understand input and endpoint behavior

   The endpoint accepts a list of Item objects and returns count and names list.

2. Step 2: Analyze input JSON

   The input has two items with names 'apple' and 'banana'.

3. Step 3: Predict output

   Count is 2, names list contains both names.

4. Final Answer:

   {"count": 2, "names": ["apple", "banana"]} -> Option B

5. Quick Check:

   List length = 2, names extracted correctly [OK]

Hint: Count list length and extract names from each item [OK]

Common Mistakes:

• Assuming only one item processed
• Expecting validation error without reason
• Returning empty list mistakenly

4. Identify the error in this FastAPI bulk operation endpoint:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

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

@app.post('/users/')
async def create_users(users: User):
    return {'usernames': [user.username for user in users]}

medium

A. The parameter 'users' should be a list type like List[User].

B. The return statement should not use list comprehension.

C. The User model is missing required fields.

D. The endpoint path should be '/user/' not '/users/'.

Solution

1. Step 1: Check parameter type for bulk input

   The parameter 'users' is typed as User, which accepts one object, not multiple.

2. Step 2: Identify correct typing for multiple users

   To accept many users, it should be List[User] from typing module.

3. Final Answer:

   The parameter 'users' should be a list type like List[User]. -> Option A

4. Quick Check:

   Bulk input needs List[Model] type [OK]

Hint: Bulk input must be List[Model], not single Model [OK]

Common Mistakes:

• Using single model instead of list for bulk
• Thinking list comprehension causes error
• Confusing endpoint path naming

5. You want to create a FastAPI endpoint that accepts a bulk list of products but only saves those with price greater than 10. Which code snippet correctly implements this filtering inside the endpoint?

hard

A. async def create_products(products: List[Product]):
filtered = [p for p in products if p.price > 10]
return {'saved': len(filtered)}

B. async def create_products(products: List[Product]):
filtered = [p for p in products if p.price < 10]
return {'saved': len(filtered)}

C. async def create_products(products: Product):
filtered = [p for p in products if p.price > 10]
return {'saved': len(filtered)}

D. async def create_products(products: List[Product]):
filtered = filter(lambda p: p.price < 10, products)
return {'saved': len(filtered)}

Solution

1. Step 1: Confirm parameter type for bulk products

   Parameter must be List[Product] to accept multiple products.

2. Step 2: Check filtering condition

   We want products with price greater than 10, so filter with p.price > 10.

3. Step 3: Validate return value

   Return count of filtered list using len(filtered).

4. Final Answer:

   async def create_products(products: List[Product]): filtered = [p for p in products if p.price > 10] return {'saved': len(filtered)} -> Option A

5. Quick Check:

   Filter price > 10 and count saved [OK]

Hint: Filter with list comprehension and correct condition [OK]

Common Mistakes:

• Filtering with wrong condition (price < 10)
• Using single Product instead of List[Product]
• Using filter but forgetting to convert to list before len()