FastAPI request body: validate JSON with a Pydantic model

Select a timestamp to watch that moment on YouTube.

1. 00:00

   A client posts JSON to /items/, but the quantity field is missing. What should the server do? We want validation to stop the request before application code assumes the field exists. In FastAPI, a parameter annotated with a Pydantic model describes a request body. We will work through the data shape, the route declaration, and actual status codes in a local test client. This server code runs in a normal Python environment, not in the browser console on this page. A FastAPI request body is JSON sent by the client, commonly with POST or PUT. Define a Pydantic BaseModel with typed fields, then annotate the route function

2. 00:42

   parameter with that model. FastAPI reads the JSON body, validates it, and passes a model instance into your function. This is distinct from a path parameter named in the URL and from a simple query parameter. The complete local app below uses a POST /items/ route; it must be run in a local Python environment rather than the browser console because the console cannot host an HTTP server. A client sends a JSON document in the request body. In a local FastAPI app, a Pydantic BaseModel makes the expected fields visible as Python annotations and an OpenAPI schema.

3. 01:26

   Add constraints such as minimum quantity only after deciding what the API promises. A missing required field should cause a validation response rather than reaching a route that immediately raises KeyError. The broken example is a plain dictionary access. It raises KeyError when quantity is absent. An API that waits until this line to discover a missing required field gives a less useful failure and may leave business logic half executed. The key lesson is to describe the incoming contract at the HTTP boundary. That is where a framework can reject malformed requests consistently and produce field-specific errors for callers.

4. 02:09

   For the example, an item has a nonempty name and a quantity of at least one. A missing quantity, wrong JSON shape, or quantity below one produces a 422 validation response before the route function runs. That is a useful contract, but it is not business validation for every possible rule. Consider whether strings should be coerced to numbers, whether extra fields should be accepted, and whether whitespace-only names should be rejected. Make these choices explicit in the model rather than assuming a plain `int` annotation captures every requirement. The browser example here uses a Python dictionary to represent a decoded JSON

5. 02:50

   object. It does not start FastAPI; use the local- only code block above to run the actual server. Focus first on the contract: `name` must contain visible text and `quantity` must be a positive integer for this example. The browser task makes those conditions explicit. The diagnosis gives the same body to a Pydantic model and prints the error location. The model knows quantity is required and reports its absence. A field annotation is not merely documentation: FastAPI uses this model to parse JSON and validate before the route function runs.

6. 03:32

   A path parameter comes from a named URL segment, and a simple optional parameter may come from a query string; they are different sources. The body model says where these fields belong. The browser exercises use local dictionaries to let you reason about body validation without a network call. The function `normalize_item` checks a JSON-like Python dict, rejects bool as a quantity even though bool subclasses int, strips the name, and returns a narrow result. This does not replace Pydantic or imitate every FastAPI rule. It lets you test the same application- level contract before connecting it to the route.

7. 04:13

   In the local app, the route receives the Pydantic model and returns the cleaned fields. In a FastAPI route such as PUT /items/{item_id}, `item_id` comes from the path, while a parameter annotated as a Pydantic model comes from the JSON body. A simple string parameter that is not in the path is commonly a query parameter. This distinction helps explain why putting JSON fields in the wrong place does not satisfy the request body model. The corrected code declares a POST route and an Item model with a minimum quantity. The printed model data demonstrates that valid input passes validation.

8. 04:54

   The route trims the name and returns only the fields it means to expose. For a production API, decide whether whitespace-only names should be rejected and whether coercion is acceptable; the browser practice implements a stricter application policy and makes boolean quantity invalid. The two snippets serve different purposes but share an explicit contract. Save the local example as app.py and run it with `fastapi dev app.py` after installing fastapi[standard]. Send a POST with Content-Type application/json to /items/ or use /docs. Try a valid body and one missing quantity, then inspect the 422 detail to see which

9. 05:35

   field failed. Do not place a body on a GET route for this basic API design. The prior HTTP response lesson validates incoming server data on the client side; this page covers validation of a client's request arriving at a FastAPI server. For the simpler POST /items/ tutorial, there is no path identifier, only the Item body. Test it in the automatically generated /docs UI or with an HTTP client. Sending an object with both required fields should reach the function. Missing quantity should yield 422 with a field location in the response details.

10. 06:18

    Do not claim that a browser-only Python function is an HTTP server. The final demo uses FastAPI TestClient to send a valid JSON body and an invalid one without opening a public server. One gets 200, the missing quantity gets 422 and identifies body.quantity. If your installed dependencies differ, run the local setup described on the page. Use /docs when running the app to inspect the generated schema. A model helps the HTTP layer, while separate business rules may still be needed after validation. Do not confuse checking an incoming request body with validating a remote

11. 07:00

    server response, which the linked earlier lesson covers. A model can enforce syntax and constraints before business logic runs, but the exact coercion policy deserves care. In plain Python, bool is a subclass of int, so `isinstance(True, int)` is true. If an API must accept only literal integer quantities, configure strict validation. The browser task uses exact type checks to make this policy easy to observe. After normalization, return only the fields the route needs. Strip surrounding whitespace from the name and reject an all-whitespace name. In a production API, tests should submit both a valid JSON body and several invalid

12. 07:44

    bodies through the HTTP layer, then assert status codes and field locations. The local app block is the starting point; the browser exercise checks the decision logic independently.