Failed · 44 questions

The docs advise using a more robust task queue such as **Celery** for heavy background work that doesn’t need to share state with the FastAPI process. Celery requires a message broker (e.g., RabbitMQ or Redis) and can run tasks across multiple processes or servers. This approach is preferable over FastAPI’s built‑in `BackgroundTasks` for compute‑intensive jobs.

For heavyweight background jobs that don’t need to share memory or run in the same process, the docs recommend using a dedicated task queue such as **Celery

A bigger tool such as Celery.

Use a **BackgroundTask**. Add a `background_tasks` parameter to your path operation, create a callable that sends the e‑mail, and add it to the task list. FastAPI will return the response immediately and execute the task after the response is sent. ```python from fastapi import FastAPI, BackgroundTasks app = FastAPI() def send_mail(): # your email‑sending logic ... @app.post("/notify") def notify(background_tasks: BackgroundTasks): background_tasks.add_task(send_mail) return {"msg": "accepted"} ``` This runs `send_mail` only after the HTTP response has been returned to the client

Use FastAPI **BackgroundTasks**. Declare a `background_tasks: BackgroundTasks` parameter in

Declare a BackgroundTasks parameter in the path operation function and add the work with background_tasks.add_task(...); it runs after the response is returned.

No – you cannot set `allow_origins=['*']` when `allow_credentials=True`. From the docs: “None of `allow_origins`, `allow_methods` and `allow_headers` can be set to `['*']` if `allow_credentials` is set to `True`.” You must explicitly list the allowed origins (and also methods/headers) if you need credentials.

No, you cannot combine `allow_origins=['*']` with `allow_credentials=True`. According to FastAPI’s CORS rules, any of `allow_origins`, `allow_methods`, or `allow_headers` must be explicitly listed when `allow_credentials=True`. Therefore you should provide a concrete list of origins instead of the wildcard.

No. With allow_credentials=True, none of allow_origins, allow_methods and allow_headers can be ['*']; they must be listed explicitly.

By default, `CORSMiddleware` allows only the **GET** method. The `allow_methods` parameter defaults to `['GET']`.

CORSMiddleware allows only the **GET** method by default. The `allow_methods` parameter defaults to `['GET']`; other methods must be explicitly listed or set to `['*']` to enable them.

Only GET: allow_methods defaults to ['GET'].

Browsers cache CORS responses for **600 seconds** (the default `max_age` value).

Browsers cache CORS responses for **600 seconds** by default. This comes from `max_age` in the `CORSMiddleware`, which defaults to `600` seconds.

600 seconds; max_age defaults to 600.

Use the **FastAPI** test app’s `app.dependency_overrides` dictionary. Inside your test, set the key to the original dependency function and the value to the fake one: ```python def fake_user(): … # your mock app.dependency_overrides[real_user_dep] = fake_user ``` FastAPI will call `fake_user` instead of `real_user_dep`. At the end of the test clear them with: ```python app.dependency_overrides = {} ```

Use FastAPI’s dependency‑override mechanism. Put the fake in the `app.dependency_overrides` dictionary, keyed by the original dependency function, e.g.: ```python app.dependency_overrides = {real_dep: fake_dep} ``` FastAPI will call `fake_dep` instead of `real_dep` during the test, and afterward reset with `app.dependency_overrides = {}`. This only affects the test that sets the override.

Set app.dependency_overrides[original] = override; it's a dict, and you reset it by setting it to an empty dict.

By default **FastAPI** serves the two interactive docs on these paths: - **Swagger UI** → `/docs` - **ReDoc** → `/redoc` These are the standard URLs you’ll see when you run the app, e.g. `http://127.0.0.1:8000/docs` and `http://127.0.0.1:8000/redoc`.

By default FastAPI serves Swagger UI at the path **`/docs`** and ReDoc at **`/redoc`**. Those are the URLs you’ll see when you visit `http://127.0.0.1:8000/docs` or `http://127.0.0.1:8000/redoc`.

Swagger UI at /docs and ReDoc at /redoc.

Use the response model flags on the route: ```python @router.get("/items/{id}", response_model=Item, response_model_exclude_unset=True) ``` `response_model_exclude_unset=True` (or `response_model_exclude_defaults=True` for default values that were explicitly set) will omit fields that were never provided by the instance.

Use the path‑operation decorator option `response_model_exclude_unset=True`. This tells FastAPI/Pydantic to exclude any fields that were not explicitly set, so default values that were never overridden do not appear in the JSON response.

Set response_model_exclude_unset=True on the path operation decorator.

No – you can’t mix them. Passages [1], [2] and [3] all state that an endpoint can declare multiple `Form`/`File` parameters, but you can’t also declare `Body` fields for JSON; the request will be `multipart/form-data` instead of `application/json`.

No. The FastAPI docs state that a path operation can have multiple `Form`/`File` parameters **but you can’t also declare `Body` fields that you expect to receive as JSON** (the request will be encoded as `application/x‑www‑form‑urlencoded` or `multipart/form‑data`). This is a limitation of the HTTP protocol, not FastAPI itself.

No. The request body is encoded as application/x-www-form-urlencoded instead of application/json, so you can't also declare JSON Body fields. This is a limitation of HTTP.

To receive form fields you must install the **`python-multipart`** package (e.g., `uv add python-multipart`). This dependency is required for parsing `multipart/form-data` requests.

You need to install **python‑multipart** before you can receive form fields.

python-multipart.

The `GZipMiddleware` defaults to a `compresslevel` of **9**. The `compresslevel` parameter accepts an **integer between 1 and 9** (inclusive).

The default `compresslevel` of `GZipMiddleware` is **9**. It can accept an integer value in the range **1 to 9** (inclusive).

It defaults to 9 and is an integer from 1 to 9; lower is faster with larger output, higher is slower with smaller output.

Generate a secure random key with OpenSSL: ```bash $ openssl rand -hex 32 ``` Copy the output (e.g., `09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7`) into the `SECRET_KEY` variable.

The docs recommend generating a random 32‑byte hex key with OpenSSL: ```bash $ openssl rand -hex 32 ``` Copy that output to a variable named `SECRET_KEY` (e.g., `SECRET_KEY = "09d25e09..."`). This key is then used to sign the JWT tokens.

Run openssl rand -hex 32.

Define a lifespan context manager, load the model before the `yield`, and release it after: ```python async def lifespan(app: FastAPI): # startup – load once app.state.model = load_model("path/to/model") # expensive step yield # shutdown – clean up del app.state.model # or call a cleanup method ``` Then create your app with this lifespan: ```python app = FastAPI(lifespan=lifespan) ``` The code before `yield` runs once when the app starts, and the code after `yield` runs once when the app shuts down.

Create a `lifespan` context manager and pass it to the FastAPI app. ```python async def lifespan(app: FastAPI): # startup: load the model once app.state.model = load_my_model() # <‑‑ executed before first request yield # → app starts handling requests # shutdown: release the model del app.state.model # <‑‑ executed after last request app = FastAPI(lifespan=lifespan) ``` The code before `yield` runs only on startup, and the code after `yield` runs on shutdown, ensuring the model is loaded once and cleaned up when the app stops.

Use a lifespan async context manager: code before yield runs at startup, code after yield at shutdown, and pass it as FastAPI(lifespan=...).

The example uses `time.perf_counter()` because, as the docs note, it “can be more precise for these use cases.” In short, `perf_counter()` offers higher resolution timing than `time.time()`, which is better for measuring the short request‑processing intervals illustrated by the middleware.

Because `time.perf_counter()` gives a higher‑resolution timer for measuring elapsed time. In the middleware example it’s used “instead of time.time() because it can be more precise for these use cases.” This makes the `X‑Process‑Time` header more accurate.

Because perf_counter() can be more precise for measuring processing time; it is used for the X-Process-Time header.

The docs recommend using the **pwdlib** library with the **Argon2** algorithm for password hashing.

I’m not sure based on the FastAPI docs.

pwdlib, with the Argon2 algorithm.

Use a Python `Enum`. Define an enum with the allowed values, e.g.: ```python class Color(str, Enum): red = "red" green = "green" blue = "blue" ``` Then declare the path parameter’s type as `Color`. FastAPI will accept only those enum members.

Use a Python `Enum`. Create an `Enum` listing the allowed values, then type‑hint the path parameter with that enum. FastAPI will only accept values that match an enum member, so the path is restricted to that fixed set.

Create a class that inherits from str and Enum and use it as the parameter's type.

To force a path value to be at least 1, declare the parameter with `Path` and the numeric constraint `ge=1`. Example: ```python from fastapi import Path @app.get("/items/{item_id}") def read_item(item_id: int = Path(..., ge=1)): return {"item_id": item_id} ``` `Path(..., ge=1)` marks `item_id` as required and guarantees it is ≥ 1.

Use FastAPI’s `Path` constraint: ```python from fastapi import Path @app.get("/items/{item_id}") def read_item(item_id: int = Path(..., ge=1)): ... ```

Use Path(ge=1), where ge means greater than or equal.

Use a cached dependency function. Add `@lru_cache` to the function that builds the `Settings` object: ```python from functools import lru_cache @lru_cache() def get_settings() -> Settings: return Settings() ``` The first call creates the `Settings` instance; subsequent calls return the cached instance, so the `.env` file is read only once.

Use the `@lru_cache` decorator on your dependency that returns a `Settings` instance. ```python from functools import lru_cache @lru_cache() def get_settings() -> Settings: return Settings() ``` The first call creates the object (reading `.env` once); subsequent calls return the cached instance, so the file is never reread.

Wrap the function that returns Settings with @lru_cache, so it's created the first time and reused afterwards.

The `BaseSettings` class is provided by **Pydantic**. It allows you to define settings classes that read environment variables.

The `BaseSettings` class that reads environment variables comes from the **Pydantic** package. It lives in `pydantic.BaseSettings`.

pydantic-settings.

FastAPI automatically sends a “keep‑alive” ping comment every **15 seconds** when no messages have been sent.

FastAPI automatically sends a keep‑alive ping comment on SSE streams. The ping is written as a comment line every **15 seconds** when no other data has been sent. This prevents proxies from closing idle connections.

Every 15 seconds when no message has been sent, as a ping comment, so proxies don't close the connection.

The endpoint should return **status code 201 (Created)** after successfully creating a new record. This is the standard convention for indicating that a new resource has been created.

I don’t know based on the FastAPI docs.

201, Created.

The **204** status code (“No Content”) is used when there is nothing to return. All 204 responses must have **no body**; if you include a body it violates the HTTP spec. In FastAPI you’d typically return `Response(status_code=status.HTTP_204_NO_CONTENT)` when nothing else is sent.

The 204 status code is **“No Content.”** It indicates that the operation succeeded but there is nothing in the response body, so the response must not include any content.

204 means No Content: there is nothing to return, so the response must not have a body.

No. TestClient is designed for synchronous test functions. When you mark a test with `@pytest.mark.anyio` and make it `async def`, the magic that lets TestClient drive the async FastAPI app inside a normal def will no longer work. For async tests you should use `httpx.AsyncClient` instead.

No – if you use the FastAPI `TestClient`, the test function must stay a normal `def`. The magic inside `TestClient` that runs your app asynchronously breaks when the test itself is `async def`. Use the standard sync `def` approach for `TestClient`; only switch to `async def` (and `AsyncClient`) when you need true async tests.

No, they are normal def functions, and the client calls are made without await.

I need to install the **httpx** package.

You need to install the **`httpx`** package to use FastAPI’s `TestClient`. ```bash uv add httpx # or pip install httpx ``` The `TestClient` is built on top of `httpx` and is available as `fastapi.testclient`.

httpx.

When a client closes a WebSocket, the receive coroutine raises a `WebSocketDisconnect` exception. Catch this exception in your handler (e.g., with a `try/except WebSocketDisconnect`) and perform any cleanup or notification logic. This is the standard way to detect a client disconnection in FastAPI.

Detect disconnections by catching the **`WebSocketDisconnect`** exception raised when a client closes the socket. Inside the receive loop: ```python try: msg = await websocket.receive_text() except WebSocketDisconnect: # handle client leaving ``` This exception signals that the client has disconnected.

await websocket.receive_text() raises WebSocketDisconnect when the connection closes; catch it.

To embed a Flask app, mount it under a sub‑path of your FastAPI instance. In the example

Wrap it with WSGIMiddleware (needs the a2wsgi package) and mount it on a path.

The exit code in a `yield`‑dependency runs **after the response is sent** by default (`Depends(scope="request")`). If you need it to run earlier, set `Depends(scope="function")`; then it runs immediately after the path‑operation function returns and **before** the response is sent. (In FastAPI < 0.118.0 the exit run earlier than the response, but this was reverted in 0.118.0.)

When you use a dependency that has a `yield`, the code after the `yield` runs once the dependency’s lifecycle ends. By default (`Depends(scope="request")`), FastAPI runs that cleanup **after the response has been sent**. If you set `Depends(scope="function")`, FastAPI will execute the exit code **after the path‑operation function returns but before the response is written to the client**. Prior to 0.118.0 the former behaviour caused the exit code to run earlier, but it was reverted to the default request‑scope behaviour.

After the response; use try/finally to make sure the exit steps run whether or not there was an exception.

I don't know based on the FastAPI docs.

Mark it with @pytest.mark.anyio (the AnyIO plugin) and send requests with an httpx AsyncClient using await.

Accept, Accept‑Language, Content‑Language and Content‑Type. These headers are automatically permitted on simple CORS requests, even when `allow_headers` is an empty list.

For simple CORS requests, the following request headers are always permitted even if `allow_headers` is empty: - `Accept` - `Accept-Language` - `Content-Language` - `Content-Type`.

Accept, Accept-Language, Content-Language and Content-Type.

Use the `FastAPI` constructor and set all three parameters to `None`: ```python app = FastAPI(openapi_url=None, docs_url=None, redoc_url=None) ``` `openapi_url=None` turns off the OpenAPI schema, and `docs_url=None` and `redoc_url=None` disable Swagger UI and ReDoc respectively.

Set the FastAPI application to use `openapi_url=None`. That turns off the `/openapi.json` schema **and also disables** the Swagger‑UI and ReDoc UIs that rely on it. (If you want to be

Set openapi_url=None, which also disables the documentation UIs that use it.

Use the **exec form** of `CMD`. ```Dockerfile CMD ["fastapi", "run", "app/main.py", "--port", "80"] ``` This form ensures graceful shutdown and triggers lifespan events.

Use the **exec form** of `CMD`. Example: `CMD ["fastapi", "run", "app/main.py", "--port", "80"]`. This ensures FastAPI can shutdown gracefully and triggers lifespan events.

Always the exec form, e.g. CMD ["fastapi", "run", "app/main.py", "--port", "80"].

Below 500 bytes, GZipMiddleware will skip compression. The default `minimum_size` argument is set to **500** bytes.

Below 500 bytes, GZipMiddleware will skip compression by default (the `minimum_size` default is `500`).

500 bytes; minimum_size defaults to 500.

You can pass any JSON‑serializable value as the `detail` argument to FastAPI’s `HTTPException`. That means strings, dictionaries, lists, numbers, booleans, etc. – anything that can be converted to JSON will be returned in the response body, e.g.: ```python raise HTTPException(status_code=400, detail={"error": "bad input"}) ``` Only `detail` is unrestricted; the status code must still be an int.

You can pass **any JSON‐serializable value** to the `detail` parameter of FastAPI’s `HTTPException`—so strings, dictionaries, lists, or other objects that the JSON encoder can handle. FastAPI’s `HTTPException` accepts any JSON‑able data, whereas Starlette’s version only accepts strings. When the exception is raised, FastAPI automatically converts the `detail` value to JSON in the response.

Any value that can be converted to JSON, not only a str, such as a dict or list.

Use the FastAPI CLI option `--forwarded-allow-ips`. For example: ```bash uv run fastapi run --forwarded-allow-ips="*" ``` This tells the server to trust the `X‑Forwarded‑*` headers from the IP(s) you specify (or all if you use `*`).

To have FastAPI trust the X‑Forwarded headers from your proxy, start the server with the CLI option `--forwarded-allow-ips`. Example for a single trusted proxy: ```bash uv run fastapi run --forwarded-allow-ips="*" ``` This tells FastAPI to read and honor the `X‑Forwarded‑*` headers from the IP(s) you specify (or all IPs when using `"*"`).

Start it with the --forwarded-allow-ips CLI option listing the trusted proxy IPs; "*" trusts all.

Use an **`Annotated`** query field with `Query(max_length=50)`: ```python from typing import Annotated from fastapi import Query q: Annotated[str | None, Query(max_length=50)] = None ``` The default `None` keeps the parameter optional, while FastAPI now validates that any supplied string has ≤ 50 characters, returns a clear error if not, and documents the limit in the OpenAPI UI.

Use `Query` with `max_length=50`. Example: ```python from typing import Annotated from fastapi import Query def items(q: Annotated[str | None, Query(max_length=50, default=None)] = None): ... ``` This makes `q` optional but validates that any supplied value is ≤ 50 characters.

Use Query(max_length=50), preferably inside Annotated.

The `tokenUrl` argument is the URL that the client (usually a browser or front‑end app) should POST to in order to exchange a username and password for a bearer token. It is only a declaration used by FastAPI to add the security scheme to the OpenAPI schema; it does not by itself create a `/token` endpoint. Because it is a relative path (e.g. `tokenUrl="token"` → `./token`), the final URL will be `https://<api‑base>/token` or `https://<api‑base>/api/v1/token` depending on your mount point.

The `tokenUrl` parameter tells **OAuth2PasswordBearer** where the client should send the `username` and `password` in order to request a token. It declares the `/token` (or whatever URL you pass) as the token‑endpoint in the OpenAPI schema, so that the interactive docs know where to POST credentials.

The URL the client sends the username and password to in order to get a token; tokenUrl="token" is a relative URL, equivalent to ./token.

Use a wildcard in the `allowed_hosts` list. ```python app.add_middleware( TrustedHostMiddleware, allowed_hosts=["*.example.com"], # accepts all sub‑domains of example.com ) ``` This pattern matches any hostname that ends with `example.com` and lets TrustedHostMiddleware accept every sub‑domain.

Use the `allowed_hosts` argument of `TrustedHostMiddleware` and give it a wildcard list. E.g.: ```python app.add_middleware( TrustedHostMiddleware, allowed_hosts=["*.example.com"] ) ``` This will accept any sub‑domain of `example.com` while rejecting others.

Use a wildcard domain like '*.example.com' in allowed_hosts.

UploadFile is preferable for large uploads because it stores data in a spooled temporary file: the file is kept in memory only up to a size limit, after which it spills to disk. This prevents a huge file from consuming all RAM, unlike a `bytes` object that holds the entire content in memory. Additionally, UploadFile exposes metadata such as `filename` and `content_type` and offers an async, file‑like interface that can be passed directly to libraries expecting a file‑like object.

`UploadFile` uses a spooled file that keeps data in memory until a size limit is hit and then stores it on disk, so large uploads (images, video, binaries) don’t exhaust RAM. It also gives you metadata (`filename`, `content_type`) and an async file‑like interface that can be passed directly to libraries. In contrast, a `bytes` parameter would load the entire file into memory at once, which is inefficient for big files.

It uses a spooled file kept in memory up to a size limit and then stored on disk, so it works for large files without consuming all memory.

To override the default validation error response, import `RequestValidationError` and register a handler with `@app.exception_handler(RequestValidationError)`. The handler receives a `Request` and the exception, so you can build and return any response (e.g., `PlainTextResponse`). ```python from fastapi import Request, FastAPI from fastapi.exceptions import RequestValidationError from fastapi.responses import PlainTextResponse app = FastAPI() @app.exception_handler(RequestValidationError) async def validation_exception_handler(request: Request, exc: RequestValidationError): return PlainTextResponse(str(exc), status_code=400) # custom text response ```

You can replace FastAPI’s default JSON by creating a custom handler for **RequestValidationError**. ```python from fastapi import Request, FastAPI from fastapi.exceptions import RequestValidationError from fastapi.responses import PlainTextResponse app = FastAPI() @app.exception_handler(RequestValidationError) async def validation_exception_handler(request: Request, exc: RequestValidationError): return PlainTextResponse(str(exc), status_code=400) ``` By decorating the handler with `@app.exception_handler(RequestValidationError)` you receive the request and the `exc`, and you can return any response format you prefer.

Import RequestValidationError and register a handler with @app.exception_handler(RequestValidationError).

Use the `--workers` flag with the `fastapi` command. ```bash fastapi run --workers 4 main.py ``` This starts the FastAPI app in four separate worker processes, allowing it to use multiple CPU cores for handling requests concurrently.

Run the FastAPI app with the `--workers` flag. For example from the docs: ```bash $ fastapi run --workers 4 main.py ``` This starts the server with four worker processes.

fastapi run --workers 4 main.py.