DEV Community

Cover image for Developing high-performing applications with Python’s FastAPI
Abto Software
Abto Software

Posted on • Updated on

Developing high-performing applications with Python’s FastAPI

Python is extremely popular among professionals, and used all over the globe. It is an object-oriented programming language with a dynamic semantic.

But what makes this programming language that popular?

FastAPI is one of the reasons.

According to the findings of JetBrains, web development is one of the programming language’s most popular use cases.

Image description

Python is mostly chosen for developing web apps because of its many additional libraries, helpful frameworks, and simplicity.

Python’s FastAPI in brief

Let’s look closer at one of the fastest Python web frameworks available.

Combining Python and FastAPI leads to amazing results and chances to develop fast websites. FastAPI is a modern, fast (high-performant), web framework with built-in support for async endpoints for building APIs with Python 3.6+ based on standard Python-type hints.

FastAPI was developed by Sebastián Ramírez. First stable release was on December 5, 2018 and the last one on May 10, 2022.

It was written in Python, and last year FastAPI was recognized as the third most loved web framework in Stack Overflow 2021 Developer Survey.

Image description

It is used by large companies like Uber and Netflix to develop some of their applications.

The benefits of using Python’s FastAPI

FastAPI gives the following benefits:

  1. Open standards FastAPI is based on open standards such as OpenAPI for API creation, including declarations of path operations, body requests, parameters, security, and more.
  2. Interactive documentation Interactive API documentation and exploration web user interfaces. Two included by default: Swagger UI, ReDoc.
  3. Standard Python It’s all based on standard Python 3.6 type declarations. No new syntax to learn. Just standard modern Python.
  4. Editor support: auto-completion works everywhere
  5. FastAPI is Short It has sensible defaults for everything, with optional configurations everywhere. All the parameters can be fine-tuned to do what you need and to define the API you need.
  6. Validation FastAPI uses Python type annotations. So you get it out-of-the-box with no need to use additional layer for validation.
  7. Security and authentication integrated HTTP Basic, OAuth2 (also with JWT tokens), API keys in Headers, Query parameters, Cookies, etc.
  8. Dependency Injection FastAPI comes with its own built-in dependency injection system that helps to integrate components when building your API.
  9. Unlimited plugin support
  10. FastAPI is thoroughly tested

How to work with Python’s FastAPI?

Check it out with the following examples.

The installation
The first step is to install base packages we are going to work with:
pip install fastapi uvicorn[standard]

Creating a base class
Let’s create a class for FastAPIServer:

from fastapi import FastAPI   

from hypercorn.asyncio import serve

from hypercorn.config import Config as HyperCornConfig

from application.actions.action_handler import ActionHandler

class FastAPIServer:

    def __init__(self, action_handler: ActionHandler):

        self._hypercorn_config = HyperCornConfig()

        self._fastapi = FastAPI()

        self._ action_handler =  action_handler

    async def run_server(self):

        self._hypercorn_config.bind = ['']


       await serve(self._fastapi, self._hypercorn_config)

    def add_routes(self):

        self._fastapi.add_api_route(path="/", endpoint=self.say_hello, methods=["GET"])
Enter fullscreen mode Exit fullscreen mode

Dependency injection
Add ‘say_hello’ function with authentication to the FastAPIServer:

from import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/login")
Enter fullscreen mode Exit fullscreen mode

You should add the path operation function and mount it to the path /api/login/.
Also we can add HTTPException and raise it from the endpoint:

from fastapi import HTTPException

credentials_exception = HTTPException(


    detail="Could not validate credentials",

    headers={"WWW-Authenticate": "Bearer"},

Enter fullscreen mode Exit fullscreen mode
from fastapi import Depends


async def say_hello(self, token: str = Depends(oauth2_scheme)):    

    current_user = await self.get_current_user(token)

    if current_user is False:

        raise self.credentials_exception
Enter fullscreen mode Exit fullscreen mode

Dependency injection is very useful when you need to have shared logic (the same code logic again and again); share database connections; enforce security, authentication (as shown in the example), role requirements, etc.

Path and Query parameters
You can mount a few endpoints to the same path by using additional parameters.

For example:

self._fastapi.add_api_route(path="/profiles", endpoint=self.get_profiles_list, methods=["GET"])

    self._fastapi.add_api_route(path="/profiles/me", endpoint=self.get_my_profile, methods=["GET"])

    self._fastapi.add_api_route(path="/profiles/{user_id}", endpoint=self.get_user_profile, methods=["GET"])
Enter fullscreen mode Exit fullscreen mode

Path operations are evaluated in order, so if you put “/profiles/{user_id}” above “/profiles/me”, me will be tracked as user_id.

user_id is called path parameters. It can be declared with type or without it:

async def get_user_profile(self, user_id: int):    


async def get_user_profile(self, user_id):

Enter fullscreen mode Exit fullscreen mode

As a parameter type can be used any of standard Python types or Pydantic types.

Except path parameters you can use Query parameter. Take a look:

from fastapi import Query


async def get_profiles_list(


    search_text: str = Query(None, alias='search-text')



Enter fullscreen mode Exit fullscreen mode

Adding CORSMiddleware
If your back-end server and web are running on the different ‘origins’ you should add CORS (Cross-Origin Resource Sharing) to your FastAPI server. It can be done by using middleware which is also supported by FastAPI.

from fastapi.middleware.cors import CORSMiddleware








Enter fullscreen mode Exit fullscreen mode

Why choose Python’s FastAPI?

FastAPI is the best solution for developing web applications using third-party inside path operation function, or for applications with microservices’ architecture. Such an API will be very fast because when your app receives the request and starts processing it in the microservice, or by passing data to some other API, it should wait for a response. Asynchronous supports the processing of other requests during the time when the system is waiting for a response.

Our team at Abto Software utilizes Python software development for fast prototyping and building highly scalable web applications. Fullstack Python web development services and client-server programming & administration are what we do on a daily basis.

To name:

  • Data science
  • Big data analysis solutions
  • High-load web portals
  • Data-driven ERP systems
  • Cloud-based solutions
  • APIs and automation plugins and more.

Top comments (5)

dendihandian profile image
Dendi Handian • Edited

you can highlight all python scripts syntaxes in this post by following

it simply to put py after the triple quote opening

abtosoftware profile image
Abto Software

tnanks! done!)

dendihandian profile image
Dendi Handian


chrisgreening profile image
Chris Greening

Thanks for sharing! I've been looking to try out some FastAPI for a couple months now - maybe this is the excuse I needed to finally jump into it :~)

abtosoftware profile image
Abto Software

Thanks for your comment! FastAPI is pretty awesome :)