REST API mit FastAPI und Python erstellen: 8 Schritte fuer Anfaenger

Warum FastAPI das beste Framework fuer Python-REST-APIs ist

Wenn Sie 2026 eine REST API mit Python bauen wollen, fuehrt kaum ein Weg an FastAPI vorbei. Das von Sebastián Ramírez entwickelte Framework hat in den letzten Jahren Flask und Django REST als bevorzugtes API-Framework abgeloest — und das aus guten Gruenden:

• Geschwindigkeit: FastAPI basiert auf Starlette und Pydantic und ist eines der schnellsten Python-Frameworks ueberhaupt — vergleichbar mit Node.js und Go.
• Automatische Dokumentation: Jede API erhaelt automatisch eine interaktive Swagger-UI und ReDoc-Dokumentation — ohne eine einzige Zeile zusaetzlichen Code.
• Typ-Sicherheit: Durch Python Type Hints und Pydantic werden Eingabedaten automatisch validiert. Fehler werden beim Entwickeln, nicht erst in der Produktion, erkannt.
• Async-native: Volle Unterstuetzung fuer async/await — ideal fuer APIs, die auf Datenbanken, externe Services oder KI-Modelle zugreifen.

In dieser Anleitung bauen wir gemeinsam eine vollstaendige REST API fuer eine Aufgabenverwaltung (Todo-App). Sie lernen alle grundlegenden Konzepte — von der Installation bis zum Deployment. Grundlegende Python-Kenntnisse genuegen als Voraussetzung.

Schritt 1: Python-Umgebung einrichten

Bevor wir mit FastAPI beginnen, brauchen wir eine saubere Python-Umgebung. Wir verwenden ein Virtual Environment, um Abhaengigkeiten isoliert zu halten. Oeffnen Sie Ihr Terminal und fuehren Sie folgende Befehle aus:

# Projektverzeichnis erstellen
mkdir todo-api && cd todo-api

# Virtual Environment erstellen (Python 3.11+)
python3 -m venv venv

# Aktivieren (macOS/Linux)
source venv/bin/activate

# Aktivieren (Windows)
# venv\Scripts\activate

# FastAPI und Uvicorn installieren
pip install fastapi uvicorn[standard] pydantic

Was wird installiert?

• fastapi — das Web-Framework selbst
• uvicorn[standard] — ein blitzschneller ASGI-Server, der FastAPI ausfuehrt
• pydantic — Datenvalidierung und Serialisierung (wird von FastAPI intern genutzt, aber wir installieren es explizit fuer Klarheit)

Pruefen Sie die Installation mit python -c "import fastapi; print(fastapi.__version__)". Sie sollten Version 0.115 oder hoeher sehen.

Schritt 2: Die erste FastAPI-Anwendung erstellen

Erstellen Sie eine Datei main.py im Projektverzeichnis. Diese wird der Einstiegspunkt unserer API:

from fastapi import FastAPI

# FastAPI-Instanz erstellen
app = FastAPI(
    title="Todo API",
    description="Eine einfache REST API fuer Aufgabenverwaltung",
    version="1.0.0",
)

# Erster Endpunkt: Willkommensnachricht
@app.get("/")
def read_root():
    return {"nachricht": "Willkommen bei der Todo API!"}

# Gesundheitscheck-Endpunkt
@app.get("/health")
def health_check():
    return {"status": "ok"}

Starten Sie den Server mit:

uvicorn main:app --reload

Der Parameter --reload startet den Server automatisch neu, wenn Sie Code aendern — perfekt fuer die Entwicklung. Oeffnen Sie http://localhost:8000 im Browser und Sie sehen die JSON-Antwort. Besuchen Sie http://localhost:8000/docs fuer die automatisch generierte Swagger-Dokumentation.

Schritt 3: Pydantic-Datenmodelle definieren

Pydantic-Modelle sind das Herzstueck jeder FastAPI-Anwendung. Sie definieren, welche Daten Ihre API akzeptiert und zurueckgibt. Erstellen Sie eine neue Datei models.py:

from pydantic import BaseModel, Field
from typing import Optional
from datetime import datetime
from enum import Enum


class Priority(str, Enum):
    niedrig = "niedrig"
    mittel = "mittel"
    hoch = "hoch"


class TodoCreate(BaseModel):
    """Schema fuer das Erstellen eines neuen Todos."""
    titel: str = Field(
        ...,
        min_length=1,
        max_length=200,
        description="Der Titel der Aufgabe"
    )
    beschreibung: Optional[str] = Field(
        None,
        max_length=1000,
        description="Optionale Beschreibung"
    )
    prioritaet: Priority = Field(
        default=Priority.mittel,
        description="Prioritaet: niedrig, mittel oder hoch"
    )


class TodoUpdate(BaseModel):
    """Schema fuer das Aktualisieren eines Todos."""
    titel: Optional[str] = Field(None, min_length=1, max_length=200)
    beschreibung: Optional[str] = Field(None, max_length=1000)
    prioritaet: Optional[Priority] = None
    erledigt: Optional[bool] = None


class TodoResponse(BaseModel):
    """Schema fuer die API-Antwort."""
    id: int
    titel: str
    beschreibung: Optional[str]
    prioritaet: Priority
    erledigt: bool
    erstellt_am: datetime
    aktualisiert_am: datetime

Beachten Sie die drei separaten Modelle: TodoCreate fuer eingehende Daten beim Erstellen, TodoUpdate fuer teilweise Aktualisierungen (alle Felder optional) und TodoResponse fuer die Antwort. Dieses Pattern heisst “Schema Separation” und ist eine Best Practice in der API-Entwicklung.

Schritt 4: CRUD-Endpunkte implementieren

Jetzt bauen wir die vier grundlegenden Operationen: Create, Read, Update, Delete. Aktualisieren Sie main.py:

from fastapi import FastAPI, HTTPException, Query
from models import TodoCreate, TodoUpdate, TodoResponse, Priority
from datetime import datetime

app = FastAPI(
    title="Todo API",
    description="REST API fuer Aufgabenverwaltung mit FastAPI",
    version="1.0.0",
)

# In-Memory-Speicher (spaeter durch Datenbank ersetzen)
todos: dict[int, dict] = {}
counter = 0


@app.post("/todos", response_model=TodoResponse, status_code=201)
def create_todo(todo: TodoCreate):
    """Erstellt eine neue Aufgabe."""
    global counter
    counter += 1
    now = datetime.now()
    new_todo = {
        "id": counter,
        "titel": todo.titel,
        "beschreibung": todo.beschreibung,
        "prioritaet": todo.prioritaet,
        "erledigt": False,
        "erstellt_am": now,
        "aktualisiert_am": now,
    }
    todos[counter] = new_todo
    return new_todo


@app.get("/todos", response_model=list[TodoResponse])
def list_todos(
    erledigt: bool | None = Query(None, description="Nach Status filtern"),
    prioritaet: Priority | None = Query(None, description="Nach Prioritaet filtern"),
):
    """Listet alle Aufgaben auf, optional gefiltert."""
    result = list(todos.values())
    if erledigt is not None:
        result = [t for t in result if t["erledigt"] == erledigt]
    if prioritaet is not None:
        result = [t for t in result if t["prioritaet"] == prioritaet]
    return result


@app.get("/todos/{todo_id}", response_model=TodoResponse)
def get_todo(todo_id: int):
    """Gibt eine einzelne Aufgabe zurueck."""
    if todo_id not in todos:
        raise HTTPException(status_code=404, detail="Aufgabe nicht gefunden")
    return todos[todo_id]


@app.put("/todos/{todo_id}", response_model=TodoResponse)
def update_todo(todo_id: int, todo: TodoUpdate):
    """Aktualisiert eine bestehende Aufgabe."""
    if todo_id not in todos:
        raise HTTPException(status_code=404, detail="Aufgabe nicht gefunden")
    stored = todos[todo_id]
    update_data = todo.model_dump(exclude_unset=True)
    for key, value in update_data.items():
        stored[key] = value
    stored["aktualisiert_am"] = datetime.now()
    return stored


@app.delete("/todos/{todo_id}", status_code=204)
def delete_todo(todo_id: int):
    """Loescht eine Aufgabe."""
    if todo_id not in todos:
        raise HTTPException(status_code=404, detail="Aufgabe nicht gefunden")
    del todos[todo_id]

Jeder Endpunkt hat einen klaren Zweck:

• POST /todos — neue Aufgabe erstellen (gibt 201 zurueck)
• GET /todos — alle Aufgaben auflisten (mit optionalen Filtern)
• GET /todos/{todo_id} — einzelne Aufgabe abrufen
• PUT /todos/{todo_id} — Aufgabe aktualisieren
• DELETE /todos/{todo_id} — Aufgabe loeschen (gibt 204 zurueck)

Schritt 5: Fehlerbehandlung professionell umsetzen

Eine gute API kommuniziert Fehler klar und einheitlich. FastAPI bietet dafuer Exception Handler. Erstellen Sie eine Datei errors.py:

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
from fastapi.exceptions import RequestValidationError

def register_error_handlers(app: FastAPI):
    @app.exception_handler(RequestValidationError)
    async def validation_error_handler(
        request: Request, exc: RequestValidationError
    ):
        errors = []
        for error in exc.errors():
            errors.append({
                "feld": " -> ".join(str(loc) for loc in error["loc"]),
                "nachricht": error["msg"],
                "typ": error["type"],
            })
        return JSONResponse(
            status_code=422,
            content={
                "detail": "Validierungsfehler",
                "fehler": errors,
            },
        )

    @app.exception_handler(Exception)
    async def general_error_handler(request: Request, exc: Exception):
        return JSONResponse(
            status_code=500,
            content={
                "detail": "Interner Serverfehler",
                "nachricht": "Ein unerwarteter Fehler ist aufgetreten.",
            },
        )

Registrieren Sie die Handler in main.py, indem Sie register_error_handlers(app) nach der App-Erstellung aufrufen. Jetzt erhalten Clients bei Validierungsfehlern klare, deutschsprachige Fehlermeldungen mit genauen Feldangaben.

Schritt 6: Middleware hinzufuegen (CORS und Logging)

Middleware verarbeitet Requests, bevor sie Ihre Endpunkte erreichen. Die zwei wichtigsten Middleware-Komponenten fuer APIs sind CORS (damit Ihr Frontend die API aufrufen kann) und Logging (damit Sie sehen, was passiert):

from fastapi.middleware.cors import CORSMiddleware
import time
import logging

logger = logging.getLogger("todo-api")

# CORS-Middleware: Erlaubt Zugriff von Ihrem Frontend
app.add_middleware(
    CORSMiddleware,
    allow_origins=["http://localhost:3000"],  # Frontend-URL
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Custom Logging-Middleware
@app.middleware("http")
async def log_requests(request, call_next):
    start = time.time()
    response = await call_next(request)
    duration = round(time.time() - start, 4)
    logger.info(
        f"{request.method} {request.url.path} "
        f"-> {response.status_code} ({duration}s)"
    )
    return response

Fuer Produktions-APIs sollten Sie die allow_origins auf Ihre tatsaechliche Domain einschraenken. Waehrend der Entwicklung koennen Sie ["*"] verwenden, aber niemals in der Produktion.

Schritt 7: Tests mit pytest schreiben

Professionelle APIs werden getestet. FastAPI bietet mit TestClient eine elegante Moeglichkeit, Endpunkte zu testen, ohne den Server zu starten. Installieren Sie zunaechst die Test-Abhaengigkeiten:

pip install pytest httpx

Erstellen Sie eine Datei test_main.py:

from fastapi.testclient import TestClient
from main import app

client = TestClient(app)


def test_create_todo():
    """Test: Aufgabe erstellen."""
    response = client.post("/todos", json={
        "titel": "Python lernen",
        "beschreibung": "FastAPI Tutorial durcharbeiten",
        "prioritaet": "hoch",
    })
    assert response.status_code == 201
    data = response.json()
    assert data["titel"] == "Python lernen"
    assert data["erledigt"] is False
    assert "id" in data


def test_list_todos():
    """Test: Alle Aufgaben auflisten."""
    response = client.get("/todos")
    assert response.status_code == 200
    assert isinstance(response.json(), list)


def test_get_todo_not_found():
    """Test: Nicht existierende Aufgabe."""
    response = client.get("/todos/99999")
    assert response.status_code == 404


def test_update_todo():
    """Test: Aufgabe aktualisieren."""
    # Erst erstellen
    create_resp = client.post("/todos", json={"titel": "Test"})
    todo_id = create_resp.json()["id"]
    # Dann aktualisieren
    update_resp = client.put(
        f"/todos/{todo_id}",
        json={"erledigt": True},
    )
    assert update_resp.status_code == 200
    assert update_resp.json()["erledigt"] is True


def test_delete_todo():
    """Test: Aufgabe loeschen."""
    create_resp = client.post("/todos", json={"titel": "Zu loeschen"})
    todo_id = create_resp.json()["id"]
    delete_resp = client.delete(f"/todos/{todo_id}")
    assert delete_resp.status_code == 204


def test_validation_error():
    """Test: Leerer Titel wird abgelehnt."""
    response = client.post("/todos", json={"titel": ""})
    assert response.status_code == 422

Fuehren Sie die Tests aus mit pytest test_main.py -v. Alle sechs Tests sollten gruen sein. Guter Code ohne Tests ist nur Code — erst Tests machen ihn zuverlaessig.

Schritt 8: Deployment vorbereiten

Ihre API ist fertig — jetzt muss sie in die Produktion. Hier sind die wichtigsten Schritte fuer ein professionelles Deployment:

requirements.txt erstellen

pip freeze > requirements.txt

Dockerfile schreiben

FROM python:3.12-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8000

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Docker-Container bauen und starten

# Image bauen
docker build -t todo-api .

# Container starten
docker run -d -p 8000:8000 --name todo-api todo-api

Fuer die Produktion empfehlen wir zusaetzlich:

• Gunicorn mit Uvicorn-Workern: gunicorn main:app -w 4 -k uvicorn.workers.UvicornWorker fuer Multi-Process-Betrieb.
• Environment Variables: Verwenden Sie pydantic-settings fuer Konfiguration statt Hardcoding.
• Reverse Proxy: Nginx oder Traefik vor Uvicorn fuer SSL-Terminierung und Rate Limiting.
• Cloud-Deployment: Google Cloud Run, AWS ECS/Fargate oder Azure Container Apps fuer automatische Skalierung.

Zusammenfassung: Ihre Lern-Roadmap

In 8 Schritten haben Sie eine vollstaendige REST API gebaut — von der Installation bis zum Deployment. Hier ist eine Zusammenfassung Ihrer neuen Faehigkeiten:

1. Umgebung einrichten — Virtual Environment, pip, FastAPI installieren
2. Erste App erstellen — FastAPI-Instanz, Endpunkte, Uvicorn-Server
3. Datenmodelle definieren — Pydantic BaseModel, Validierung, Schema Separation
4. CRUD implementieren — POST, GET, PUT, DELETE mit Path- und Query-Parametern
5. Fehlerbehandlung — Exception Handler, einheitliche Fehlermeldungen
6. Middleware — CORS, Logging, Request-Verarbeitung
7. Tests schreiben — pytest, TestClient, alle Endpunkte abdecken
8. Deployment — Docker, Gunicorn, Cloud-Optionen

Als naechste Schritte empfehlen wir: Datenbankanbindung mit SQLModel (vom FastAPI-Erfinder), Authentifizierung mit OAuth2 und JWT, und die Integration von KI-Agenten ueber API-Endpunkte. Wer diese Skills beherrscht, ist als Backend-Entwickler auf dem deutschen Arbeitsmarkt hervorragend aufgestellt.

FastAPI wird von Unternehmen wie Microsoft, Netflix, Uber und SAP in der Produktion eingesetzt. Was Sie hier gelernt haben, ist keine Uebung — es sind die gleichen Patterns, die in Produktions-APIs weltweit verwendet werden.