Building a Simple API with FastAPI (Python & Backend Focus)

March 1, 2025

·

FastAPI has gained popularity as one of the fastest and most efficient web frameworks for building APIs with Python. Designed with speed and developer productivity in mind, FastAPI simplifies API development while ensuring high performance. In this guide, we’ll walk through the process of building a simple API with FastAPI, covering installation, routing, request handling, and data validation.

Why Choose FastAPI for API Development?

FastAPI is an excellent choice for backend developers who need a fast, easy-to-use, and well-documented framework. Some of its key features include:

High performance (thanks to Starlette and Pydantic)
Automatic interactive documentation (Swagger UI & ReDoc)
Type hinting for better code quality
Asynchronous support for improved scalability
Built-in data validation with Pydantic models

Step 1: Install FastAPI and Uvicorn

Before building our API, we need to install FastAPI and an ASGI server such as Uvicorn to run the application. Run the following command:

pip install fastapi uvicorn

Step 2: Create a Basic FastAPI Application

Now, let’s create a simple FastAPI app. Save the following code in a file named main.py:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def home():
    return {"message": "Welcome to FastAPI!"}

This defines a FastAPI app with a single GET endpoint at / that returns a JSON response.

Step 3: Run the FastAPI Server

Run the application using Uvicorn:

uvicorn main:app --reload

Open your browser and go to http://127.0.0.1:8000/
You should see the JSON response: {"message": "Welcome to FastAPI!"}

Bonus: Auto-Generated API Docs

FastAPI automatically generates interactive API documentation. Check them out at:

Swagger UI: http://127.0.0.1:8000/docs
ReDoc: http://127.0.0.1:8000/redoc

Step 4: Create API Endpoints

Let’s add more endpoints to handle CRUD operations. In this example, we’ll build a simple todo API.

Define a Data Model

FastAPI uses Pydantic for data validation. Let’s create a model for our todos:

from pydantic import BaseModel
from typing import List

class Todo(BaseModel):
    id: int
    title: str
    completed: bool

Create API Routes

Now, we add routes to handle CRUD operations:

todos = []

@app.post("/todos/")
def create_todo(todo: Todo):
    todos.append(todo)
    return {"message": "Todo added successfully!"}

@app.get("/todos/", response_model=List[Todo])
def get_todos():
    return todos

@app.get("/todos/{todo_id}")
def get_todo(todo_id: int):
    for todo in todos:
        if todo.id == todo_id:
            return todo
    return {"error": "Todo not found"}

@app.put("/todos/{todo_id}")
def update_todo(todo_id: int, updated_todo: Todo):
    for index, todo in enumerate(todos):
        if todo.id == todo_id:
            todos[index] = updated_todo
            return {"message": "Todo updated successfully"}
    return {"error": "Todo not found"}

@app.delete("/todos/{todo_id}")
def delete_todo(todo_id: int):
    global todos
    todos = [todo for todo in todos if todo.id != todo_id]
    return {"message": "Todo deleted successfully"}

Step 5: Testing Your API

You can test your API using:

curl -X POST "http://127.0.0.1:8000/todos/" -H "Content-Type: application/json" -d '{"id": 1, "title": "Learn FastAPI", "completed": false}'

Step 6: Adding Async Support (Optional)

To make the API even more scalable, use async functions:

@app.get("/async-example/")
async def async_route():
    return {"message": "This is an async endpoint"}

Top Picks for FastAPI Development

Looking to enhance your FastAPI development experience? Check out these must-have tools:

🔥 Best Books for Python Backend Development → Check on Amazon
🚀 Top FastAPI Learning Resources → See Books on Amazon
💡 Best Laptops for Python Development → Find on Amazon

Final Thoughts

Building APIs with FastAPI is quick, efficient, and scalable. By following this guide, you’ve set up a working FastAPI application with CRUD operations, data validation, and asynchronous support.

If you enjoyed this tutorial, consider subscribing to our newsletter for more Python and backend development tips!

Key Takeaways

✅ FastAPI is a high-performance framework ideal for modern backend development.
✅ Built-in validation with Pydantic ensures data integrity.
✅ Interactive API documentation makes testing easy.
✅ Asynchronous support helps handle high-traffic applications efficiently.

Thank you for reading, Leave a comment and see you on the next post.

4DEVbyDEV