Créer une API avec FastAPI et Claude Code : le guide complet 2026

FastAPI et Claude Code : le duo Python pour créer une API rapide sans galérer

FastAPI est devenu en quelques années le framework de référence pour construire des API en Python. Sa promesse tient en trois mots : rapide, moderne, typé. Grâce à l'asynchrone (ASGI) et à la validation automatique via Pydantic, il rivalise en performance avec Node.js et Go, tout en générant gratuitement une documentation interactive (Swagger UI). C'est le framework qui alimente aujourd'hui la majorité des backends d'applications IA, des microservices et des API mobiles. Mais entre les modèles Pydantic, l'injection de dépendances, l'ORM, l'authentification JWT et le déploiement ASGI, monter une API complète reste intimidant quand on débute.

En 2026, Claude Code change la donne. Cet agent de développement autonome, piloté en langage naturel depuis le terminal, sait échafauder un projet FastAPI, écrire les routes, brancher une base de données, sécuriser vos endpoints et vous accompagner jusqu'au déploiement. Vous décrivez ce que vous voulez en français, l'agent produit du code Python idiomatique et typé. Ce guide montre, étape par étape, comment créer une API avec FastAPI et Claude Code : installation, CLAUDE.md, routes, Pydantic, base de données, authentification, tests et mise en production. Si vous découvrez l'agent, gardez à portée notre guide complet de Claude Code, qui pose les bases du travail en mode agent.

Sommaire

Pourquoi FastAPI est un terrain idéal pour Claude Code<a id="pourquoi-fastapi"></a>

FastAPI est particulièrement adapté au développement assisté par IA, pour plusieurs raisons concrètes.

D'abord, le typage explicite partout. FastAPI s'appuie sur les annotations de type Python et sur Pydantic pour décrire les entrées et sorties. Ce contrat clair réduit énormément les ambiguïtés : Claude Code sait exactement quelles données circulent, et le typage sert de garde-fou contre les hallucinations.

Ensuite, des conventions fortes et stables. Une route est une fonction décorée, un modèle est une classe Pydantic, une dépendance s'injecte avec Depends. Ce socle bien défini permet à l'agent de générer du code conforme aux pratiques officielles, pas un patchwork improbable.

Enfin, une boucle de vérification immédiate. FastAPI génère automatiquement une documentation Swagger à l'adresse /docs. Après chaque endpoint généré, l'agent (ou vous) peut tester la route directement dans le navigateur. Résultat : les cycles « je décris, l'agent code, je teste, l'agent corrige » sont rapides et fiables. Cette philosophie rejoint celle décrite dans notre guide pour créer une API REST avec Node.js et Express — utile si vous hésitez encore sur la stack.

Installer Python, FastAPI et Claude Code en 2026<a id="installation"></a>

FastAPI s'appuie sur Python 3.11 ou supérieur. Vérifiez votre version :

python3 --version   # 3.11+ recommandé

Installez ensuite Claude Code en global via npm :

npm install -g @anthropic-ai/claude-code
claude --version

Au premier lancement, l'agent vous demande de vous authentifier (abonnement Claude Pro/Max ou clé API). Si vous êtes sous Windows, l'installation passe idéalement par WSL : suivez notre guide d'installation de Claude Code sur Mac, Windows et Linux pour éviter les pièges classiques.

Créer le squelette du projet et l'environnement virtuel<a id="squelette"></a>

En Python, on isole toujours les dépendances dans un environnement virtuel. Ouvrez Claude Code dans un dossier vide et demandez :

« Initialise un projet FastAPI. Crée un environnement virtuel avec venv, installe fastapi et uvicorn, crée un fichier main.py avec une route d'accueil, puis lance le serveur pour vérifier que tout fonctionne. »

L'agent va exécuter les commandes, structurer le projet et démarrer le serveur. Les commandes sous-jacentes ressemblent à :

python3 -m venv .venv
source .venv/bin/activate        # sous Windows : .venv\Scripts\activate
pip install "fastapi[standard]" uvicorn

Un premier main.py minimal produit par l'agent ressemble à ceci :

from fastapi import FastAPI

app = FastAPI(title="Mon API")

@app.get("/")
def accueil():
    return {"message": "API en ligne"}

Lancez le serveur avec uvicorn main:app --reload, puis ouvrez http://127.0.0.1:8000/docs. La documentation Swagger interactive est déjà là, sans une ligne de configuration. Prenez l'habitude de laisser l'agent vérifier son travail : lancer le serveur, appeler la route, confirmer l'absence d'erreur. C'est cette boucle de vérification qui distingue un vrai workflow agentique d'une simple génération de code à l'aveugle.

Le fichier CLAUDE.md, cerveau de votre projet FastAPI<a id="claude-md"></a>

Avant de générer la moindre fonctionnalité, créez un fichier CLAUDE.md à la racine. C'est la mémoire de projet que l'agent lit automatiquement à chaque session : vos conventions y sont gravées une fois pour toutes.

# Projet : Mon API FastAPI

## Stack
- Python 3.11, FastAPI, Uvicorn
- Pydantic v2 pour la validation
- SQLModel + SQLite (PostgreSQL en production)
- Authentification JWT via OAuth2
- pytest + httpx pour les tests

## Conventions
- Routes asynchrones (async def) par défaut
- Modèles Pydantic pour toutes les entrées/sorties
- Séparer routes (routers/), modèles (models.py), logique (services/)
- Variables sensibles dans .env, jamais en dur
- Typage strict : annoter tous les paramètres et retours

## Commandes
- Lancer : uvicorn main:app --reload
- Tests : pytest
- Dépendances : pip install -r requirements.txt

Ce fichier évite les allers-retours : l'agent sait d'emblée qu'il doit écrire des routes asynchrones, valider avec Pydantic et respecter votre arborescence. Pour aller plus loin sur cet outil décisif, consultez notre guide complet du fichier CLAUDE.md.

Du prompt à la route : premiers endpoints<a id="routes"></a>

Place au concret. Construisons une API de gestion de tâches. Demandez à Claude Code :

« Crée un routeur `taches` avec les endpoints CRUD complets : lister les tâches, en créer une, en récupérer une par son id, la mettre à jour et la supprimer. Utilise des routes asynchrones et un stockage en mémoire pour l'instant. »

L'agent produit un routeur idiomatique, monté dans l'application principale :

from fastapi import APIRouter, HTTPException

router = APIRouter(prefix="/taches", tags=["taches"])
taches: list[dict] = []

@router.get("/")
async def lister():
    return taches

@router.post("/", status_code=201)
async def creer(tache: dict):
    tache["id"] = len(taches) + 1
    taches.append(tache)
    return tache

@router.get("/{tache_id}")
async def recuperer(tache_id: int):
    for t in taches:
        if t["id"] == tache_id:
            return t
    raise HTTPException(status_code=404, detail="Tâche introuvable")

Chaque endpoint apparaît instantanément dans Swagger, prêt à être testé. On voit ici tout l'intérêt de l'agent : il connaît les codes de statut HTTP corrects (201 à la création, 404 quand une ressource n'existe pas) et le gestionnaire d'exceptions de FastAPI.

Valider les données avec Pydantic<a id="pydantic"></a>

Le stockage dict fonctionne, mais il n'offre aucune garantie sur la forme des données. C'est là qu'intervient Pydantic, le cœur de FastAPI. Demandez à l'agent :

« Remplace les dictionnaires par des modèles Pydantic : un modèle `TacheCreer` pour l'entrée (libellé obligatoire, priorité optionnelle) et un modèle `Tache` pour la sortie avec un id. Applique-les aux routes. »

L'agent génère des classes typées et branche la validation automatiquement :

from pydantic import BaseModel, Field

class TacheCreer(BaseModel):
    libelle: str = Field(min_length=1, max_length=200)
    priorite: int = Field(default=1, ge=1, le=5)

class Tache(TacheCreer):
    id: int
    terminee: bool = False

Désormais, si un client envoie un libellé vide ou une priorité de 10, FastAPI renvoie automatiquement une erreur 422 détaillée, sans une seule ligne de code de validation à écrire. C'est l'un des grands atouts du framework : la validation est déclarative. Pour enrichir vos endpoints avec de vraies données externes, une API spécialisée comme immoAPI fournit des jeux de données structurés que Claude Code sait intégrer à vos modèles Pydantic en quelques minutes.

Brancher une base de données avec SQLModel<a id="base-de-donnees"></a>

Pour persister les données, le plus simple avec FastAPI est SQLModel, une bibliothèque signée par le créateur de FastAPI qui fusionne Pydantic et SQLAlchemy. Demandez :

« Ajoute SQLModel avec une base SQLite. Transforme le modèle Tache en table, crée la session de base de données en dépendance injectable et branche-la sur les routes CRUD. »

L'agent installe la dépendance, définit le moteur, crée les tables au démarrage et injecte la session via Depends. Vous obtenez une persistance réelle sans jongler manuellement avec les curseurs SQL. Précisez dans votre CLAUDE.md que la production utilise PostgreSQL (avec le pilote asynchrone asyncpg), et l'agent adaptera la chaîne de connexion. Si vous voulez comparer avec une approche « batteries incluses », notre guide créer une application web Django avec Claude Code détaille l'ORM et les migrations côté Django.

Sécuriser l'API : authentification JWT<a id="securite"></a>

Une API publique doit protéger ses endpoints sensibles. FastAPI intègre nativement le schéma OAuth2 avec token JWT. Demandez à l'agent :

« Ajoute l'authentification par token JWT : un endpoint /login qui vérifie l'utilisateur et renvoie un token, le hachage des mots de passe avec passlib et bcrypt, et une dépendance qui protège les routes nécessitant une connexion. »

Claude Code met en place OAuth2PasswordBearer, la génération et la vérification du token avec la bibliothèque python-jose, et une dépendance utilisateur_courant que vous ajoutez aux routes à protéger. Pensez à stocker la clé secrète dans un fichier .env chargé par pydantic-settings, jamais en dur. La sécurité des API générées par IA est un sujet sérieux : notre article sur la sécurité des assistants IA de code rappelle les réflexes indispensables avant toute mise en production.

Tester votre API avec pytest<a id="tests"></a>

Une API sans tests est une API fragile. FastAPI fournit un TestClient qui simule les requêtes HTTP. Demandez :

« Écris des tests pytest pour les endpoints des tâches : création, récupération, cas d'erreur 404 et validation 422. Utilise le TestClient de FastAPI. »

L'agent génère une suite complète :

from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_creer_tache():
    reponse = client.post("/taches/", json={"libelle": "Test"})
    assert reponse.status_code == 201
    assert reponse.json()["libelle"] == "Test"

def test_tache_introuvable():
    assert client.get("/taches/9999").status_code == 404

Lancez pytest et laissez l'agent corriger les éventuels échecs. Cette boucle test-correction est l'un des workflows où Claude Code brille le plus : il lit le message d'erreur, comprend la cause et ajuste le code.

Déployer votre API FastAPI<a id="deploiement"></a>

Une fois l'API testée, place à la mise en production. Une application FastAPI se sert derrière un serveur ASGI comme Uvicorn ou Gunicorn, souvent conteneurisée avec Docker. Demandez à l'agent de générer un Dockerfile et un fichier requirements.txt, puis déployez sur une plateforme comme Railway, Render, Fly.io ou votre propre serveur.

Pour un contrôle total et l'auto-hébergement de vos services IA, la ressource formation OpenClaw explore les stratégies d'agents open-source et d'infrastructure auto-hébergée, complémentaires d'une API que vous voulez garder chez vous. Et pour les plateformes managées, notre guide déployer une application avec Claude Code sur Vercel et Netlify couvre l'automatisation du déploiement.

Voir Claude Code à l'œuvre en vidéo

Si vous débutez avec l'agent, cette formation de la chaîne Sophiène IA vous emmène de zéro jusqu'à un usage avancé de Claude Code en moins d'une heure. Un excellent complément à ce guide : vous y verrez concrètement comment l'agent enchaîne les tâches, corrige ses erreurs et travaille dans le terminal — exactement la boucle que nous utilisons ici pour construire une API FastAPI.

FastAPI ou Django avec Claude Code ?<a id="fastapi-vs-django"></a>

Les deux frameworks sont parfaitement maîtrisés par l'agent, mais ils ne visent pas la même chose.

FastAPI est spécialisé dans les API. Léger, asynchrone, ultra-rapide, il produit une documentation OpenAPI automatique et brille pour les microservices, les backends d'applications mobiles et les API qui exposent un modèle d'IA. C'est le choix par défaut en 2026 pour une API moderne et performante.

Django (avec Django REST Framework) est un framework complet « batteries incluses » : ORM mature, interface d'administration prête à l'emploi, authentification riche. Il convient mieux à une application web full-stack avec back-office et pages rendues côté serveur.

En résumé : pour une API pure et rapide, choisissez FastAPI ; pour une application web complète avec administration, penchez vers Django. Claude Code vous accompagne dans les deux cas — et sait même migrer de l'un à l'autre si votre projet évolue.

Bonnes pratiques et pièges à éviter<a id="bonnes-pratiques"></a>

Quelques réflexes pour tirer le meilleur de Claude Code sur un projet FastAPI :

En suivant cette méthode, vous passez d'une idée à une API FastAPI documentée, sécurisée et testée en une fraction du temps habituel. L'agent gère le code répétitif ; vous gardez la vision produit et le contrôle qualité.

Automatisez votre développement d'API avec l'IA

Créer une API n'est qu'un début. Claude Code peut automatiser une part croissante de votre travail de développeur : génération de code, tests, revue, déploiement. Pour aller plus loin et transformer votre façon de coder, découvrez comment vous faire remplacer par l'IA sur les tâches répétitives et concentrer votre énergie sur ce qui compte vraiment.

Pour aller plus loin