8 FastAPI Tricks You Didn’t Know

Unlock the full potential of FastAPI with these lesser-known tricks and techniques. Discover advanced features and optimizations to take your API development to the next level.

Ankur Dhuriya

FastAPI, known for its simplicity and performance, offers more than meets the eye. In this blog, we delve into lesser-known yet powerful tricks that can supercharge your API development process. From WebSocket support to custom middleware, authentication, and streaming responses, these advanced techniques provide a deeper understanding of FastAPI’s capabilities. Whether you’re optimizing performance or adding real-time features, these tricks will elevate your API development to new heights. Let’s explore these hidden gems and unlock the full potential of FastAPI.

1. WebSocket Support

FastAPI provides native support for WebSocket connections, allowing you to build real-time communication features into your API. You can define WebSocket endpoints using WebSockets from fastapi.websockets, enabling bidirectional communication between clients and servers.

from fastapi import FastAPI, WebSocket 

app = FastAPI() @app.websocket("/ws") 

async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept() 
    while True: 
        data = await websocket.receive_text() 
        await websocket.send_text(f"Message text was: {data}")

2. Background Tasks

FastAPI allows you to run background tasks asynchronously using BackgroundTasks. This feature is useful for offloading time-consuming tasks from the main request-response cycle, improving the responsiveness of your API.

from fastapi import FastAPI, BackgroundTasks

app = FastAPI()

def process_data(data: str):
    # Some time-consuming task
    return data.upper()

@app.post("/submit/")
async def submit_data(background_tasks: BackgroundTasks, data: str):
    background_tasks.add_task(process_data, data)
    return {"message": "Data submitted for processing"}

3. Custom Middleware

You can create custom middleware in FastAPI to intercept and modify requests and responses before they reach your API endpoints. Middleware functions can be added using add_middleware() method of FastAPI.

from fastapi import FastAPI, Request

app = FastAPI()

async def custom_middleware(request: Request, call_next):
    # Do something before handling the request
    response = await call_next(request)
    # Do something after handling the request
    return response

app.add_middleware(custom_middleware)

4. Authentication and Authorization

FastAPI supports various authentication and authorization mechanisms, including OAuth2, JWT, and HTTP Basic/Digest authentication. You can use libraries like fastapi.security to implement secure authentication and authorization in your API.

from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer

app = FastAPI()
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

def fake_decode_token(token):
    # Placeholder for token decoding logic
    return {"username": "user", "scopes": ["read", "write"]}

async def get_current_user(token: str = Depends(oauth2_scheme)):
    user_dict = fake_decode_token(token)
    if user_dict is None:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid authentication credentials",
            headers={"WWW-Authenticate": "Bearer"},
        )
    return user_dict

@app.get("/users/me")
async def read_users_me(current_user: dict = Depends(get_current_user)):
    return current_user

5. Streaming Responses

FastAPI allows you to stream large responses efficiently using asynchronous generators. This feature is particularly useful for serving large files or continuously generated data.

from fastapi import FastAPI, Response
import asyncio

app = FastAPI()

async def generate_large_data():
    for i in range(10):
        yield f"Data chunk {i}\n"
        await asyncio.sleep(1)

@app.get("/stream")
async def stream_large_data(response: Response):
    response.headers["Content-Type"] = "text/plain"
    response.headers["Content-Disposition"] = "attachment; filename=large_data.txt"
    return generate_large_data()

6. Background Database Tasks

FastAPI allows you to execute database tasks in the background, improving the responsiveness of your API endpoints. You can use background tasks to perform tasks like database cleanup, data synchronization, or asynchronous data processing.

from fastapi import FastAPI, BackgroundTasks
from sqlalchemy import create_engine

app = FastAPI()

def cleanup_database():
    # Perform database cleanup tasks
    pass

@app.post("/cleanup/")
async def cleanup(background_tasks: BackgroundTasks):
    background_tasks.add_task(cleanup_database)
    return {"message": "Database cleanup initiated"}

7. Response Headers

You can easily add custom headers to your API responses using FastAPI. This feature is useful for setting response headers like caching directives, content type, or authentication tokens.

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    headers = {
        "X-Custom-Header": "Custom Value",
        "Cache-Control": "max-age=3600",
    }
    return {"message": "Hello, World!"}, headers

8. API Versioning

FastAPI supports API versioning out of the box, allowing you to maintain multiple versions of your API endpoints. You can specify the API version in the URL path or using custom headers, providing flexibility and backward compatibility for your API consumers.

from fastapi import FastAPI

app = FastAPI()

@app.get("/v1/items/")
async def read_items_v1():
    return {"message": "Items from API version 1"}

@app.get("/v2/items/")
async def read_items_v2():
    return {"message": "Items from API version 2"}

For developers aiming to create high-performance APIs with more features, these advanced FastAPI tips present an abundance of options. Modern applications require strong and feature-rich APIs, which can be created by utilising WebSocket support, bespoke middleware, authentication techniques, and streaming replies. Using these approaches in your FastAPI projects will not only speed up development but also lead to more creative solutions and smooth user interfaces.

Reference

1. FastAPI Official Documentation: https://fastapi.tiangolo.com/
2. FastAPI GitHub Repository: https://github.com/tiangolo/fastapi
3. FastAPI Security Documentation: https://fastapi.tiangolo.com/tutorial/security/

Feel free to connect with me on LinkedIn.