tiangolo.fastapi/docs/fr/docs/index.md

FastAPI

Framework FastAPI, haute performance, facile à apprendre, rapide à coder, prêt pour la production

---

Documentation : https://fastapi.tiangolo.com/fr

Code source : https://github.com/fastapi/fastapi

---

FastAPI est un framework web moderne et rapide (haute performance) pour la création d’API avec Python, basé sur les annotations de type standard de Python.

Les principales fonctionnalités sont :

• Rapide : Très hautes performances, au niveau de NodeJS et Go (grâce à Starlette et Pydantic). L’un des frameworks Python les plus rapides.
• Rapide à coder : Augmente la vitesse de développement des fonctionnalités d’environ 200 % à 300 %. *
• Moins de bugs : Réduit d’environ 40 % les erreurs induites par le développeur. *
• Intuitif : Excellente prise en charge par les éditeurs. Complétion partout. Moins de temps passé à déboguer.
• Facile : Conçu pour être facile à utiliser et à apprendre. Moins de temps passé à lire la documentation.
• Concis : Minimise la duplication de code. Plusieurs fonctionnalités à partir de chaque déclaration de paramètre. Moins de bugs.
• Robuste : Obtenez du code prêt pour la production. Avec une documentation interactive automatique.
• Basé sur des standards : Basé sur (et entièrement compatible avec) les standards ouverts pour les API : OpenAPI (anciennement connu sous le nom de Swagger) et JSON Schema.

* estimation basée sur des tests d’une équipe de développement interne, construisant des applications de production.

Sponsors

Sponsor clé de voûte

{% for sponsor in sponsors.keystone -%} {% endfor -%}

Sponsors Or et Argent

{% for sponsor in sponsors.gold -%} {% endfor -%} {%- for sponsor in sponsors.silver -%} {% endfor %}

Autres sponsors

Opinions

«[...] J’utilise beaucoup FastAPI ces derniers temps. [...] Je prévois de l’utiliser dans mon équipe pour tous les services de ML chez Microsoft. Certains d’entre eux seront intégrés dans le cœur de Windows et dans certains produits Office.»

Kabir Khan - Microsoft (ref)

---

«Nous avons adopté la bibliothèque FastAPI pour créer un serveur REST qui peut être interrogé pour obtenir des prédictions. [pour Ludwig]»

Piero Molino, Yaroslav Dudin et Sai Sumanth Miryala - Uber (ref)

---

«Netflix a le plaisir d’annoncer la sortie en open-source de notre framework d’orchestration de gestion de crise : Dispatch ! [construit avec FastAPI]»

Kevin Glisson, Marc Vilanova, Forest Monsen - Netflix (ref)

---

«Je suis très enthousiaste à propos de FastAPI. C’est un bonheur !»

Brian Okken - Animateur du podcast Python Bytes (ref)

---

«Honnêtement, ce que vous avez construit a l’air super solide et élégant. À bien des égards, c’est comme ça que je voulais que Hug soit — c’est vraiment inspirant de voir quelqu’un construire ça.»

Timothy Crosley - Créateur de Hug (ref)

---

«Si vous cherchez à apprendre un framework moderne pour créer des API REST, regardez FastAPI [...] C’est rapide, facile à utiliser et à apprendre [...]»

«Nous sommes passés à FastAPI pour nos API [...] Je pense que vous l’aimerez [...]»

Ines Montani - Matthew Honnibal - Fondateurs de Explosion AI — Créateurs de spaCy (ref) - (ref)

---

«Si quelqu’un cherche à construire une API Python de production, je recommande vivement FastAPI. Il est bien conçu, simple à utiliser et très évolutif, il est devenu un composant clé dans notre stratégie de développement API first et il est à l’origine de nombreux automatismes et services tels que notre ingénieur virtuel TAC.»

Deon Pillsbury - Cisco (ref)

---

Mini documentaire FastAPI

Un mini documentaire FastAPI est sorti à la fin de 2025, vous pouvez le regarder en ligne :

Typer, le FastAPI des CLI

Si vous souhaitez construire une application CLI utilisable dans un terminal au lieu d’une API web, regardez Typer.

Typer est le petit frère de FastAPI. Et il est destiné à être le FastAPI des CLI. ⌨️ 🚀

Prérequis

FastAPI repose sur les épaules de géants :

• Starlette pour les parties web.
• Pydantic pour les parties données.

Installation

Créez et activez un environnement virtuel puis installez FastAPI :

$ pip install "fastapi[standard]"

---> 100%

Remarque : Assurez-vous de mettre "fastapi[standard]" entre guillemets pour garantir que cela fonctionne dans tous les terminaux.

Exemple

Créer

Créez un fichier main.py avec :

from typing import Union

from fastapi import FastAPI

app = FastAPI()


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


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

Ou utilisez async def...

Si votre code utilise async / await, utilisez async def :

from typing import Union

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def read_root():
    return {"Hello": "World"}


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

Remarque :

Si vous ne savez pas, consultez la section «In a hurry?» à propos de async et await dans la documentation.

Lancer

Lancez le serveur avec :

$ fastapi dev main.py

 ╭────────── FastAPI CLI - Development mode ───────────╮
 │                                                     │
 │  Serving at: http://127.0.0.1:8000                  │
 │                                                     │
 │  API docs: http://127.0.0.1:8000/docs               │
 │                                                     │
 │  Running in development mode, for production use:   │
 │                                                     │
 │  fastapi run                                        │
 │                                                     │
 ╰─────────────────────────────────────────────────────╯

INFO:     Will watch for changes in these directories: ['/home/user/code/awesomeapp']
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [2248755] using WatchFiles
INFO:     Started server process [2248757]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

À propos de la commande fastapi dev main.py...

La commande fastapi dev lit votre fichier main.py, détecte l’application FastAPI qu’il contient et démarre un serveur avec Uvicorn.

Par défaut, fastapi dev démarre avec le rechargement automatique activé pour le développement local.

Vous pouvez en lire davantage dans la documentation de la CLI FastAPI.

Vérifier

Ouvrez votre navigateur à l’adresse http://127.0.0.1:8000/items/5?q=somequery.

Vous verrez la réponse JSON :

{"item_id": 5, "q": "somequery"}

Vous avez déjà créé une API qui :

• Reçoit des requêtes HTTP pour les chemins / et /items/{item_id}.
• Les deux chemins acceptent des opérations GET (également connues comme méthodes HTTP).
• Le chemin /items/{item_id} a un paramètre de chemin item_id qui doit être un int.
• Le chemin /items/{item_id} a un paramètre de requête optionnel q de type str.

Documentation API interactive

Maintenant, allez sur http://127.0.0.1:8000/docs.

Vous verrez la documentation API interactive automatique (fournie par Swagger UI) :

Documentation API alternative

Et maintenant, allez sur http://127.0.0.1:8000/redoc.

Vous verrez la documentation automatique alternative (fournie par ReDoc) :

Exemple de mise à niveau

Modifiez maintenant le fichier main.py pour recevoir le corps d’une requête PUT.

Déclarez le corps en utilisant les types Python standards, grâce à Pydantic.

from typing import Union

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    price: float
    is_offer: Union[bool, None] = None


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


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


@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    return {"item_name": item.name, "item_id": item_id}

Le serveur fastapi dev devrait se recharger automatiquement.

Mise à niveau de la documentation API interactive

Maintenant, allez sur http://127.0.0.1:8000/docs.

• La documentation API interactive sera automatiquement mise à jour, y compris le nouveau corps :

• Cliquez sur le bouton «Try it out», il vous permet de renseigner les paramètres et d’interagir directement avec l’API :

• Cliquez ensuite sur le bouton «Execute», l’interface utilisateur communiquera avec votre API, enverra les paramètres, obtiendra les résultats et les affichera à l’écran :

Mise à niveau de la documentation API alternative

Et maintenant, allez sur http://127.0.0.1:8000/redoc.

• La documentation alternative reflètera également le nouveau paramètre de requête et le nouveau corps :

Récapitulatif

En résumé, vous déclarez une fois les types de paramètres, le corps, etc. comme paramètres de fonction.

Vous faites cela avec les types Python modernes standards.

Vous n’avez pas à apprendre une nouvelle syntaxe, les méthodes ou classes d’une bibliothèque spécifique, etc.

Juste du Python standard.

Par exemple, pour un int :

item_id: int

ou pour un modèle Item plus complexe :

item: Item

... et avec cette seule déclaration vous obtenez :

• Assistance de l’éditeur, notamment :
  • Complétion.
  • Vérifications de type.
• Validation des données :
  • Des erreurs automatiques et claires lorsque les données ne sont pas valides.
  • Une validation même pour des objets JSON profondément imbriqués.
• Conversion des données d’entrée : depuis le réseau vers les données et types Python. Lecture depuis :
  • JSON.
  • Paramètres de chemin.
  • Paramètres de requête.
  • Cookies.
  • En-têtes.
  • Formulaires.
  • Fichiers.
• Conversion des données de sortie : conversion des données et types Python en données réseau (au format JSON) :
  • Conversion des types Python (str, int, float, bool, list, etc).
  • Objets datetime.
  • Objets UUID.
  • Modèles de base de données.
  • ... et bien plus.
• Documentation API interactive automatique, avec 2 interfaces utilisateur alternatives :
  • Swagger UI.
  • ReDoc.

---

Pour revenir à l’exemple de code précédent, FastAPI va :

• Valider la présence d’un item_id dans le chemin pour les requêtes GET et PUT.
• Valider que item_id est de type int pour les requêtes GET et PUT.
  • Si ce n’est pas le cas, le client verra une erreur utile et claire.
• Vérifier s’il existe un paramètre de requête optionnel nommé q (comme dans http://127.0.0.1:8000/items/foo?q=somequery) pour les requêtes GET.
  • Comme le paramètre q est déclaré avec = None, il est optionnel.
  • Sans le None, il serait requis (comme l’est le corps dans le cas du PUT).
• Pour les requêtes PUT vers /items/{item_id}, lire le corps en JSON :
  • Vérifier qu’il possède un attribut obligatoire name qui doit être un str.
  • Vérifier qu’il possède un attribut obligatoire price qui doit être un float.
  • Vérifier qu’il possède un attribut optionnel is_offer, qui doit être un bool, s’il est présent.
  • Tout cela fonctionnerait également pour des objets JSON profondément imbriqués.
• Convertir depuis et vers JSON automatiquement.
• Tout documenter avec OpenAPI, qui peut être utilisé par :
  • Des systèmes de documentation interactive.
  • Des systèmes de génération automatique de code client, pour de nombreuses langues.
• Fournir directement 2 interfaces web de documentation interactive.

---

Nous n’avons fait qu’effleurer la surface, mais vous comprenez déjà l’idée de fonctionnement général.

Essayez de changer la ligne :

    return {"item_name": item.name, "item_id": item_id}

... de :

        ... "item_name": item.name ...

... vers :

        ... "item_price": item.price ...

... et voyez comment votre éditeur complètera automatiquement les attributs et connaîtra leurs types :

Pour un exemple plus complet incluant davantage de fonctionnalités, voir le Tutoriel - Guide utilisateur.

Alerte spoiler : le tutoriel - guide utilisateur inclut :

• Déclaration de paramètres provenant d’autres endroits tels que : en-têtes, cookies, champs de formulaire et fichiers.
• Comment définir des contraintes de validation comme maximum_length ou regex.
• Un système de Injection de dépendances très puissant et facile à utiliser.
• Sécurité et authentification, y compris la prise en charge de OAuth2 avec les jetons JWT et l’authentification HTTP Basic.
• Des techniques plus avancées (mais tout aussi simples) pour déclarer des modèles JSON profondément imbriqués (grâce à Pydantic).
• Intégration GraphQL avec Strawberry et d’autres bibliothèques.
• De nombreuses fonctionnalités supplémentaires (grâce à Starlette) comme :
  • WebSockets
  • des tests extrêmement faciles basés sur HTTPX et pytest
  • CORS
  • Sessions Cookie
  • ... et plus encore.

Déployer votre application (optionnel)

Vous pouvez éventuellement déployer votre application FastAPI sur FastAPI Cloud, allez vous inscrire sur la liste d’attente si ce n’est pas déjà fait. 🚀

Si vous avez déjà un compte FastAPI Cloud (nous vous avons invité depuis la liste d’attente 😉), vous pouvez déployer votre application avec une seule commande.

Avant de déployer, assurez-vous d’être connecté :

$ fastapi login

You are logged in to FastAPI Cloud 🚀

Puis déployez votre application :

$ fastapi deploy

Deploying to FastAPI Cloud...

✅ Deployment successful!

🐔 Ready the chicken! Your app is ready at https://myapp.fastapicloud.dev

C’est tout ! Vous pouvez maintenant accéder à votre application à cette URL. ✨

À propos de FastAPI Cloud

FastAPI Cloud est créé par le même auteur et la même équipe derrière FastAPI.

Il simplifie le processus de construction, de déploiement et d’accès à une API avec un minimum d’efforts.

Il apporte la même expérience développeur de la création d’applications avec FastAPI au déploiement dans le cloud. 🎉

FastAPI Cloud est le sponsor principal et le financeur des projets open source FastAPI and friends. ✨

Déployer sur d’autres fournisseurs cloud

FastAPI est open source et basé sur des standards. Vous pouvez déployer des applications FastAPI sur n’importe quel fournisseur cloud de votre choix.

Suivez les guides de votre fournisseur cloud pour y déployer des applications FastAPI. 🤓

Performance

Les benchmarks indépendants TechEmpower montrent que les applications FastAPI s’exécutant sous Uvicorn sont parmi les frameworks Python les plus rapides, juste derrière Starlette et Uvicorn eux-mêmes (utilisés en interne par FastAPI). (*)

Pour en savoir plus, consultez la section Benchmarks.

Dépendances

FastAPI dépend de Pydantic et Starlette.

Dépendances standard

Lorsque vous installez FastAPI avec pip install "fastapi[standard]", cela inclut le groupe standard de dépendances optionnelles :

Utilisées par Pydantic :

• email-validator — pour la validation des adresses email.

Utilisées par Starlette :

• httpx — requis si vous souhaitez utiliser TestClient.
• jinja2 — requis si vous souhaitez utiliser la configuration de template par défaut.
• python-multipart — requis si vous souhaitez prendre en charge l’«décodage» de formulaires avec request.form().

Utilisées par FastAPI :

• uvicorn — pour le serveur qui charge et sert votre application. Cela inclut uvicorn[standard], qui comprend certaines dépendances (par ex. uvloop) nécessaires pour un service à haute performance.
• fastapi-cli[standard] — pour fournir la commande fastapi.
  • Cela inclut fastapi-cloud-cli, qui vous permet de déployer votre application FastAPI sur FastAPI Cloud.

Sans dépendances standard

Si vous ne souhaitez pas inclure les dépendances optionnelles standard, vous pouvez installer avec pip install fastapi au lieu de pip install "fastapi[standard]".

Sans fastapi-cloud-cli

Si vous souhaitez installer FastAPI avec les dépendances standard mais sans fastapi-cloud-cli, vous pouvez installer avec pip install "fastapi[standard-no-fastapi-cloud-cli]".

Autres dépendances optionnelles

Il existe des dépendances supplémentaires que vous pourriez vouloir installer.

Dépendances optionnelles supplémentaires pour Pydantic :

• pydantic-settings — pour la gestion des paramètres.
• pydantic-extra-types — pour des types supplémentaires à utiliser avec Pydantic.

Dépendances optionnelles supplémentaires pour FastAPI :

• orjson — requis si vous souhaitez utiliser ORJSONResponse.
• ujson — requis si vous souhaitez utiliser UJSONResponse.

Licence

Ce projet est soumis aux termes de la licence MIT.