FastAPI Hello World

1 Introduction to FastAPI

FastAPI is a modern Python web framework for building APIs. It rides on Starlette for the web layer and Pydantic for data validation. Type hints are not just decoration—they drive request parsing, response serialization, and automatic documentation.

Fast: High performance on par with Node and Go.
Fast to code: Sprints through features with minimal boilerplate.
Fewer bugs: Validates input and output automatically.
Standards-based: Generates OpenAPI, Swagger UI, and ReDoc out of the box.

When ready, click “Next” and we’ll get a minimal app running locally.

2 Prerequisites: Python & Pip

Confirm Python 3.7+ and pip are installed:

python --version
pip --version

If they’re missing, install from python.org.

3 Setup a Virtual Environment

Keep dependencies tidy with a virtual environment.

python -m venv .venv

Activate it:

# macOS/Linux
source .venv/bin/activate

# Windows (Command Prompt)
.venv\Scripts\activate

You’ll see (.venv) when it’s active.

4 Install FastAPI and Uvicorn

Install FastAPI and Uvicorn (the ASGI server) inside your virtual environment:

pip install "fastapi[all]" uvicorn[standard]

The [all] extra pulls in Pydantic v2 and standard optional dependencies. If you prefer lean installs, use pip install fastapi uvicorn.

5 Create main.py

Make a file named main.py and add a basic endpoint:

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():
    return {"message": "Hello, FastAPI"}

That’s it—one import, one app, one route. The docstrings and type hints will power the generated docs.

6 Run the Server with Uvicorn

Start the server with hot-reload during development:

uvicorn main:app --reload

Open http://127.0.0.1:8000/ to see your JSON response.

7 Explore Interactive Docs

FastAPI serves Swagger UI and ReDoc automatically:

Swagger UI: /docs
ReDoc: /redoc
OpenAPI schema: /openapi.json

You can try the endpoint directly from the docs and see request/response models without any extra setup.

8 Add a Route with a Path Parameter

Update main.py with a parameterized route:

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():
    return {"message": "Hello, FastAPI"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: str | None = None):
    result = {"item_id": item_id}
    if q:
        result["q"] = q
    return result

Thanks to type hints, item_id will be validated as an integer and documented automatically.

9 Accept a Request Body (Pydantic)

Define a model and accept JSON payloads:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    price: float
    tags: list[str] = []


@app.post("/items/", response_model=Item)
def create_item(item: Item):
    # Normally you'd store this; here we just echo it back.
    return item


@app.get("/")
def read_root():
    return {"message": "Hello, FastAPI"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: str | None = None):
    result = {"item_id": item_id}
    if q:
        result["q"] = q
    return result

FastAPI validates the JSON, enforces types, and documents the model in the generated schema.

10 Raise and Handle Errors

Use HTTPException for clean error responses:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    price: float
    tags: list[str] = []


db: dict[int, Item] = {}


@app.post("/items/", response_model=Item)
def create_item(item: Item):
    new_id = len(db) + 1
    db[new_id] = item
    return item


@app.get("/items/{item_id}")
def read_item(item_id: int):
    item = db.get(item_id)
    if not item:
        raise HTTPException(status_code=404, detail="Item not found")
    return {"item_id": item_id, **item.dict()}

Now trying a missing ID returns a clean 404 JSON: {"detail": "Item not found"}.

11 Next Steps and Deployment

Pin dependencies: pip freeze > requirements.txt
Try production mode: uvicorn main:app --host 0.0.0.0 --port 8000
Deploy to Render, Fly.io, Railway, or a VM with Gunicorn + Uvicorn workers
Use @app.exception_handler to centralize error formatting
Secure endpoints with OAuth2/JWT via fastapi.security

You now have a working API, validation, and live docs. From here you can grow routes, layers, and tests without swapping frameworks.

Tutorial Progress