First Check

• I added a very descriptive title here.
• I used the GitHub search to find a similar question and didn't find it.
• I searched the FastAPI documentation, with the integrated search.
• I already searched in Google "How to X in FastAPI" and didn't find any information.
• I already read and followed all the tutorial in the docs and didn't find an answer.
• I already checked if it is not related to FastAPI but to Pydantic.
• I already checked if it is not related to FastAPI but to Swagger UI.
• I already checked if it is not related to FastAPI but to ReDoc.

Commit to Help

• I commit to help with one of those options 👆

Example Code

## Server code

@app.post("/heroes/")
def create_hero(hero: Hero, session: SessionDep) -> Hero:
    session.add(hero)
    session.flush()
    return hero

@app.get("/heroes/{hero_id}")
def read_hero(hero_id: int, session: SessionDep) -> Hero:
    hero = session.get(Hero, hero_id)
    if not hero:
        raise HTTPException(status_code=404, detail="Hero not found")
    return hero

## Client code

hero_id = requests.post("/heroes", json={...})
requests.get(f"/heroes/{hero_id}")  # sometimes returns 404

Description

My Use Case

Before 0.118.0, code placed after the yield in a dependency would run before sending the response.
That made it possible to structure a DB session dependency like this:

def get_db():
    db = SessionLocal()
    try:
        yield db
        db.commit()   # ensures commit before returning response
    finally:
        db.close()

This pattern is very common in tutorials and examples. It ensures that when the client receives a 201 Created, the data is already committed and available for immediate queries.

Problem With Current Behavior

After 0.118.0, the code after yield runs after the response is sent, which means:

• The client may query for data it just created and receive a 404.
• Transactions are not guaranteed to be committed at the moment the response is returned.

In effect, this changes the semantics from "commit before responding" to "commit sometime after responding".

Why Early Closing Would Help

In my case, I need to guarantee transactional consistency at response time.

• The client depends on the resource being available immediately after receiving the response.
• Without early closing, I have to manually commit and close inside each endpoint, which removes the benefit of dependency-based session handling.

Proposal

It would be very helpful to have an opt-in mechanism for early closing, e.g.:

• A parameter on the dependency system (yield early=True)
• Or a helper function/context manager that ensures code after yield executes before sending the response

This way, users can choose the behavior that fits their use case:

• Default: release connections late (after response) for performance/throughput.
• Opt-in: close/commit early for consistency-sensitive workflows.

Operating System

Windows

Operating System Details

No response

FastAPI Version

0.118.0

Pydantic Version

2.11.9

Python Version

3.13.5

Additional Context

No response