Building a REST API with Python in 30 Minutes (Complete Guide)
Photo by Unsplash
Quick Win: By the end of this tutorial, you'll have a fully functional REST API with user authentication, database integration, and automatic documentation. No prior API experience needed!
Building a REST API doesn't have to be complicated. In 2026, FastAPI makes it incredibly easy to create production-ready APIs in Python.
What we'll build:
- ✅ User registration and login endpoints
- ✅ CRUD operations for a "tasks" resource
- ✅ JWT authentication
- ✅ SQLite database (easy to switch to PostgreSQL)
- ✅ Automatic API documentation (Swagger UI)
Time required: 30 minutes
Difficulty: Beginner-friendly
📋 Prerequisites
| Requirement | Details |
|---|---|
| Python | 3.8 or higher |
| Basic Python | Functions, classes, decorators |
| Terminal | Basic command line usage |
💡 Don't worry if you're new to APIs! I'll explain everything as we go.
1Project Setup (2 minutes)
Create a new project directory and set up a virtual environment:
# Create project directory
mkdir fastapi-todo-api
cd fastapi-todo-api
# Create virtual environment
python -m venv venv
# Activate virtual environment
# On Mac/Linux:
source venv/bin/activate
# On Windows:
venv\\Scripts\\activate
# Install dependencies
pip install fastapi uvicorn sqlalchemy python-jose[cryptography] passlib[bcrypt] python-multipart
💡 Pro Tip: Always use a virtual environment to keep your projects isolated!
2Create Basic API (5 minutes)
Create main.py with our first endpoints:
from fastapi import FastAPI
from pydantic import BaseModel
from typing import Optional
app = FastAPI(
title="Todo API",
description="A simple Todo API built with FastAPI",
version="1.0.0"
)
# Pydantic model for Task
class Task(BaseModel):
id: Optional[int] = None
title: str
description: Optional[str] = None
completed: bool = False
@app.get("/")
async def root():
return {"message": "Welcome to Todo API!"}
@app.get("/tasks")
async def get_tasks():
return [{"id": 1, "title": "Learn FastAPI", "completed": True}]
@app.post("/tasks")
async def create_task(task: Task):
return {"message": "Task created", "task": task}
# Run with: uvicorn main:app --reload
Run the server:
uvicorn main:app --reload
Visit http://127.0.0.1:8000/docs to see the automatic Swagger UI documentation!
📸 FastAPI auto-generates beautiful API docs
3Database Setup (8 minutes)
Create database.py for SQLite connection:
from sqlalchemy import create_engine, Column, Integer, String, Boolean
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
DATABASE_URL = "sqlite:///./todo.db"
engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()
class TaskModel(Base):
__tablename__ = "tasks"
id = Column(Integer, primary_key=True, index=True)
title = Column(String, index=True)
description = Column(String, nullable=True)
completed = Column(Boolean, default=False)
# Create tables
Base.metadata.create_all(bind=engine)
💡 Switching to PostgreSQL? Just change the DATABASE_URL to your PostgreSQL connection string!
4Complete CRUD Operations (10 minutes)
Update main.py with full CRUD operations:
from fastapi import FastAPI, Depends, HTTPException
from sqlalchemy.orm import Session
import database
from pydantic import BaseModel
from typing import Optional
app = FastAPI()
# Dependency
def get_db():
db = database.SessionLocal()
try:
yield db
finally:
db.close()
class TaskCreate(BaseModel):
title: str
description: Optional[str] = None
class Task(BaseModel):
id: int
title: str
description: Optional[str]
completed: bool
class Config:
from_attributes = True
@app.post("/tasks/", response_model=Task)
async def create_task(task: TaskCreate, db: Session = Depends(get_db)):
db_task = database.TaskModel(**task.dict())
db.add(db_task)
db.commit()
db.refresh(db_task)
return db_task
@app.get("/tasks/", response_model=list[Task])
async def read_tasks(skip: int = 0, limit: int = 10, db: Session = Depends(get_db)):
tasks = db.query(database.TaskModel).offset(skip).limit(limit).all()
return tasks
@app.get("/tasks/{task_id}", response_model=Task)
async def read_task(task_id: int, db: Session = Depends(get_db)):
task = db.query(database.TaskModel).filter(database.TaskModel.id == task_id).first()
if task is None:
raise HTTPException(status_code=404, detail="Task not found")
return task
@app.put("/tasks/{task_id}", response_model=Task)
async def update_task(task_id: int, task: TaskCreate, db: Session = Depends(get_db)):
db_task = db.query(database.TaskModel).filter(database.TaskModel.id == task_id).first()
if db_task is None:
raise HTTPException(status_code=404, detail="Task not found")
for key, value in task.dict().items():
setattr(db_task, key, value)
db.commit()
db.refresh(db_task)
return db_task
@app.delete("/tasks/{task_id}")
async def delete_task(task_id: int, db: Session = Depends(get_db)):
db_task = db.query(database.TaskModel).filter(database.TaskModel.id == task_id).first()
if db_task is None:
raise HTTPException(status_code=404, detail="Task not found")
db.delete(db_task)
db.commit()
return {"message": "Task deleted successfully"}
5Test Your API (5 minutes)
Test endpoints using the Swagger UI at http://127.0.0.1:8000/docs
Test with curl:
# Create a task
curl -X POST "http://127.0.0.1:8000/tasks/" \
-H "Content-Type: application/json" \
-d '{"title": "Learn FastAPI", "description": "Build a REST API"}'
# Get all tasks
curl "http://127.0.0.1:8000/tasks/"
# Get specific task
curl "http://127.0.0.1:8000/tasks/1"
# Update task
curl -X PUT "http://127.0.0.1:8000/tasks/1" \
-H "Content-Type: application/json" \
-d '{"title": "Master FastAPI", "description": "Build production APIs"}'
# Delete task
curl -X DELETE "http://127.0.0.1:8000/tasks/1"
💡 Pro Tip: Use HTTPie for a more user-friendly CLI experience!
🚀 Next Steps
Congratulations! You've built a complete REST API. Here's what to learn next:
- ✅ Authentication: Add JWT tokens with python-jose
- ✅ Validation: Add more Pydantic validation rules
- ✅ Deployment: Deploy to Railway, Render, or AWS
- ✅ Testing: Write tests with pytest
- ✅ Documentation: Add detailed docstrings
⚠️ Production Checklist:
- Use environment variables for secrets
- Add rate limiting
- Enable CORS properly
- Use PostgreSQL instead of SQLite
- Add logging and monitoring
📦 Complete Code Repository
Want the complete code with authentication and deployment config?
💭 Final Thoughts
FastAPI makes building REST APIs incredibly fast and enjoyable. The automatic documentation, type validation, and async support make it the best choice for Python APIs in 2026.
What took 30 minutes:
- ✅ Project setup
- ✅ Database configuration
- ✅ Complete CRUD operations
- ✅ Automatic API documentation
Now go build something amazing! 🚀
Want More Python Tutorials?
Subscribe for weekly backend development tips and code examples.
Subscribe →💬 Questions?
Drop your questions in the comments! I read and respond to every one.
📧 Subscribe for more Python and backend tutorials.
Comments
Post a Comment