FastAPI for Beginners: Your First API Step by Step

Table of Contents

1. Prerequisites
2. Installation
3. Your First FastAPI Application
4. Understanding the Code
5. Running the Application
6. Testing the API
7. Common Practices and Best Practices
8. Conclusion
9. References

Prerequisites

Before you start, make sure you have the following installed on your system:

• Python 3.7 or higher
• A code editor (e.g., Visual Studio Code, PyCharm)

Installation

The first step is to install FastAPI and Uvicorn. Uvicorn is an ASGI server that will run our FastAPI application. You can install them using pip, the Python package manager. Open your terminal and run the following command:

pip install fastapi uvicorn

Your First FastAPI Application

Let’s create a simple “Hello, World!” API using FastAPI. Create a new Python file, for example, main.py, and add the following code:

from fastapi import FastAPI

# Create a FastAPI instance
app = FastAPI()

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

Understanding the Code

• Importing FastAPI: We import the FastAPI class from the fastapi library. This class is used to create our FastAPI application.
• Creating an Instance: We create an instance of the FastAPI class named app. This instance will be the core of our application.
• Defining a Route: We use the @app.get("/") decorator to define a route. The @app.get part indicates that this is a GET request, and the "/" is the path of the route. The function read_root is the handler for this route. It returns a dictionary, which will be automatically converted to JSON by FastAPI.

Running the Application

To run the FastAPI application, we use Uvicorn. In the terminal, navigate to the directory where your main.py file is located and run the following command:

uvicorn main:app --reload

• main is the name of the Python file (without the .py extension).
• app is the name of the FastAPI instance we created in the file.
• --reload is an optional flag that enables auto - reloading. This means that whenever you make changes to your code, the server will automatically restart.

Testing the API

Once the server is running, you can test the API in your web browser or using tools like curl or Postman.

• Using a Web Browser: Open your web browser and go to http://127.0.0.1:8000/. You should see the JSON response {"Hello": "World"}.
• Using curl: In the terminal, run the following command:

curl http://127.0.0.1:8000/

You will get the same JSON response.

Common Practices and Best Practices

Input Validation

FastAPI uses Python type hints for input validation. For example, if you want to create a route that accepts a parameter, you can do the following:

from fastapi import FastAPI

app = FastAPI()

@app.get("/items/{item_id}")
def read_item(item_id: int):
    return {"item_id": item_id}

Here, item_id is expected to be an integer. If a non - integer value is provided, FastAPI will automatically return a validation error.

Error Handling

FastAPI provides built - in error handling. You can also define custom error handlers. For example:

from fastapi import FastAPI, HTTPException

app = FastAPI()

@app.get("/items/{item_id}")
def read_item(item_id: int):
    if item_id < 0:
        raise HTTPException(status_code=400, detail="Item ID cannot be negative")
    return {"item_id": item_id}

Documentation

FastAPI automatically generates interactive API documentation. You can access it at http://127.0.0.1:8000/docs (Swagger UI) or http://127.0.0.1:8000/redoc (ReDoc). This documentation is very useful for testing and understanding your API.

Code Organization

As your application grows, it’s important to organize your code. You can use modules and routers to split your code into smaller, more manageable parts.

from fastapi import FastAPI, APIRouter

app = FastAPI()
router = APIRouter()

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

app.include_router(router)

Conclusion

FastAPI is a powerful and easy - to - use web framework for building APIs with Python. In this blog post, we walked you through the process of creating your first FastAPI application, from installation to testing. We also covered some common practices and best practices, such as input validation, error handling, documentation, and code organization. With these basics, you are well on your way to building more complex and robust APIs using FastAPI.

References

• FastAPI Documentation
• Uvicorn Documentation