WebSocket endpoint creation in FastAPI - Step-by-Step Execution

Concept Flow - WebSocket endpoint creation

Client connects to WebSocket URL

↓

Server accepts connection

↓

Server listens for messages

↓

Client sends message

→Server receives message

↓

Server processes message

↓

Connection stays open or closes

↓

End

This flow shows how a WebSocket connection is established, messages are exchanged, and the connection is maintained or closed.

Execution Sample

FastAPI

from fastapi import FastAPI, WebSocket
app = FastAPI()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    data = await websocket.receive_text()
    await websocket.send_text(f"Message text was: {data}")

This code creates a WebSocket endpoint that accepts a connection, receives a text message, and sends back a response with the received message.

Execution Table

Step	Action	Evaluation	Result
1	Client connects to /ws	Connection request received	Server prepares to accept
2	Server calls websocket.accept()	Connection accepted	WebSocket connection established
3	Server waits for message	Waiting for client message	Paused until message arrives
4	Client sends message 'Hello'	Message received	data = 'Hello'
5	Server processes message	Formats response string	Response = 'Message text was: Hello'
6	Server sends response	Response sent to client	Client receives response
7	Connection remains open or closes	Depends on client/server	Connection stays or ends

💡 Execution stops when connection closes or client disconnects

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
websocket	WebSocket object	Connected WebSocket	Connected WebSocket	Connected or closed
data	None	'Hello'	'Hello'	'Hello'
response	None	None	'Message text was: Hello'	'Message text was: Hello'

Key Moments - 3 Insights

Why do we need to call websocket.accept()?

The server must accept the WebSocket connection explicitly; without calling websocket.accept(), the connection is not established. See execution_table step 2.

What happens if the client sends no message?

The server waits at await websocket.receive_text() until a message arrives, so the code pauses at step 3 until the client sends something.

Can the connection stay open after sending a response?

Yes, WebSocket connections stay open for continuous communication unless closed by client or server, as shown in step 7.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'data' after step 4?

A 'Hello'

B None

C 'Message text was: Hello'

D WebSocket object

💡 Hint

Check the variable_tracker row for 'data' at 'After Step 4'

At which step does the server accept the WebSocket connection?

A Step 1

B Step 4

C Step 2

D Step 6

💡 Hint

Look at execution_table step describing websocket.accept()

If the client never sends a message, what happens at step 3?

A Server sends a default message

B Server waits indefinitely for a message

C Server closes connection immediately

D Server throws an error

💡 Hint

Refer to key_moments about waiting for client message

Concept Snapshot

WebSocket endpoint creation in FastAPI:
- Use @app.websocket decorator with URL path
- Accept connection with await websocket.accept()
- Receive messages with await websocket.receive_text()
- Send messages with await websocket.send_text()
- Connection stays open for ongoing communication
- Close connection when done or on error

Full Transcript

This visual execution trace shows how to create a WebSocket endpoint in FastAPI. The client connects to the server's WebSocket URL. The server accepts the connection explicitly using websocket.accept(). Then the server waits for a message from the client. When the client sends a message, the server receives it and processes it. The server sends back a response message to the client. The connection can stay open for more messages or close when communication ends. Variables like 'data' hold the received message, and 'response' holds the message sent back. Key points include the need to accept the connection and that the server waits for messages asynchronously. This step-by-step flow helps beginners understand how WebSocket communication works in FastAPI.

Practice

1. What decorator is used in FastAPI to create a WebSocket endpoint?

easy

A. @app.websocket

B. @app.get

C. @app.post

D. @app.route

Solution

1. Step 1: Understand FastAPI endpoint decorators

   FastAPI uses different decorators for different endpoint types: @app.get for GET HTTP, @app.post for POST HTTP, and @app.websocket for WebSocket connections.

2. Step 2: Identify the correct decorator for WebSocket

   Since WebSocket is a different protocol from HTTP, FastAPI uses @app.websocket to create WebSocket endpoints.

3. Final Answer:

   @app.websocket -> Option A

4. Quick Check:

   WebSocket endpoint decorator = @app.websocket [OK]

Hint: WebSocket endpoints use @app.websocket decorator [OK]

Common Mistakes:

• Using @app.get or @app.post instead of @app.websocket
• Confusing HTTP routes with WebSocket routes
• Trying to use @app.route which is not in FastAPI

2. Which of the following is the correct syntax to accept a WebSocket connection in FastAPI?

easy

A. await websocket.connect()

B. websocket.accept()

C. await websocket.accept()

D. websocket.connect()

Solution

1. Step 1: Recognize asynchronous WebSocket methods

   FastAPI WebSocket methods are async, so you must use await to call them.

2. Step 2: Identify the method to accept a connection

   The method to accept a WebSocket connection is accept(), which must be awaited as await websocket.accept().

3. Final Answer:

   await websocket.accept() -> Option C

4. Quick Check:

   Accept WebSocket connection = await websocket.accept() [OK]

Hint: Use await with websocket.accept() to accept connection [OK]

Common Mistakes:

• Forgetting to use await with async methods
• Using websocket.connect() which does not exist
• Calling accept() without await causing runtime errors

3. Given this FastAPI WebSocket endpoint code, what will it send back to the client when the client sends 'hello'?

from fastapi import FastAPI, WebSocket
app = FastAPI()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    data = await websocket.receive_text()
    await websocket.send_text(f"Message text was: {data}")

medium

A. Message text was: hello

B. hello

C. Message text was: None

D. Error: receive_text() not awaited

Solution

1. Step 1: Trace the WebSocket message flow

   The server accepts the connection, then waits to receive text from the client. It stores the received text in 'data'.

2. Step 2: Understand the response sent back

   The server sends back a message with the text 'Message text was: ' plus the received data. If client sends 'hello', the response is 'Message text was: hello'.

3. Final Answer:

   Message text was: hello -> Option A

4. Quick Check:

   Sent message = 'Message text was: hello' [OK]

Hint: Server echoes with prefix 'Message text was:' [OK]

Common Mistakes:

• Confusing received message with sent message
• Missing await causing runtime errors
• Assuming server sends back raw client message without prefix

4. Identify the error in this FastAPI WebSocket endpoint code:

from fastapi import FastAPI, WebSocket
app = FastAPI()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    websocket.accept()
    data = await websocket.receive_text()
    await websocket.send_text(data)

medium

A. Missing await before websocket.receive_text()

B. Missing await before websocket.accept()

C. Missing await before websocket.send_text()

D. Incorrect WebSocket path

Solution

1. Step 1: Check async method calls

   In FastAPI, websocket.accept() is an async method and must be awaited.

2. Step 2: Identify missing await

   The code calls websocket.accept() without await, which will cause a runtime error.

3. Final Answer:

   Missing await before websocket.accept() -> Option B

4. Quick Check:

   Async methods require await = missing await [OK]

Hint: Always await async WebSocket methods like accept() [OK]

Common Mistakes:

• Calling async methods without await
• Confusing which methods are async
• Assuming accept() is synchronous

5. You want to create a FastAPI WebSocket endpoint that continuously receives messages and sends back each message reversed. Which code snippet correctly implements this behavior?

hard

A. async def websocket_endpoint(websocket: WebSocket):
websocket.accept()
while True:
data = websocket.receive_text()
websocket.send_text(data[::-1])

B. async def websocket_endpoint(websocket: WebSocket):
await websocket.accept()
data = await websocket.receive_text()
await websocket.send_text(data[::-1])

C. async def websocket_endpoint(websocket: WebSocket):
await websocket.accept()
for data in websocket.receive_text():
await websocket.send_text(data[::-1])

D. async def websocket_endpoint(websocket: WebSocket):
await websocket.accept()
while True:
data = await websocket.receive_text()
await websocket.send_text(data[::-1])

Solution

1. Step 1: Understand continuous message handling

   To handle multiple messages, the server must loop indefinitely, receiving and sending messages repeatedly.

2. Step 2: Check async calls and loop structure

   async def websocket_endpoint(websocket: WebSocket): await websocket.accept() while True: data = await websocket.receive_text() await websocket.send_text(data[::-1]) uses an async while True loop, awaits receive_text(), and sends back reversed text with await send_text(), correctly handling async and continuous flow.

3. Final Answer:

   async def websocket_endpoint(websocket: WebSocket): await websocket.accept() while True: data = await websocket.receive_text() await websocket.send_text(data[::-1]) -> Option D

4. Quick Check:

   Continuous async loop with await calls = async def websocket_endpoint(websocket: WebSocket): await websocket.accept() while True: data = await websocket.receive_text() await websocket.send_text(data[::-1]) [OK]

Hint: Use while True with await receive and send for continuous WebSocket [OK]

Common Mistakes:

• Missing loop for continuous messages
• Not awaiting async methods
• Using for loop incorrectly on async receive_text()
• Calling async methods without await