Skip to content
CS Notes

FastAPI Overview

FastAPI is a modern Python framework that helps you build APIs quickly and with great performance. It is built using two other tools - Starlette (which handles the web side of things) and Pydantic (which checks and validates data). FastAPI is made to be simple to use, and it gets its great speed from Python’s async features (a way of handling many tasks at once without waiting around).

Unlike Django, FastAPI does not come with everything built in (this is sometimes called a “batteries-included” framework). Instead, it gives you the basic tools needed to build APIs, and lets you choose the libraries and structure that work best for your project.

Prerequisites

Section titled “Prerequisites”

Before you start learning FastAPI, it helps to already know a few basic things:

  • Python: FastAPI uses Python type hints a lot (this means writing the expected data type along with your variables), along with async programming and object-oriented programming (OOP). You should be comfortable with Python basics before starting.
  • Web Development: It helps to understand HTTP methods (like GET and POST), how requests and responses work, REST APIs, JSON, and basic HTML, CSS, and JavaScript.
  • Databases: You should know some SQL, how relational databases work, and basic database design, since most API-based apps need to store and manage data.
  • Async Programming: It is a good idea to know about async/await (a way to run tasks without blocking other tasks), since FastAPI heavily supports this kind of programming.

Quick Recap: What is an API?

Section titled “Quick Recap: What is an API?”

Before going further, let’s quickly cover what an API actually is, in simple words.

An API (Application Programming Interface) is basically a way for two programs to talk to each other. For example, when you open a weather app on your phone, the app sends a request to a server somewhere, asking for today’s weather. The server sends back a response with the weather details. That whole exchange happens through an API.

In web development, this usually works over HTTP (the same protocol your browser uses to load websites). Your frontend (the part users see, like a website or app) sends a request to the backend (the server), and the backend sends back a response - usually in a format called JSON (a simple way to organize data using key-value pairs).

FastAPI is a tool that helps you build this backend part - the API - using Python, in a fast and simple way.

What is FastAPI?

Section titled “What is FastAPI?”

FastAPI is a modern Python framework made specifically for building APIs. It uses Python type hints to automatically check your data, format it correctly, create documentation, and even help your code editor give you better suggestions.

FastAPI also creates interactive documentation for your API on its own, using tools called Swagger UI and ReDoc. This makes it easy to test and explore your API while you are still building it.

Key Features of FastAPI

Section titled “Key Features of FastAPI”

  1. High Performance: FastAPI is one of the fastest Python frameworks around. This is because it is built on ASGI (a modern way to run Python web apps) and fully supports async programming.

  2. Automatic Data Validation: FastAPI uses Pydantic models to check that incoming request data is correct, and to format the data it sends back in responses.

  3. Automatic API Documentation: FastAPI builds interactive documentation for your API on its own, following the OpenAPI standard.

  4. Dependency Injection: FastAPI has a strong dependency injection system (a way to share common logic across your code) that makes things like authentication, database sessions, and reusable logic much easier to manage.

  5. Async Support: FastAPI naturally supports async programming, which helps it handle many requests at the same time without slowing down.

  6. Type Safety: Because FastAPI uses Python type hints, it helps you write code faster and catch mistakes before they cause problems while the app is running.

  7. Flexible Architecture: You get to choose your own ORM (a tool for working with databases), authentication system, caching method, and background task tool - FastAPI does not force you to use specific ones.

Why Use FastAPI?

Section titled “Why Use FastAPI?”

There are many good reasons to choose FastAPI for building APIs:

  • Performance: For most API tasks, FastAPI performs almost as well as Node.js and Go.
  • Developer Experience: Features like automatic documentation, data validation, and type checking make development faster and easier.
  • Scalability: FastAPI works well whether you are building a small API or a large system spread across many servers.
  • Modern Python Features: FastAPI fully supports type hints, async programming, and the latest Python standards.
  • Microservices Friendly: Because it is lightweight, FastAPI is a great choice for building microservices (small, independent services that work together).
  • AI and ML Integration: FastAPI is often used to turn machine learning and AI models into usable APIs.

Where Not to Use FastAPI?

Section titled “Where Not to Use FastAPI?”

FastAPI is powerful, but it is not always the right tool for every job. Here are some cases where it might not be the best fit:

  • Admin-Heavy Applications: FastAPI does not come with a ready-made admin panel like Django does (Django Admin).
  • Content Management Systems: If your project needs a lot of content management features, Django might be a better choice.
  • Rapid CRUD Applications: Since Django comes with a lot of features built in already, it can help you build traditional web apps faster.
  • Apps That Need Built-In Authentication and Permissions: FastAPI does not include these features by default, so you will need to add them using outside libraries.
  • Server-Rendered Websites: You can build these with FastAPI, but it is mainly designed for building APIs, not full websites rendered on the server.

Roadmap of FastAPI

Section titled “Roadmap of FastAPI”

  1. FastAPI Fundamentals: Learn the basic concepts you need to start building APIs.

    1. Project Setup: Learn about UV, virtual environments, how to structure your project, and how to manage dependencies (the external packages your project needs).

    2. Building a Web Server: Learn how FastAPI apps work, what path operations are, and how requests are handled.

    3. Path Parameters: Learn how to grab values directly from a URL and check that they are correct.

    4. Query Parameters: Learn how to filter, search, and use optional extra values added to a URL.

    5. Request and Response Models: Learn how to use Pydantic models to check incoming data and format outgoing data.

    6. Headers and Cookies: Learn how to read and change HTTP headers and cookies.

    7. Routers: Learn how to organize your API endpoints into separate, reusable files using APIRouter.

    8. Dependency Injection: Learn how FastAPI’s dependency system works, and how to create dependencies you can reuse.

  2. Database Development: Learn how to build apps that save and store data using databases.

    1. SQLModel Fundamentals: Learn how to create SQLModel models, fields, and relationships between them.

    2. Database Configuration: Learn how to set up databases like PostgreSQL, MySQL, or SQLite.

    3. Async Database Access: Learn how to use async database sessions and engines (the tools that connect your app to the database).

    4. Lifespan Events: Learn how to handle opening and closing database connections when your app starts and stops.

    5. Database Models: Learn how to design and build the data models for your app.

    6. CRUD Operations: Learn how to Create, Read, Update, and Delete data (this is called CRUD).

    7. Service Layer Architecture: Learn how to keep your business logic separate and reusable by using service classes.

    8. Database Relationships: Learn about One-to-One, One-to-Many, and Many-to-Many relationships between data.

  3. Authentication & Authorization: Learn how to keep your APIs safe and secure.

    1. User Models: Learn how to build models for user accounts and login systems.

    2. Password Hashing: Learn how to keep passwords safe using tools like Passlib and bcrypt.

    3. JWT Authentication: Learn about access tokens and refresh tokens (these help keep users logged in safely).

    4. Bearer Authentication: Learn how to set up HTTP Bearer authentication.

    5. Token Revocation: Learn how to block (blacklist) tokens using Redis when needed.

    6. Current User Dependencies: Learn how to get the logged-in user’s details inside your endpoints.

    7. Role-Based Access Control (RBAC): Learn how to set up permissions based on user roles.

    8. Authorization Dependencies: Learn how to build reusable checks for permissions.

  4. Database Migrations: Learn how to handle changes to your database structure over time.

    1. Alembic Fundamentals: Learn the basics of how migrations work.

    2. Migration Generation: Learn how to automatically create migrations when you change your models.

    3. Migration Management: Learn how to safely move your database forward or back to different versions.

  5. Error Handling & Middleware: Learn how to build APIs that are ready for real-world use.

    1. HTTP Exceptions: Learn how to handle common errors in your API.

    2. Custom Exceptions: Learn how to create your own reusable error classes.

    3. Exception Handlers: Learn how to manage all your app’s errors in one place.

    4. Logging Middleware: Learn how to keep track of (log) incoming requests and outgoing responses.

    5. Custom Middleware: Learn how to build your own ASGI middleware (code that runs before or after each request).

    6. CORS Middleware: Learn how to set up Cross-Origin Resource Sharing (CORS), which controls which websites are allowed to talk to your API.

    7. Trusted Hosts: Learn how to protect your app from host header attacks.

  6. Email & Account Management: Learn how to add features for managing user accounts.

    1. FastAPI-Mail Setup: Learn how to set up an email service for your app.

    2. Sending Emails: Learn how to send emails for things like notifications and updates.

    3. Account Verification: Learn how to check and confirm a user’s email address.

    4. Password Resets: Learn how to let users reset their password if they forget it.

  7. Background Processing: Learn how to run tasks separately, without making the user wait for a response.

    1. Background Tasks: Learn how to use FastAPI’s built-in BackgroundTasks feature.

    2. Celery Integration: Learn how to use Celery together with Redis to run tasks across multiple workers.

    3. Task Monitoring: Learn how to keep an eye on your background workers using a tool called Flower.

    4. Production Workloads: Learn how to handle things like emails, reports, and long-running jobs in a real app.

  8. Testing & Documentation: Learn how to make sure your API works well and is reliable.

    1. Swagger UI: Learn how to explore and test your API using its interactive documentation.

    2. ReDoc: Learn how to create clean, professional-looking API reference documentation.

    3. Unit Testing: Learn how to test your app’s logic using Pytest.

    4. API Testing: Learn how to test your API endpoints using FastAPI’s TestClient.

    5. Mocking: Learn how to use unittest.mock to test parts of your code on their own.

    6. Contract Testing: Learn how to check your API’s structure using a tool called Schemathesis.

  9. Production & Deployment: Learn how to take your app live for real users.

    1. Settings Management: Learn how to manage environment variables using Pydantic Settings.

    2. Logging & Monitoring: Learn how to set up proper logging and monitor your app.

    3. Containerization: Learn how to package your app using Docker.

    4. ASGI Servers: Learn how to deploy your app using Uvicorn and Gunicorn.

    5. Reverse Proxies: Learn how to set up Nginx or Caddy in front of your app.

    6. Cloud Deployment: Learn how to deploy your app to platforms like Render, Railway, AWS, DigitalOcean, or Fly.io.

Setup and Installation

Section titled “Setup and Installation”

To start using FastAPI, you first need to set up your development environment. Follow these steps to install FastAPI and create your first project:

  1. Install UV: UV is a fast, modern tool for managing Python packages. It makes handling dependencies and virtual environments much simpler.

    Terminal window
    scoop install main/uv

  2. Initialize UV Project: Create a new folder and set up your project inside it.

    Terminal window
    uv init

  3. Install FastAPI:

    Terminal window
    uv add fastapi

  4. Install Uvicorn:

    Terminal window
    uv add uvicorn

  5. Create Your First Application:

    from fastapi import FastAPI
    

    app = FastAPI()
    

    @app.get("/")
    async def root():
        return {"message": "Hello FastAPI"}

  6. Run Development Server:

    Terminal window
    uv run fastapi dev

  7. Access the Application:

    Open your browser and go to:

    If everything was set up correctly, you should see your API’s response, along with documentation that was created automatically.