WebSocket authentication in FastAPI - Step-by-Step Execution

Concept Flow - WebSocket authentication

Client connects WebSocket

↓

Server receives connection

↓

Server checks auth token

↓

Accept connection

↓

Start message handling

The server accepts a WebSocket connection, checks the client's authentication token, and either accepts or rejects the connection based on validity.

Execution Sample

FastAPI

from fastapi import FastAPI, WebSocket, WebSocketDisconnect
app = FastAPI()

@app.websocket('/ws')
async def websocket_endpoint(websocket: WebSocket):
    token = websocket.headers.get('Authorization')
    if token != 'valid-token':
        await websocket.close()
        return
    await websocket.accept()
    await websocket.send_text('Welcome!')

This code accepts a WebSocket connection only if the Authorization header matches 'valid-token'; otherwise, it closes the connection.

Execution Table

Step	Action	Auth Token	Condition	Result	Connection State	Message Sent
1	Client connects	Authorization header sent: 'valid-token'	token == 'valid-token'?	True	Connection accepted	None
2	Server accepts connection	valid-token	N/A	N/A	Connected	None
3	Server sends welcome message	valid-token	N/A	N/A	Connected	'Welcome!'
4	Client receives message	valid-token	N/A	N/A	Connected	'Welcome!'
5	Connection remains open	valid-token	N/A	N/A	Connected	None
6	Client disconnects	valid-token	N/A	N/A	Disconnected	None

💡 Connection closes only if token is invalid; here token is valid, so connection stays open.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
token	None	'valid-token'	'valid-token'	'valid-token'	'valid-token'
Connection State	Disconnected	Connecting	Connected	Connected	Disconnected
Message Sent	None	None	None	'Welcome!'	None

Key Moments - 2 Insights

Why does the server close the connection if the token is invalid?

Because the condition token == 'valid-token' fails (see execution_table step 1), the server calls websocket.close() to reject unauthorized clients.

When does the server send the welcome message?

Only after accepting the connection (execution_table step 2), the server sends the welcome message (step 3). Sending before accept would cause an error.

Visual Quiz - 3 Questions

Look at the execution_table at step 1. What is the value of the auth token?

A None

B 'valid-token'

C 'invalid-token'

D 'Authorization'

💡 Hint

Check the 'Auth Token' column at step 1 in the execution_table.

At which step does the server accept the WebSocket connection?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Connection State' column in execution_table to see when it changes to 'Connected'.

If the token was invalid, what would happen at step 1?

A Connection closed immediately

B Connection accepted but no message sent

C Connection accepted and welcome message sent

D Server waits for client message

💡 Hint

Refer to the concept_flow where invalid token leads to connection rejection.

Concept Snapshot

WebSocket authentication in FastAPI:
- Client sends token in headers on connect
- Server checks token before accepting
- If valid, call websocket.accept() and proceed
- If invalid, call websocket.close() to reject
- Send messages only after accept
- Keep connection open for authorized clients

Full Transcript

This example shows how FastAPI handles WebSocket authentication. When a client connects, the server reads the Authorization header token. If the token matches the expected value, the server accepts the connection and sends a welcome message. If the token is invalid, the server closes the connection immediately. This ensures only authorized clients can keep the WebSocket open. The execution table traces each step: connection attempt, token check, accept or close, and message sending. Variables like token and connection state update accordingly. Key moments clarify why the server closes unauthorized connections and when messages can be sent. The visual quiz tests understanding of token values, connection acceptance timing, and behavior on invalid tokens.

Practice

1. What is the main purpose of WebSocket authentication in FastAPI?

easy

A. To speed up the WebSocket connection process

B. To confirm the user's identity before allowing the WebSocket connection

C. To encrypt the WebSocket messages automatically

D. To log all WebSocket messages for debugging

Solution

1. Step 1: Understand WebSocket authentication role

   Authentication ensures only authorized users can connect to the WebSocket.

2. Step 2: Identify the main goal in FastAPI context

   FastAPI uses authentication to confirm user identity before opening the connection.

3. Final Answer:

   To confirm the user's identity before allowing the WebSocket connection -> Option B

4. Quick Check:

   Authentication = Confirm identity [OK]

Hint: Authentication means confirming user identity before connection [OK]

Common Mistakes:

• Confusing authentication with encryption
• Thinking authentication speeds up connection
• Assuming authentication logs messages

2. Which of the following is the correct way to accept a WebSocket connection with token authentication in FastAPI?

easy

A. await websocket.accept() without checking token

B. Call await websocket.close() before checking token

C. Use await websocket.send_text() before accepting

D. Check token, then call await websocket.accept() if valid

Solution

1. Step 1: Understand WebSocket connection flow

   You must check the token first to decide if connection is allowed.

2. Step 2: Accept connection only if token is valid

   Call await websocket.accept() only after confirming token validity.

3. Final Answer:

   Check token, then call await websocket.accept() if valid -> Option D

4. Quick Check:

   Accept after token check = C [OK]

Hint: Accept connection only after validating token [OK]

Common Mistakes:

• Accepting connection before token check
• Closing connection before checking token
• Sending messages before accepting connection

3. Given this FastAPI WebSocket code snippet, what will happen if the token is invalid?

async def websocket_endpoint(websocket: WebSocket):
    token = websocket.query_params.get('token')
    if token != 'secret123':
        await websocket.close(code=1008)
    else:
        await websocket.accept()
        await websocket.send_text('Welcome!')

medium

A. The connection closes immediately with code 1008

B. The connection accepts and sends 'Welcome!' anyway

C. The server raises a runtime error

D. The connection stays open but no message is sent

Solution

1. Step 1: Check token validation logic

   If token is not 'secret123', the code calls await websocket.close(code=1008).

2. Step 2: Understand WebSocket close behavior

   Calling close immediately ends the connection with the given code.

3. Final Answer:

   The connection closes immediately with code 1008 -> Option A

4. Quick Check:

   Invalid token triggers close(1008) [OK]

Hint: Invalid token triggers immediate close with code 1008 [OK]

Common Mistakes:

• Assuming connection accepts anyway
• Expecting a runtime error
• Thinking connection stays open silently

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

async def websocket_endpoint(websocket: WebSocket):
    token = websocket.headers.get('Authorization')
    if token != 'Bearer secret123':
        await websocket.accept()
        await websocket.send_text('Unauthorized')
        await websocket.close()
    else:
        await websocket.accept()
        await websocket.send_text('Welcome')

medium

A. Using headers.get instead of query_params.get

B. Not closing connection on invalid token

C. Accepting connection before sending 'Unauthorized' message

D. Missing await before websocket.close()

Solution

1. Step 1: Analyze connection flow on invalid token

   The code calls await websocket.accept() before sending 'Unauthorized' and closing.

2. Step 2: Understand best practice for unauthorized access

   It is better to close connection immediately without accepting it to avoid opening unauthorized connection.

3. Final Answer:

   Accepting connection before sending 'Unauthorized' message -> Option C

4. Quick Check:

   Unauthorized should close without accept [OK]

Hint: Do not accept connection before rejecting unauthorized users [OK]

Common Mistakes:

• Accepting connection before rejecting
• Ignoring connection close on invalid token
• Confusing headers and query parameters

5. You want to authenticate WebSocket connections in FastAPI using a token passed as a query parameter. Which approach correctly handles authentication and rejects unauthorized users cleanly?

hard

A. Check token from query params; if invalid, call await websocket.close(1008) before accept; else accept connection

B. Accept connection first, then check token; if invalid, send 'Unauthorized' message and close

C. Ignore token and accept all connections; handle authorization in message handlers

D. Check token in headers only; ignore query parameters

Solution

1. Step 1: Understand token location and validation

   Token is passed as query parameter, so check websocket.query_params for token.

2. Step 2: Handle unauthorized users before accepting connection

   If token is invalid, close connection immediately with code 1008 to reject cleanly.

3. Step 3: Accept connection only if token is valid

   Only call await websocket.accept() after confirming token validity.

4. Final Answer:

   Check token from query params; if invalid, call await websocket.close(1008) before accept; else accept connection -> Option A

5. Quick Check:

   Reject before accept with close(1008) = A [OK]

Hint: Reject unauthorized before accept using close(1008) [OK]

Common Mistakes:

• Accepting connection before token check
• Ignoring query parameters for token
• Handling authorization after connection open