WebSocket endpoint creation in FastAPI - Mini Project: Build & Apply

WebSocket endpoint creation

📖 Scenario: You are building a simple chat server using FastAPI. Users will connect to your server using WebSocket to send and receive messages in real time.

🎯 Goal: Create a WebSocket endpoint in FastAPI that accepts connections and echoes back any message sent by the client.

📋 What You'll Learn

Create a FastAPI app instance named app

Create a WebSocket endpoint at path /ws

Accept WebSocket connections using the websocket parameter

Accept and receive text messages from the client

Send back the same message to the client (echo)

Properly accept and close the WebSocket connection

💡 Why This Matters

🌍 Real World

WebSocket endpoints are used in real-time applications like chat apps, live notifications, and online games where instant communication is needed.

💼 Career

Knowing how to create WebSocket endpoints with FastAPI is valuable for backend developers working on interactive web applications requiring real-time data exchange.

1

Create FastAPI app instance

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

FastAPI

from fastapi import FastAPI

# Create FastAPI app instance called app
# Your code here

Hint

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

2

Import WebSocket and create endpoint

Import WebSocket from fastapi. Create a WebSocket endpoint at path /ws using @app.websocket("/ws") and define an async function websocket_endpoint that accepts a parameter named websocket of type WebSocket.

FastAPI

from fastapi import FastAPI, WebSocket

app = FastAPI()

# Create WebSocket endpoint at /ws
# Your code here

Hint

Use @app.websocket("/ws") decorator and define an async function with websocket: WebSocket parameter.

3

Accept connection and receive message

Inside websocket_endpoint, accept the WebSocket connection using await websocket.accept(). Then receive a text message from the client using await websocket.receive_text() and store it in a variable called data.

FastAPI

from fastapi import FastAPI, WebSocket

app = FastAPI()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    # Accept the connection
    # Receive a text message and store in data
    # Your code here

Hint

Use await websocket.accept() to accept connection and data = await websocket.receive_text() to get the message.

4

Send echo message and close connection

Send back the received message stored in data to the client using await websocket.send_text(data). Then close the WebSocket connection with await websocket.close().

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()
    # Send back the message
    # Close the connection
    # Your code here

Hint

Use await websocket.send_text(data) to send the message and await websocket.close() to close connection.

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