How do you use a Python class as a FastAPI dependency?

What's really being asked

This question probes whether you view FastAPI dependencies as a real architectural layer or merely as a bag of helper functions. The interviewer wants to see that you understand the dependency injection system can host callable classes, not just bare functions, and that you know when object-oriented encapsulation improves maintainability over a purely procedural approach. They are also checking if you grasp how FastAPI resolves dependencies by calling the provided callable and how that design naturally extends to classes with initialization logic.

The full answer

First, explain that Depends will invoke any callable, so a class exposing a call method works exactly like a function dependency while adding the power of object initialization. Second, describe how init becomes the natural place for sub-dependencies and configuration, turning the class into a reusable service boundary that accepts parameters at the router or endpoint level. Third, highlight concrete benefits: centralized setup logic that avoids repetition, shared mutable or immutable state across multiple path operations, cleaner unit testing through standard instantiation without mocking frameworks, and seamless integration with OpenAPI because FastAPI continues to inspect type annotations on call. Fourth, contrast this with function-based dependencies, which are inherently stateless and can scatter setup boilerplate when the same preamble is needed in many endpoints, forcing developers to rely on closures or repeated parameter lists.

The mistakes people make

A major red flag is claiming classes are only syntactic sugar and provide zero runtime or organizational benefit. Another is forgetting that FastAPI manages dependency resolution automatically, so developers should not manually instantiate the class themselves instead of letting the framework inject it through Depends. Some candidates also confuse class instantiation with dependency scope, incorrectly arguing that class-based dependencies leak state between requests unless manually managed.

What usually comes next

The interviewer may ask how you would share a database connection pool via a class dependency, how to override a class dependency during unit or integration testing using dependency overrides, or whether you should prefer a class over a factory function when the setup logic grows complex. They might also ask how sub-dependencies interact with class initialization or how type hints on call affect automatic documentation.

A concrete example

Imagine a PermissionChecker class that accepts a list of required roles in init, receives the current user from a sub-dependency, and returns a boolean or raises an HTTPException in call. Using a class keeps the role configuration declarative at the router level while encapsulating the authorization logic in one testable unit, something a single function cannot do as cleanly without awkward closures or repeated parameters across every protected endpoint.