Streaming responses in FastAPI - Step-by-Step Execution

Concept Flow - Streaming responses

Client sends request

↓

Server starts processing

↓

Server yields data chunks

↓

Client receives chunks progressively

↓

Streaming ends when all data sent

↓

Connection closes

The server sends data in small pieces as they become ready, letting the client receive it bit by bit without waiting for all data.

Execution Sample

FastAPI

from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()

@app.get("/stream")
async def stream():
    async def generator():
        for i in range(3):
            yield f"chunk {i}\n"
    return StreamingResponse(generator(), media_type="text/plain")

This FastAPI endpoint streams three text chunks to the client one by one.

Execution Table

Step	Action	Generator State	Data Yielded	Client Receives
1	Request received, generator starts	Not started	None	None
2	Generator yields 'chunk 0\n'	Yielded 0	'chunk 0\n'	'chunk 0\n' received
3	Generator yields 'chunk 1\n'	Yielded 1	'chunk 1\n'	'chunk 1\n' received
4	Generator yields 'chunk 2\n'	Yielded 2	'chunk 2\n'	'chunk 2\n' received
5	Generator ends, streaming complete	Completed	None	Streaming finished
6	Connection closes	N/A	N/A	Connection closed

💡 All chunks yielded and sent; streaming ends and connection closes

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
i	N/A	0	1	2	N/A
generator state	Not started	Yielded 0	Yielded 1	Yielded 2	Completed

Key Moments - 3 Insights

Why does the client receive data in parts instead of all at once?

Because the server uses a generator that yields chunks one by one (see execution_table steps 2-4), so data is sent progressively.

What happens when the generator finishes yielding all chunks?

StreamingResponse detects the generator is done (step 5), finishes sending data, and closes the connection (step 6).

Can the client start processing data before the entire response is ready?

Yes, the client receives each chunk as soon as it is yielded (execution_table steps 2-4), allowing immediate processing.

Visual Quiz - 3 Questions

Look at the execution table, what is the generator state after step 3?

A Not started

B Yielded 1

C Completed

D Yielded 2

💡 Hint

Check the 'Generator State' column at step 3 in the execution_table

At which step does the client receive the last chunk?

A Step 4

B Step 5

C Step 2

D Step 6

💡 Hint

Look at the 'Client Receives' column for the last 'chunk 2\n' in the execution_table

If the generator yielded 5 chunks instead of 3, how would the variable 'i' change in variable_tracker?

A It would stay at 3

B It would go from 1 to 5

C It would go from 0 to 4 across iterations

D It would not change

💡 Hint

Variable 'i' tracks the loop index; see variable_tracker values for 'i'

Concept Snapshot

Streaming responses in FastAPI:
- Use a generator function to yield data chunks
- Return StreamingResponse(generator, media_type)
- Client receives data progressively
- Useful for large or slow data
- Connection closes after all chunks sent

Full Transcript

Streaming responses in FastAPI let the server send data bit by bit instead of all at once. When a client requests the streaming endpoint, the server starts a generator that yields small pieces of data. Each chunk is sent immediately to the client, who can start processing it right away. This continues until the generator finishes yielding all chunks. Then the server closes the connection. This method is helpful when sending large files or data that takes time to prepare. The example code shows a generator yielding three text chunks. The execution table traces each step: starting the generator, yielding chunks, client receiving them, and closing the connection. Variables like the loop index 'i' update with each yield. Understanding this flow helps beginners see how streaming responses work in FastAPI.