FastAPI for Absolute Beginners — A Step-by-Step Guide to Building Your First API

Learn FastAPI without confusion — even if you’ve never built an API before.

FastAPI for Absolute Beginners — A Step-by-Step Guide to Building Your First API

If you’ve been working with Python and want to dip your toes into building web APIs, FastAPI is hands down one of the best frameworks to start with.

It’s simple, powerful, and — as the name suggests — fast. But what really makes FastAPI a developer favorite is how beginner-friendly it is while still being production-ready.

In this guide, I’ll walk you through the basics of FastAPI from scratch. By the end, you’ll have your own working API up and running — and you’ll understand why things work the way they do.

What You’ll Need Before We Begin

Python 3.8+

Basic Python knowledge (functions, classes, etc.)

Terminal access (Mac/Linux/Windows)

Let’s get coding!

Step 1: Install FastAPI and Uvicorn

Uvicorn is the lightning-fast ASGI server that runs your FastAPI app.

pip install fastapi uvicorn

That’s it. You’re ready to build.

Step 2: Create a Simple FastAPI App

Create a new Python file called main.py:

# main.py 
from fastapi import FastAPI 
 
app = FastAPI() 
 
@app.get("/") 
def read_root(): 
    return {"message": "Welcome to FastAPI!"} 
 
@app.get("/hello/{name}") 
def say_hello(name: str): 
    return {"greeting": f"Hello, {name}!"}

This small app has two endpoints:

• / returns a welcome message.
• /hello/{name} takes a dynamic name and returns a greeting.

Step 3: Run the API

In your terminal, run:

uvicorn main:app --reload

Here’s what’s happening:

• main is the filename (without .py)
• app is the FastAPI instance
• --reload watches for code changes (great for development)

Now open your browser and visit:

• 👉 http://127.0.0.1:8000 — Your API is live!
• 👉 http://127.0.0.1:8000/docs — Interactive Swagger UI
• 👉 http://127.0.0.1:8000/redoc — Alternate ReDoc documentation

Yes — FastAPI auto-generates these docs just from your code!

Step 4: Add Query Parameters and Type Validation

Let’s make an endpoint that calculates the square of a number:

@app.get("/square") 
def get_square(number: int): 
    return {"number": number, "square": number ** 2}

Now try this in your browser:

http://127.0.0.1:8000/square?number=5

FastAPI automatically validates that number is an integer. Try using abc instead — it returns a 422 error with a friendly message.

Bonus: Add a POST Endpoint with a Request Body

Let’s accept data using a POST request:

from pydantic import BaseModel 
 
class Item(BaseModel): 
    name: str 
    price: float 
    in_stock: bool 
 
@app.post("/items/") 
def create_item(item: Item): 
    return {"message": "Item received", "item": item}

Use a tool like Postman or curl to test:

POST http://127.0.0.1:8000/items/ 
Content-Type: application/json 
 
{ 
  "name": "Laptop", 
  "price": 1099.99, 
  "in_stock": true 
}

FastAPI will:

Validate the input

Generate the OpenAPI schema

Return your data in a clean response

Final Thoughts

FastAPI removes a lot of the traditional boilerplate of backend development. You focus on writing Python functions, and it takes care of the rest.

If you’re coming from Flask or Django, you’ll feel right at home — but with way more power under the hood.

Whether you’re building a side project, a startup API, or a production-grade backend, FastAPI is the modern Python framework you didn’t know you needed.

Next Steps

Here’s what you can explore after this:

• Add request validation with Query, Path, and Body
• Use async functions for better performance
• Connect a database (e.g., SQLModel, SQLAlchemy)
• Add authentication and authorization
• Deploy to cloud (e.g., Render, Vercel, or Docker)

Enjoyed the Guide?

If you found this helpful:

• Leave a comment with your questions or API ideas
• Follow me for more Python & FastAPI tutorials
• Bookmark this guide for your next project