Building a RESTful API in Python (In-Memory Data)

Matthew

In today’s software world, RESTful APIs are the backbone of most modern applications — from mobile apps and web frontends to microservices.
If you’re a Python developer, the good news is: building APIs is easier than you think.

In this post, we’ll break down what a RESTful API is, and show you how to build one in Python using FastAPI, one of the most modern and efficient frameworks available.

🚀 What Is a RESTful API?

REST (Representational State Transfer) is an architectural style that defines how systems communicate over HTTP.

In a RESTful API:

  • Resources (like users or posts) are represented by URLs.
  • Each HTTP method performs a specific action: MethodActionExampleGETRetrieve data/usersPOSTCreate new data/usersPUTUpdate data/users/1DELETEDelete data/users/1

Responses are typically in JSON format, making them easy to consume from frontends (like React) or other backends.

⚙️ Setting Up Your Environment

Let’s start from scratch.

Step 1: Create a virtual environment

python -m venv venv
source venv/bin/activate  # or venv\Scripts\activate on Windows

Step 2: Install FastAPI and Uvicorn

pip install fastapi uvicorn
  • FastAPI: the web framework.
  • Uvicorn: the server to run your app (an ASGI server).

🧱 Creating Your First RESTful API

Let’s make a small API for managing blog posts.

main.py

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

# Fake database
posts = []

# Pydantic model for validation
class Post(BaseModel):
    id: int
    title: str
    content: str

@app.get("/posts")
def get_posts():
    return posts

@app.get("/posts/{post_id}")
def get_post(post_id: int):
    for post in posts:
        if post["id"] == post_id:
            return post
    raise HTTPException(status_code=404, detail="Post not found")

@app.post("/posts", status_code=201)
def create_post(post: Post):
    posts.append(post.dict())
    return post

@app.put("/posts/{post_id}")
def update_post(post_id: int, updated_post: Post):
    for index, post in enumerate(posts):
        if post["id"] == post_id:
            posts[index] = updated_post.dict()
            return updated_post
    raise HTTPException(status_code=404, detail="Post not found")

@app.delete("/posts/{post_id}", status_code=204)
def delete_post(post_id: int):
    for index, post in enumerate(posts):
        if post["id"] == post_id:
            posts.pop(index)
            return
    raise HTTPException(status_code=404, detail="Post not found")

▶️ Running the Server

Run your app with:

uvicorn main:app --reload

Visit:

  • Docs: http://127.0.0.1:8000/docs → FastAPI automatically generates Swagger UI!
  • API: Try making requests from there — no need for Postman.

🧩 Adding a Database (Optional Next Step)

You can connect your API to a real database using SQLAlchemy:

pip install sqlalchemy<br>

Then define models and use a session to interact with your DB.
FastAPI integrates cleanly with ORMs, making it easy to build production-ready systems.

🧠 Why FastAPI Is Great for RESTful APIs

  • 🚀 Blazing fast performance (based on Starlette and Pydantic).
  • 🧩 Type hints → automatic validation and documentation.
  • 🔐 Easy authentication (JWT, OAuth2 built-in support).
  • 🧪 Built-in testing with TestClient.
  • 📝 Interactive docs with Swagger and ReDoc.

✅ Conclusion

Building RESTful APIs in Python is straightforward and scalable — especially with FastAPI.
You can go from a simple prototype to a production-ready microservice in a matter of hours, with clean, modern code and automatic documentation.

💡 Whether you’re integrating with a React frontend, mobile app, or internal system — mastering FastAPI will make you a far more effective developer.

Related Posts

Leave a Reply