How do you define routes (path operations)?

Question

Accepted Answer

In FastAPI, a **path operation** is a route — a function decorated with an HTTP method decorator (`@app.get`, `@app.post`, etc.) that handles requests to a path. The function's return value is automatically serialized to JSON.

## Defining routes for each HTTP method

```python
from fastapi import FastAPI
app = FastAPI()

@app.get("/items")                # GET /items
def list_items():
    return [{"id": 1}, {"id": 2}]  # dict/list → automatically JSON-serialized

@app.get("/items/{item_id}")      # GET /items/5 — path parameter
def get_item(item_id: int):        # type hint converts "5" → int (and validates)
    return {"id": item_id}

@app.post("/items")               # POST /items
def create_item(item: Item):
    return item

@app.put("/items/{item_id}")      # PUT, PATCH, DELETE work the same way
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    return {"deleted": item_id}
```

Each decorator maps an HTTP method + path to a handler. The function name is yours; the decorator defines the route. Returned dicts/lists/Pydantic models are serialized to JSON automatically — no manual `json.dumps`.

## Order matters for overlapping paths

```python
@app.get("/users/me")            # ✅ specific route FIRST
def read_me(): ...
@app.get("/users/{user_id}")     # dynamic AFTER — else "me" matches {user_id}
def read_user(user_id: int): ...
```

FastAPI matches routes in declaration order, so put static paths before dynamic ones.

## Operation metadata (drives the docs)

```python
@app.get("/items", tags=["items"], summary="List items", status_code=200)
def list_items(): ...
```

Decorator parameters (`tags`, `summary`, `status_code`, `response_model`) configure behavior and enrich the auto-generated documentation.

## Why it matters

Path operations are the foundation of every FastAPI application — they define your API's endpoints and how requests are handled.

Understanding the decorator-per-HTTP-method pattern, that return values are automatically serialized to JSON (no boilerplate), that type hints on parameters drive conversion and validation, and that route order matters for overlapping paths is essential everyday knowledge for building any endpoint.

The decorator metadata also feeds FastAPI's automatic documentation, tying routes directly to the docs.

This is the first and most fundamental thing to master in FastAPI.