Background Tasks in FastAPI (Async & Non-Blocking Operations)

 

Introduction

In real-world applications, some tasks:

  • Take time
  • Don’t need immediate response
  • Should run in the background

Examples:

  • Sending emails
  • Logging activity
  • Processing files

FastAPI provides a simple way to handle this using Background Tasks.

What are Background Tasks?

Background tasks are operations that:

  • Run after returning a response
  • Do not block the main request
  • Improve API performance

Without Background Tasks

@app.post("/send-email")
def send_email():
    # takes 5 seconds
    time.sleep(5)
    return {"message": "Email sent"}

Problem:

  • User waits 5 seconds
  • API becomes slow

With Background Tasks

from fastapi import BackgroundTasks, FastAPI

app = FastAPI()

def send_email_task(email: str):
    import time
    time.sleep(5)
    print(f"Email sent to {email}")

@app.post("/send-email/")
def send_email(email: str, background_tasks: BackgroundTasks):
    background_tasks.add_task(send_email_task, email)
    return {"message": "Email is being sent"}

Response is instant .Task runs in background.

How It Works

  1. Request comes in.
  2. FastAPI returns response immediately.
  3. Background task runs after response

Real-World Example: User Registration

def send_welcome_email(email: str):
    print(f"Welcome email sent to {email}")

@app.post("/register/")
def register_user(email: str, background_tasks: BackgroundTasks):
    # Save user (DB logic here)
    
    background_tasks.add_task(send_welcome_email, email)

    return {"message": "User registered successfully"}

Multiple Background Tasks
def task1():
    print("Task 1 done")

def task2():
    print("Task 2 done")

@app.get("/tasks/")
def run_tasks(background_tasks: BackgroundTasks):
    background_tasks.add_task(task1)
    background_tasks.add_task(task2)
    return {"message": "Tasks running"}

When to Use Background Tasks
    1.Sending emails
    2.Logging activity
    3.Notifications
    4.Small async jobs
Limitations
BackgroundTasks is not suitable for:
    1.Heavy processing (ML, video processing)
    2.Long-running jobs
    3.Distributed systems
For these, use:
  • Celery

  • Redis

  • RabbitMQ
Best Practices
    1.Keep tasks lightweight
    2.Avoid blocking operations
    3.Use proper logging
    4.Move heavy jobs to task queues
Common Mistakes
    1.Running heavy logic in background tasks
    2.Assuming tasks run in parallel (they don’t scale like Celery)
    3.Not handling failures
Key Takeaways
  • Background tasks improve API performance

  • They run after sending response

  • Ideal for non-critical operations

  • Not suitable for heavy workloads

Comments

Post a Comment

Popular posts from this blog

Database Integration in FastAPI (SQLAlchemy CRUD)

  Introduction So far, we’ve built APIs without storing data.But real-world applications need a database to: Store user data. Manage products. Persist application state. In this blog, we’ll connect FastAPI with a database using SQLAlchemy and perform CRUD operations . What is SQLAlchemy? SQLAlchemy is a powerful Python ORM (Object Relational Mapper) that allows you to: Interact with databases using Python code. Avoid writing raw SQL queries. Work with models instead of tables. Step 1: Install Dependencies pip install sqlalchemy (For SQLite, no extra driver needed) Project Structure Update app/ ├── main.py ├── database/ │ ├── connection.py ├── models/ │ ├── item.py ├── schemas/ │ ├── item.py ├── routes/ │ ├── item.py Step 2: Database Connection app/database/connection.py from sqlalchemy import create_engine from sqlalchemy . orm import sessionmaker , declarative_base DATABASE_URL = "sqlite:///./test.db" engine = create_engine ( DAT...
Read more

Middleware & CORS in FastAPI

  Introduction As your API grows, you may need to: Log requests Modify responses Handle cross-origin requests This is where Middleware and CORS (Cross-Origin Resource Sharing) come into play.They help control how requests and responses flow through your application. What is Middleware? Middleware is a function that runs: Before a request reaches your route After a response is returned Think of it as a pipeline layer between client and server. Request Flow with Middleware Client → Middleware → Route → Middleware → Response Creating Custom Middleware from fastapi import FastAPI , Request import time app = FastAPI () @ app . middleware ( "http" ) async def log_requests ( request : Request , call_next ): start_time = time . time() response = await call_next ( request ) process_time = time . time() - start_time print ( f"Request: { request . url} | Time: { process_time } " ) return response What This Middle...
Read more

Python Data Handling

Python Data Handling for Beginners In Python, data handling means storing, changing, and using data in different ways. In this post, you will learn: Lists Tuples Dictionaries Sets String Methods Type Conversion 1. Python Lists :Lists store many values in one variable.                fruits = ["apple", "banana", "mango"]                                                                       Method                          Use                                            append()          ...
Read more