Custom exception handlers in FastAPI - Mini Project: Build & Apply

Custom Exception Handlers in FastAPI

📖 Scenario: You are building a simple web API using FastAPI. You want to handle errors gracefully by creating custom exception handlers that return friendly error messages to users.

🎯 Goal: Build a FastAPI app that defines a custom exception and a handler for it. When the exception is raised, the app should return a JSON response with a clear error message and status code.

📋 What You'll Learn

Create a custom exception class called MyCustomException.

Add a FastAPI app instance called app.

Write a custom exception handler function called my_custom_exception_handler that returns a JSON response with status_code=418 and a message.

Register the custom exception handler with the FastAPI app using app.exception_handler(MyCustomException).

Create a GET route /raise-error that raises MyCustomException.

💡 Why This Matters

🌍 Real World

Custom exception handlers help APIs respond with clear, user-friendly error messages instead of generic server errors.

💼 Career

Knowing how to create and register custom exception handlers is essential for backend developers building robust and maintainable APIs.

1

Create the custom exception class

Create a custom exception class called MyCustomException that inherits from Exception.

FastAPI

# Your code here

Hint

Define a class named MyCustomException that inherits from Exception. Use pass inside the class.

2

Create the FastAPI app instance

Import FastAPI from fastapi and create an app instance called app.

FastAPI

class MyCustomException(Exception):
    pass

# Your code here

Hint

Use from fastapi import FastAPI and then create app = FastAPI().

3

Write the custom exception handler function

Import Request from fastapi and JSONResponse from fastapi.responses. Write a function called my_custom_exception_handler that takes request: Request and exc: MyCustomException as parameters. Return a JSONResponse with status_code=418 and a JSON content with {"message": "This is a custom error"}.

FastAPI

from fastapi import FastAPI

class MyCustomException(Exception):
    pass

app = FastAPI()

# Your code here

Hint

Define a function with parameters request and exc. Return JSONResponse with the specified status code and message.

4

Register the handler and create the route

Register the custom exception handler with app using @app.exception_handler(MyCustomException). Then create a GET route /raise-error that raises MyCustomException.

FastAPI

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

class MyCustomException(Exception):
    pass

app = FastAPI()

def my_custom_exception_handler(request: Request, exc: MyCustomException):
    return JSONResponse(
        status_code=418,
        content={"message": "This is a custom error"}
    )

# Your code here

Hint

Use the decorator @app.exception_handler(MyCustomException) above the handler function. Then add a GET route /raise-error that raises the exception.

Practice

1. What is the main purpose of a custom exception handler in FastAPI?

easy

A. To catch specific errors and return user-friendly responses

B. To speed up the server response time

C. To automatically fix bugs in the code

D. To log all incoming requests

Solution

1. Step 1: Understand what exception handlers do

   They catch errors that happen during request processing.

2. Step 2: Identify the benefit of custom handlers

   They allow sending clear, friendly messages instead of default error pages.

3. Final Answer:

   To catch specific errors and return user-friendly responses -> Option A

4. Quick Check:

   Custom handlers improve user experience = B [OK]

Hint: Custom handlers catch errors and explain them clearly [OK]

Common Mistakes:

• Thinking they fix bugs automatically
• Confusing with logging or performance tools
• Assuming they speed up requests

2. Which of the following is the correct way to register a custom exception handler in FastAPI?

easy

A. app.add_exception_handler(MyException, handler_function)

B. app.register_handler(MyException, handler_function)

C. app.use_exception_handler(MyException, handler_function)

D. app.exception_handler(MyException, handler_function)

Solution

1. Step 1: Recall FastAPI method for adding handlers

   FastAPI uses add_exception_handler to register handlers.

2. Step 2: Check method names in options

   Only app.add_exception_handler(MyException, handler_function) uses the correct method name and parameters.

3. Final Answer:

   app.add_exception_handler(MyException, handler_function) -> Option A

4. Quick Check:

   Correct method is add_exception_handler = D [OK]

Hint: Use add_exception_handler to register custom handlers [OK]

Common Mistakes:

• Using wrong method names like register_handler
• Confusing decorator syntax with registration
• Passing wrong parameters order

3. Given this code snippet, what will be the HTTP status code returned when MyException is raised?

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

app = FastAPI()

class MyException(Exception):
    pass

@app.exception_handler(MyException)
async def my_exception_handler(request: Request, exc: MyException):
    return JSONResponse(status_code=418, content={"message": "Custom error occurred"})

@app.get("/test")
async def test():
    raise MyException()

medium

A. 404

B. 418

C. 200

D. 500

Solution

1. Step 1: Identify the status code in the handler

   The handler returns a JSONResponse with status_code=418.

2. Step 2: Understand what happens when exception is raised

   Raising MyException triggers the handler, which sends the 418 status.

3. Final Answer:

   418 -> Option B

4. Quick Check:

   Handler sets status 418 = A [OK]

Hint: Check the status_code in JSONResponse inside handler [OK]

Common Mistakes:

• Assuming default 500 error code
• Confusing 404 with missing route
• Ignoring custom status_code in handler

4. What is wrong with this FastAPI custom exception handler code?

from fastapi import FastAPI

app = FastAPI()

class CustomError(Exception):
    pass

@app.exception_handler(CustomError)
def handler(exc: CustomError):
    return {"error": "Something went wrong"}

medium

A. Return value must be a string, not a dict

B. Exception class must inherit from HTTPException

C. Handler function must be async and accept Request parameter

D. Decorator should be @app.add_exception_handler, not @app.exception_handler

Solution

1. Step 1: Check handler function signature

   FastAPI expects async handler with parameters (Request, Exception).

2. Step 2: Identify missing Request and async

   The handler lacks the Request parameter and is not async.

3. Final Answer:

   Handler function must be async and accept Request parameter -> Option C

4. Quick Check:

   Handler signature requires async and Request = C [OK]

Hint: Handler must be async and take Request as first argument [OK]

Common Mistakes:

• Making handler synchronous
• Omitting Request parameter
• Thinking exception must inherit HTTPException

5. You want to create a custom exception handler in FastAPI that returns a JSON response with a dynamic message and a 400 status code whenever ValueError is raised. Which code snippet correctly implements this?

hard

A. from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

app = FastAPI()

@app.exception_handler(ValueError)
async def value_error_handler(request: Request, exc: ValueError):
return JSONResponse(content={"error": str(exc)}, status=400)

B. from fastapi import FastAPI

app = FastAPI()

@app.exception_handler(ValueError)
def value_error_handler(exc: ValueError):
return {"error": str(exc), "status": 400}

C. from fastapi import FastAPI, Request

app = FastAPI()

@app.add_exception_handler(ValueError)
async def value_error_handler(request: Request, exc: ValueError):
return {"error": str(exc), "status_code": 400}

D. from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

app = FastAPI()

@app.exception_handler(ValueError)
async def value_error_handler(request: Request, exc: ValueError):
return JSONResponse(status_code=400, content={"error": str(exc)})

Solution

1. Step 1: Check correct decorator and function signature

   Use @app.exception_handler with async function taking (Request, Exception).

2. Step 2: Verify JSONResponse usage and status code

   Return JSONResponse with status_code=400 and content with error message.

3. Step 3: Identify correct option

   from fastapi import FastAPI, Request from fastapi.responses import JSONResponse app = FastAPI() @app.exception_handler(ValueError) async def value_error_handler(request: Request, exc: ValueError): return JSONResponse(status_code=400, content={"error": str(exc)}) matches all requirements exactly.

4. Final Answer:

   A -> Option D

5. Quick Check:

   Correct async handler with JSONResponse and status_code=400 = A [OK]

Hint: Use async handler with JSONResponse and status_code param [OK]

Common Mistakes:

• Using synchronous handler
• Missing Request parameter
• Wrong decorator or status code parameter name
• Returning dict instead of JSONResponse