How to Customize Error Responses for Invalid Requests in FastAPI?

Custom Error Response Handling in FastAPI

In FastAPI applications, handling errors is essential for providing informative responses to clients. One common issue encountered is receiving a 422 Unprocessable Entity error when sending additional or invalid data in requests. This article will demonstrate how to customize the error response to handle such scenarios.

Consider the following FastAPI backend example:

from fastapi import FastAPI

app = FastAPI

class Demo(BaseModel):
    content: str = None

@app.post("/demo")
async def demoFunc(d: Demo):
    return d.content

Upon sending a request with extra data, such as data = {"content": "some text here"}aaaa, the API returns a 422 error with the following response:

{
  "detail": [
    {
      "loc": [
        "body",
        47
      ],
      "msg": "Extra data: line 4 column 2 (char 47)",
      "type": "value_error.jsondecode",
      "ctx": {
        "msg": "Extra data",
        "doc": "{\n  \"content\": \"some text here\"}aaaaa",
        "pos": 47,
        "lineno": 4,
        "colno": 2
      }
    }
  ]
}

To customize the error response, FastAPI allows for overriding the request validation exception handler. Start by importing the necessary modules and defining a custom exception handler function:

from fastapi import FastAPI, Body, Request, status
from fastapi.encoders import jsonable_encoder
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse

app = FastAPI()

@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
    return JSONResponse(
        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
        content=jsonable_encoder({
            "detail": exc.errors(),
            "body": exc.body,
            "custom msg": {
                "Your error message"
            }
        }),
    )

This function intercepts the RequestValidationError exception and generates a customized JSON response. You can include the error details, the request body, and any custom message.

For example, using an invalid JSON body would now result in a response similar to:

{
    "detail": [
        {
            "loc": ["body", 1],
            "msg": "invalid json",
            "type": "json.decoder.JSONDecodeError",
            "ctx": {}
        }
    ],
    "body": {},
    "custom msg": {
        "Your error message"
    }
}

Alternatively, you can return a plain text response with just the error message:

from fastapi.responses import PlainTextResponse

@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request, exc):
    return PlainTextResponse(str(exc), status_code=422) 

By customizing the error response behavior in FastAPI, you can provide more informative and consistent error handling for your APIs. This improves the user experience and simplifies debugging for both developers and API consumers.

The above is the detailed content of How to Customize Error Responses for Invalid Requests in FastAPI?. For more information, please follow other related articles on the PHP Chinese website!