Lors de la création de l'objet application, un *chemin d'accès* pour `/openapi.json` (ou pour l'URL que vous avez définie dans votre `openapi_url`) est enregistré.

Il renvoie simplement une réponse JSON avec le résultat de la méthode `.openapi()` de l'application.

Par défaut, la méthode `.openapi()` vérifie la propriété `.openapi_schema` pour voir si elle contient des données et les renvoie.

</details>

### Vérifier { #check-it }

Ouvrez votre navigateur à l'adresse [http://127.0.0.1:8000/items/5?q=somequery](http://127.0.0.1:8000/items/5?q=somequery).

Vous verrez la réponse JSON :

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

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

* Reçoit des requêtes HTTP sur les _chemins_ `/` et `/items/{item_id}`.

## JSON Lines { #json-lines }

Dans ces cas, il est courant d'envoyer des « JSON Lines », qui est un format où vous envoyez un objet JSON par ligne.

Une réponse aurait un type de contenu `application/jsonl` (au lieu de `application/json`) et le corps ressemblerait à ceci :

```json
{"name": "Plumbus", "description": "A multi-purpose household device."}

Vous aurez de nombreux, nombreux utilisateurs, mais votre serveur attendra 🕙 que leur connexion peu performante envoie des requêtes.

Puis vous attendrez 🕙 de nouveau que leurs réponses reviennent.

Cette « attente » 🕙 se mesure en microsecondes, mais tout de même, en cumulé cela fait beaucoup d'attente.

C'est pourquoi il est logique d'utiliser du code asynchrone ⏸🔀⏯ pour des APIs web.

## Attribution

Vous pourriez aussi utiliser `from starlette.responses import HTMLResponse`.

**FastAPI** fournit les mêmes `starlette.responses` sous `fastapi.responses` simplement pour votre convenance en tant que développeur. Mais la plupart des réponses disponibles proviennent directement de Starlette.

///

### Téléversements multiples avec métadonnées supplémentaires { #multiple-file-uploads-with-additional-metadata }

* Prise en charge des **WebSocket**.
* Tâches d'arrière-plan dans le processus.
* Évènements de démarrage et d'arrêt.
* Client de test basé sur HTTPX.
* **CORS**, GZip, fichiers statiques, réponses en streaming.
* Prise en charge des **Sessions et Cookies**.
* Couverture de test à 100 %.
* Base de code annotée à 100 % avec des types.

## Fonctionnalités de Pydantic { #pydantic-features }

        // Should not affect IP limiting
        rateLimiter.recordFailure(null, "192.168.1.8");
        assertTrue(rateLimiter.checkAttempt("realuser", "192.168.1.8"), "Should still track IP");
    }

    @Test
    public void testNullIp() throws Exception {
        // Null IP should be handled gracefully

			t.Fatal(err)
		}
		_, err = globalIAMSys.PolicyDBSet(ctx, accessKey, testKMSPolicyName, regUser, false)
		if err != nil {
			t.Fatal(err)
		}
	} else {
		err = globalIAMSys.DeletePolicy(ctx, testKMSPolicyName, false)
		if err != nil {
			t.Fatal(err)
		}
		_, err = globalIAMSys.PolicyDBSet(ctx, accessKey, "", regUser, false)
		if err != nil {
			t.Fatal(err)
		}
	}

If the intention is to gather user feedback on an early prototype, then the experimental property should be used.
If the intention is to allow an issue reporter to get additional local diagnostics when running a build in their proprietary environment, then the internal property is sufficient.

Examples of properties that follow the naming rules: