Claude Code FastAPI: Python-APIs in Minuten statt Stunden bauen

FastAPI ist das Python-Framework, das viele Entwickler zu dem gemacht hat, was Django und Flask nie ganz geschafft haben: moderne, produktionsreife REST-APIs ohne Boilerplate-Qual. Automatische OpenAPI-Dokumentation, typsichere Request-Validierung via Pydantic, native Async-Unterstützung — alles inklusive, nichts konfigurieren.

Und wenn man Claude Code FastAPI kombiniert, beschleunigt sich das nochmals: Endpoints generieren, Pydantic-Models ableiten, JWT-Auth implementieren, Tests schreiben — ohne stundenlange Dokumentations-Recherche. Dieser Artikel zeigt, wie das in der Praxis funktioniert.

1. Was ist FastAPI — und warum ist es anders

FastAPI ist ein modernes Python-Web-Framework, das auf Starlette (ASGI-Basis) und Pydantic (Datenvalidierung) aufbaut. Es wurde 2018 von Sebastián Ramírez veröffentlicht und hat sich seitdem zum meistgesternten Python-API-Framework auf GitHub entwickelt.

Was FastAPI von Flask und Django REST Framework unterscheidet:

• Automatische OpenAPI-Dokumentation: Swagger UI und ReDoc werden out-of-the-box generiert, ohne ein einziges Docstring-Format zu lernen
• Typsicherheit durch Python Type Hints: FastAPI liest deine Typ-Annotationen und validiert Request-Daten automatisch
• Native Async/Await-Unterstützung: Endpoints können synchron oder asynchron sein — ohne Umweg über Celery oder ähnliche Tools
• Dependency Injection eingebaut: Datenbankverbindungen, Auth-Checks, gemeinsam genutzte Logik — alles über ein sauberes DI-System
• Performance: Auf Augenhöhe mit Node.js und Go bei I/O-lastigen Workloads

Kurz: FastAPI ist das Framework, das Python-APIs so baut, wie sie 2026 gebaut werden sollten.

2. Erste Schritte: Installation und Hello-World-Endpoint

FastAPI benötigt Python 3.8 oder neuer. Installation:

pip install fastapi uvicorn[standard]

Ein minimaler Hello-World-Endpoint in main.py:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def root():
    return {"message": "Hello World"}

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

Starten mit uvicorn:

uvicorn main:app --reload

Die API läuft jetzt auf http://localhost:8000. Die automatisch generierte Swagger-Dokumentation ist unter http://localhost:8000/docs erreichbar — ohne eine einzige Zeile Konfiguration.

Mit Claude Code geht das noch schneller. Statt selbst die Struktur aufzusetzen:

claude "Erstelle eine FastAPI-Anwendung für einen einfachen
Produktkatalog mit CRUD-Endpoints: GET /products, GET /products/{id},
POST /products, PUT /products/{id}, DELETE /products/{id}"

Claude Code liest das Projekt-Setup, wählt die richtige Struktur (einzelne Datei oder Router-basiert je nach Projektgröße) und generiert vollständige, lauffähige Endpoints — inklusive korrekter HTTP-Status-Codes und Fehlerbehandlung.

3. Pydantic-Models: Request- und Response-Validierung

Das Herzstück von FastAPI ist die Integration mit Pydantic. Statt Daten manuell zu validieren, definierst du ein Model — und FastAPI übernimmt den Rest:

from pydantic import BaseModel, EmailStr, Field
from typing import Optional

class ProductCreate(BaseModel):
    name: str = Field(..., min_length=1, max_length=200)
    price: float = Field(..., gt=0)
    description: Optional[str] = None
    category: str

class ProductResponse(ProductCreate):
    id: int
    created_at: datetime

    class Config:
        from_attributes = True

FastAPI validiert automatisch: Ein Request mit price: -5 wird mit HTTP 422 abgelehnt, bevor dein Code überhaupt aufgerufen wird. Das Response-Model filtert automatisch Felder heraus, die nicht im Schema stehen — kein versehentliches Leaken von internen Daten.

4. Dependency Injection: Datenbankverbindungen und Auth

FastAPI bringt ein eigenes Dependency-Injection-System mit, das eleganter ist als das manuelle Weitergeben von Verbindungen oder das Nutzen globaler State-Variablen.

Datenbankverbindung als Dependency

from sqlalchemy.orm import Session
from database import SessionLocal

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.get("/products/{product_id}")
def read_product(product_id: int, db: Session = Depends(get_db)):
    product = db.query(Product).filter(Product.id == product_id).first()
    if not product:
        raise HTTPException(status_code=404, detail="Produkt nicht gefunden")
    return product

FastAPI öffnet eine Datenbankverbindung pro Request, schließt sie nach Abschluss automatisch — und du musst das nicht manuell managen. Der yield in der Dependency sorgt für das korrekte Cleanup, auch bei Exceptions.

Auth als wiederverwendbare Dependency

from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

async def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
    user = verify_token_and_get_user(token, db)
    if not user:
        raise HTTPException(status_code=401, detail="Ungültiger Token")
    return user

@app.get("/me")
async def read_current_user(current_user: User = Depends(get_current_user)):
    return current_user

Einmal definiert, ist get_current_user auf jeden geschützten Endpoint anwendbar — mit einer einzigen Zeile. Claude Code kann solche Dependency-Chains lesen und neue Endpoints automatisch korrekt einbinden.

5. Async/Await: Hintergrundaufgaben und async Endpoints

FastAPI unterstützt sowohl synchrone als auch asynchrone Endpoints. Für I/O-lastige Operationen — Datenbankabfragen, externe API-Calls, Datei-Operationen — sind async Endpoints der richtige Weg:

import httpx

@app.get("/exchange-rate/{currency}")
async def get_exchange_rate(currency: str):
    async with httpx.AsyncClient() as client:
        response = await client.get(f"https://api.example.com/rates/{currency}")
        return response.json()

Für Aufgaben, die nach dem Response weiterlaufen sollen — E-Mail versenden, Cache aktualisieren, Logging — gibt es BackgroundTasks:

from fastapi import BackgroundTasks

def send_welcome_email(email: str):
    # Email-Versand im Hintergrund
    email_client.send(to=email, subject="Willkommen!")

@app.post("/users/")
async def create_user(user: UserCreate, background_tasks: BackgroundTasks, db: Session = Depends(get_db)):
    db_user = create_user_in_db(db, user)
    background_tasks.add_task(send_welcome_email, user.email)
    return db_user

Der Response geht sofort zurück — der Nutzer wartet nicht auf den E-Mail-Versand.

6. JWT-Authentifizierung implementieren

JWT-Auth ist ein häufiges Muster in FastAPI-Projekten. Die Grundstruktur:

pip install python-jose[cryptography] passlib[bcrypt]

from jose import JWTError, jwt
from passlib.context import CryptContext
from datetime import datetime, timedelta

SECRET_KEY = "dein-geheimer-schluessel"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

def create_access_token(data: dict):
    to_encode = data.copy()
    expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
    to_encode.update({"exp": expire})
    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)

@app.post("/token")
async def login(form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_db)):
    user = authenticate_user(db, form_data.username, form_data.password)
    if not user:
        raise HTTPException(status_code=401, detail="Falsche Zugangsdaten")
    token = create_access_token({"sub": user.email})
    return {"access_token": token, "token_type": "bearer"}

7. Claude Code FastAPI: Konkrete Tipps für den Alltag

Nach Monaten mit Claude Code FastAPI im produktiven Einsatz die wichtigsten Erkenntnisse:

Endpoints aus Beschreibung generieren

Der direkteste Weg: Beschreibe die Geschäftslogik, Claude Code baut den Endpoint:

claude "Erstelle einen FastAPI-Endpoint POST /orders, der:
- Einen eingeloggten Nutzer erwartet (JWT)
- Prüft ob alle Produkte im Lager verfügbar sind
- Die Bestellung in der DB speichert
- Den Lagerbestand reduziert (atomarer DB-Vorgang)
- Eine Bestätigungs-E-Mail im Hintergrund sendet
- HTTP 201 mit der erstellten Bestellung zurückgibt"

Tests automatisch schreiben lassen

FastAPI hat eine eingebaute Test-Integration über TestClient. Claude Code kennt das Pattern:

claude "Schreibe pytest-Tests für alle Product-Endpoints in products.py.
Nutze TestClient, mocke die Datenbankverbindung und teste:
- Happy Path, fehlende Felder, ungültige Typen, 404-Fall"

Pydantic-Schemas aus bestehenden Models ableiten

claude "Ich habe dieses SQLAlchemy-Model: [Model einfügen].
Erstelle die passenden Pydantic-Schemas: Base, Create, Update, Response.
Response soll keine internen Felder (password_hash, deleted_at) enthalten."

OpenAPI-Schema verstehen und erweitern

Claude Code kann auch das generierte OpenAPI-Schema lesen und Schwachstellen identifizieren: fehlende Beschreibungen, nicht dokumentierte Fehlercodes, inkonsistente Benennung. Ein Audit mit Claude Code dauert Minuten statt Stunden.

"Der größte Zeitgewinn ist nicht das Generieren von Boilerplate — das ist nett, aber nicht entscheidend. Der echte Gewinn ist, dass Claude Code den Gesamtkontext des Projekts kennt: bestehende Models, Dependency-Struktur, Auth-Setup. Neue Endpoints passen sich automatisch ein."

Zwei verwandte Artikel, die dieses Thema vertiefen:

• Claude Code für Python-Projekte — allgemeine Python-Workflows mit Claude Code
• Claude Code Debugging — Bugs in FastAPI-Anwendungen systematisch finden