FastAPI 101: A Comprehensive Tutorial for Building Lightning-Fast APIs

Build your first API using Python’s lightning-fast framework — FastAPI

Photo by Chris Ried on Unsplash

Intro

If you’re a developer looking to build blazing-fast APIs with Python, then you’ve come to the right place! In this tutorial, we’ll be exploring FastAPI, a modern, fast (yes, it’s in the name!), simplistic, and highly efficient web framework for building APIs with Python.

What is FastAPI?

FastAPI is a relatively new web framework for building APIs in Python. It’s built on top of the fast ASGI (Asynchronous Server Gateway Interface) server, and the powerful Pydantic library for data validation and serialization.

Why FastAPI?

There are several reasons why FastAPI has become so popular among developers:

- Fast— As the name suggests, FastAPI is really fast! It’s built on top of the Starlette framework, which is an asynchronous framework that is highly optimized for performance.
- Easy to use — FastAPI is designed to be easy to use, with a simple and intuitive API that makes it easy to build high-performance APIs.
- Type annotations — FastAPI uses type annotations to define the structure of your data, making it easy to validate and serialize data in your API.
- API documentation — FastAPI automatically generates documentation for your API based on your code, making it easy to understand and use.
- Modern features — FastAPI supports many modern features of Python 3.7+, including async/await, type annotations, and data classes.

Setting up FastAPI

Before we dive into building our API, we need to install FastAPI and a few other dependencies. FastAPI does not only provide fast APIs, but it is also easy and fast to set up. Open up your terminal and run the following commands:

pip install fastapi uvicorn[standard]

This will install FastAPI and uvicorn, a lightning-fast ASGI server.

Building our API

Now that we have FastAPI installed, let’s start building our API! We’ll start by creating a new Python file called main.py. In this file, we’ll import FastAPI and create a new instance of the FastAPI class:

from fastapi import FastAPI
app = FastAPI()

Defining a route

Now let’s define a route for our API. We’ll create a simple endpoint that returns a JSON response when we visit it in our browser. Add the following code to your main.py file:

@app.get("/")
def read_root():
    return {"Hello": "World"}

This creates a new route using the @app.get decorator. The `read_root` function returns a JSON response with a “Hello World” message. Note that the get in @app.get indicates that the request is a ‘get request’.

Running our API

Now that we have our API defined, we need to run it! We’ll use uvicorn to start our server. Run the following command in your terminal:

uvicorn main:app --reload

This command starts the uvicorn server and tells it to load our main.py file and use the app instance of FastAPI. The — reload flag tells uvicorn to automatically reload the server when we make changes to our code.

Complete code

This is the complete code for our first API (with just one endpoint). And just like that in only five lines of code, we’ve created our first API using FastAPI.

## main.py
from fastapi import FastAPI
app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

Testing our API

Now that our API is running, let’s test it out! Open up your web browser and go to http://localhost:8000/. You should see a JSON response with a ‘{“Hello”: “World”}’ message.

Conclusion

In this tutorial, we’ve explored FastAPI, a modern and fast web framework for building APIs with Python. We’ve learned how to set up FastAPI, define a route, and run our API using uvicorn. With FastAPI, we can easily build high-performance APIs that are easy to use and maintain. So what are you waiting for? Go ye into the world and write some fast APIs using FastAPI :)

I will publish build-up articles on this article so kindly follow me and subscribe to the email notification service to learn more about FastAPI.