diff --git a/docs/en/mkdocs.yml b/docs/en/mkdocs.yml
index 6f1e12511..528c80b8e 100644
--- a/docs/en/mkdocs.yml
+++ b/docs/en/mkdocs.yml
@@ -363,6 +363,8 @@ extra:
name: ja - 日本語
- link: /ko/
name: ko - 한국어
+ - link: /nl/
+ name: nl - Nederlands
- link: /pl/
name: pl - Polski
- link: /pt/
diff --git a/docs/nl/docs/index.md b/docs/nl/docs/index.md
new file mode 100644
index 000000000..8edc3ba0c
--- /dev/null
+++ b/docs/nl/docs/index.md
@@ -0,0 +1,494 @@
+# FastAPI
+
+
+
+
+ 
+
+
+ FastAPI framework, zeer goede prestaties, eenvoudig te leren, snel te programmeren, klaar voor productie
+
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+
+---
+
+**Documentatie**: https://fastapi.tiangolo.com
+
+**Broncode**: https://github.com/tiangolo/fastapi
+
+---
+
+FastAPI is een modern, snel (zeer goede prestaties), web framework voor het bouwen van API's in Python, gebruikmakend van standaard Python type-hints.
+
+De belangrijkste kenmerken zijn:
+
+* **Snel**: Zeer goede prestaties, vergelijkbaar met **NodeJS** en **Go** (dankzij Starlette en Pydantic). [Een van de snelste beschikbare Python frameworks](#prestaties).
+* **Snel te programmeren**: Verhoog de snelheid om functionaliteit te ontwikkelen met ongeveer 200% tot 300%. *
+* **Minder bugs**: Verminder ongeveer 40% van de door mensen (ontwikkelaars) veroorzaakte fouten. *
+* **Intuïtief**: Buitengewoon goede ondersteuning voor editors. Overal automische code aanvulling. Minder tijd kwijt aan debuggen.
+* **Eenvoudig**: Ontworpen om gemakkelijk te gebruiken en te leren. Minder tijd nodig om documentatie te lezen.
+* **Kort**: Minimaliseer codeduplicatie. Elke parameterdeclaratie ondersteunt meerdere functionaliteiten. Minder bugs.
+* **Robust**: Code gereed voor productie. Met automatische interactieve documentatie.
+* **Standards-based**: Gebaseerd op (en volledig verenigbaar met) open standaarden voor API's: OpenAPI (voorheen bekend als Swagger) en JSON Schema.
+
+* schatting op basis van testen met een intern ontwikkelteam en bouwen van productieapplicaties.
+
+## Sponsors
+
+
+
+{% if sponsors %}
+{% for sponsor in sponsors.gold -%}
+
+{% endfor -%}
+{%- for sponsor in sponsors.silver -%}
+
+{% endfor %}
+{% endif %}
+
+
+
+Overige sponsoren
+
+## Meningen
+
+"_[...] Ik gebruik **FastAPI** heel vaak tegenwoordig. [...] Ik ben van plan om het te gebruiken voor alle **ML-services van mijn team bij Microsoft**. Sommige van deze worden geïntegreerd in het kernproduct van **Windows** en sommige **Office**-producten._"
+
+Kabir Khan -
Microsoft (ref)Piero Molino, Yaroslav Dudin en Sai Sumanth Miryala -
Uber (ref)Kevin Glisson, Marc Vilanova, Forest Monsen -
Netflix (ref)Deon Pillsbury -
Cisco (ref)
+
+Als je een CLI-app bouwt die in de terminal moet worden gebruikt in plaats van een web-API, gebruik dan **Typer**.
+
+**Typer** is het kleine broertje van FastAPI. En het is bedoeld als de **FastAPI van CLI's**. ️
+
+## Vereisten
+
+FastAPI staat op de schouders van reuzen:
+
+* Starlette voor de webonderdelen.
+* Pydantic voor de datadelen.
+
+## Installatie
+
+
+
+```console
+$ pip install "fastapi[standard]"
+
+---> 100%
+```
+
+
+
+**Opmerking**: Zet `"fastapi[standard]"` tussen aanhalingstekens om ervoor te zorgen dat het werkt in alle terminals.
+
+## Voorbeeld
+
+### Creëer het
+
+* Maak het bestand `main.py` aan met daarin:
+
+```Python
+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}
+```
+
+
+Of maak gebruik van async def...
+
+Als je code gebruik maakt van `async` / `await`, gebruik dan `async def`:
+
+```Python hl_lines="9 14"
+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}
+```
+
+**Opmerking**:
+
+Als je het niet weet, kijk dan in het gedeelte _"Heb je haast?"_ over `async` en `await` in de documentatie.
+
+
+
+### Voer het uit
+
+Run de server met:
+
+
+
+```console
+$ 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.
+```
+
+
+
+
+Over het commando fastapi dev main.py...
+
+Het commando `fastapi dev` leest het `main.py` bestand, detecteert de **FastAPI** app, en start een server met Uvicorn.
+
+Standaard zal dit commando `fastapi dev` starten met "auto-reload" geactiveerd voor ontwikkeling op het lokale systeem.
+
+Je kan hier meer over lezen in de FastAPI CLI documentatie.
+
+
+
+### Controleer het
+
+Open je browser op http://127.0.0.1:8000/items/5?q=somequery.
+
+Je zult een JSON response zien:
+
+```JSON
+{"item_id": 5, "q": "somequery"}
+```
+
+Je hebt een API gemaakt die:
+
+* HTTP verzoeken kan ontvangen op de _paden_ `/` en `/items/{item_id}`.
+* Beide _paden_ hebben `GET` operaties (ook bekend als HTTP _methoden_).
+* Het _pad_ `/items/{item_id}` heeft een _pad parameter_ `item_id` dat een `int` moet zijn.
+* Het _pad_ `/items/{item_id}` heeft een optionele `str` _query parameter_ `q`.
+
+### Interactieve API documentatie
+
+Ga naar http://127.0.0.1:8000/docs.
+
+Je ziet de automatische interactieve API documentatie (verstrekt door Swagger UI):
+
+
+
+### Alternatieve API documentatie
+
+Ga vervolgens naar http://127.0.0.1:8000/redoc.
+
+Je ziet de automatische interactieve API documentatie (verstrekt door ReDoc):
+
+
+
+## Voorbeeld upgrade
+
+Pas nu het bestand `main.py` aan om de body van een `PUT` request te ontvangen.
+
+Dankzij Pydantic kunnen we de body declareren met standaard Python types.
+
+```Python hl_lines="4 9-12 25-27"
+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}
+```
+
+De `fastapi dev` server zou automatisch moeten herladen.
+
+### Interactieve API documentatie upgrade
+
+Ga nu naar http://127.0.0.1:8000/docs.
+
+* De interactieve API-documentatie wordt automatisch bijgewerkt, inclusief de nieuwe body:
+
+
+
+* Klik op de knop "Try it out", hiermee kan je de parameters invullen en direct met de API interacteren:
+
+
+
+* Klik vervolgens op de knop "Execute", de gebruikersinterface zal communiceren met jouw API, de parameters verzenden, de resultaten ophalen en deze op het scherm tonen:
+
+
+
+### Alternatieve API documentatie upgrade
+
+Ga vervolgens naar http://127.0.0.1:8000/redoc.
+
+* De alternatieve documentatie zal ook de nieuwe queryparameter en body weergeven:
+
+
+
+### Samenvatting
+
+Samengevat declareer je **eenmalig** de types van parameters, body, etc. als functieparameters.
+
+Dat doe je met standaard moderne Python types.
+
+Je hoeft geen nieuwe syntax te leren, de methods of klassen van een specifieke bibliotheek, etc.
+
+Gewoon standaard **Python**.
+
+Bijvoorbeeld, voor een `int`:
+
+```Python
+item_id: int
+```
+
+of voor een complexer `Item` model:
+
+```Python
+item: Item
+```
+
+...en met die ene verklaring krijg je:
+
+* Editor ondersteuning, inclusief:
+ * Code aanvulling.
+ * Type validatie.
+* Validatie van data:
+ * Automatische en duidelijke foutboodschappen wanneer de data ongeldig is.
+ * Validatie zelfs voor diep geneste JSON objecten.
+* Conversie van invoergegevens: afkomstig van het netwerk naar Python-data en -types. Zoals:
+ * JSON.
+ * Pad parameters.
+ * Query parameters.
+ * Cookies.
+ * Headers.
+ * Formulieren.
+ * Bestanden.
+* Conversie van uitvoergegevens: converstie van Python-data en -types naar netwerkgegevens (zoals JSON):
+ * Converteer Python types (`str`, `int`, `float`, `bool`, `list`, etc).
+ * `datetime` objecten.
+ * `UUID` objecten.
+ * Database modellen.
+ * ...en nog veel meer.
+* Automatische interactieve API-documentatie, inclusief 2 alternatieve gebruikersinterfaces:
+ * Swagger UI.
+ * ReDoc.
+
+---
+
+Terugkomend op het vorige code voorbeeld, **FastAPI** zal:
+
+* Valideren dat er een `item_id` bestaat in het pad voor `GET` en `PUT` verzoeken.
+* Valideren dat het `item_id` van het type `int` is voor `GET` en `PUT` verzoeken.
+ * Wanneer dat niet het geval is, krijgt de cliënt een nuttige, duidelijke foutmelding.
+* Controleren of er een optionele query parameter is met de naam `q` (zoals in `http://127.0.0.1:8000/items/foo?q=somequery`) voor `GET` verzoeken.
+ * Aangezien de `q` parameter werd gedeclareerd met `= None`, is deze optioneel.
+ * Zonder de `None` declaratie zou deze verplicht zijn (net als bij de body in het geval met `PUT`).
+* Voor `PUT` verzoeken naar `/items/{item_id}`, lees de body als JSON:
+ * Controleer of het een verplicht attribuut `naam` heeft en dat dat een `str` is.
+ * Controleer of het een verplicht attribuut `price` heeft en dat dat een`float` is.
+ * Controleer of het een optioneel attribuut `is_offer` heeft, dat een `bool` is wanneer het aanwezig is.
+ * Dit alles werkt ook voor diep geneste JSON objecten.
+* Converteer automatisch van en naar JSON.
+* Documenteer alles met OpenAPI, dat gebruikt kan worden door:
+ * Interactieve documentatiesystemen.
+ * Automatische client code generatie systemen, voor vele talen.
+* Biedt 2 interactieve documentatie-webinterfaces aan.
+
+---
+
+Dit was nog maar een snel overzicht, maar je zou nu toch al een idee moeten hebben over hoe het allemaal werkt.
+
+Probeer deze regel te veranderen:
+
+```Python
+ return {"item_name": item.name, "item_id": item_id}
+```
+
+...van:
+
+```Python
+ ... "item_name": item.name ...
+```
+
+...naar:
+
+```Python
+ ... "item_price": item.price ...
+```
+
+...en zie hoe je editor de attributen automatisch invult en hun types herkent:
+
+
+
+Voor een vollediger voorbeeld met meer mogelijkheden, zie de Tutorial - Gebruikershandleiding.
+
+**Spoiler alert**: de tutorial - gebruikershandleiding bevat:
+
+* Declaratie van **parameters** op andere plaatsen zoals: **headers**, **cookies**, **formuliervelden** en **bestanden**.
+* Hoe stel je **validatie restricties** in zoals `maximum_length` of een `regex`.
+* Een zeer krachtig en eenvoudig te gebruiken **Dependency Injection** systeem.
+* Beveiliging en authenticatie, inclusief ondersteuning voor **OAuth2** met **JWT-tokens** en **HTTP Basic** auth.
+* Meer geavanceerde (maar even eenvoudige) technieken voor het declareren van **diep geneste JSON modellen** (dankzij Pydantic).
+* **GraphQL** integratie met Strawberry en andere packages.
+* Veel extra functies (dankzij Starlette) zoals:
+ * **WebSockets**
+ * uiterst gemakkelijke tests gebaseerd op HTTPX en `pytest`
+ * **CORS**
+ * **Cookie Sessions**
+ * ...en meer.
+
+## Prestaties
+
+Onafhankelijke TechEmpower benchmarks tonen **FastAPI** applicaties draaiend onder Uvicorn aan als een van de snelste Python frameworks beschikbaar, alleen onder Starlette en Uvicorn zelf (intern gebruikt door FastAPI). (*)
+
+Zie de sectie Benchmarks om hier meer over te lezen.
+
+## Afhankelijkheden
+
+FastAPI maakt gebruik van Pydantic en Starlette.
+
+### `standard` Afhankelijkheden
+
+Wanneer je FastAPI installeert met `pip install "fastapi[standard]"`, worden de volgende `standard` optionele afhankelijkheden geïnstalleerd:
+
+Gebruikt door Pydantic:
+
+* email_validator - voor email validatie.
+
+Gebruikt door Starlette:
+
+* httpx - Vereist indien je de `TestClient` wil gebruiken.
+* jinja2 - Vereist als je de standaard templateconfiguratie wil gebruiken.
+* python-multipart - Vereist indien je "parsen" van formulieren wil ondersteunen met `requests.form()`.
+
+Gebruikt door FastAPI / Starlette:
+
+* uvicorn - voor de server die jouw applicatie laadt en bedient.
+* `fastapi-cli` - om het `fastapi` commando te voorzien.
+
+### Zonder `standard` Afhankelijkheden
+
+Indien je de optionele `standard` afhankelijkheden niet wenst te installeren, kan je installeren met `pip install fastapi` in plaats van `pip install "fastapi[standard]"`.
+
+### Bijkomende Optionele Afhankelijkheden
+
+Er zijn nog een aantal bijkomende afhankelijkheden die je eventueel kan installeren.
+
+Bijkomende optionele afhankelijkheden voor Pydantic:
+
+* pydantic-settings - voor het beheren van settings.
+* pydantic-extra-types - voor extra data types die gebruikt kunnen worden met Pydantic.
+
+Bijkomende optionele afhankelijkheden voor FastAPI:
+
+* orjson - Vereist indien je `ORJSONResponse` wil gebruiken.
+* ujson - Vereist indien je `UJSONResponse` wil gebruiken.
+
+## Licentie
+
+Dit project is gelicenseerd onder de voorwaarden van de MIT licentie.
diff --git a/docs/nl/mkdocs.yml b/docs/nl/mkdocs.yml
new file mode 100644
index 000000000..de18856f4
--- /dev/null
+++ b/docs/nl/mkdocs.yml
@@ -0,0 +1 @@
+INHERIT: ../en/mkdocs.yml