Fix RuntimeError: RuntimeError: Task got bad yield: <coroutine object send_notification at 0x7f8b2c3a1d00> in FastAPI

This error occurs when a background task is defined as an async function but is not properly awaited, or when you pass a coroutine object instead of a callable to BackgroundTasks.add_task(). Fix it by passing the function reference and its arguments separately to add_task() instead of calling the async function directly.

Reading the Stack Trace

Here's what each line means:

• File "/app/venv/lib/python3.11/site-packages/starlette/background.py", line 43, in __call__: Starlette's BackgroundTask runner is executing the queued task after the response has been sent.
• File "/app/src/tasks/notifications.py", line 12, in send_notification: The send_notification coroutine was passed incorrectly, causing the runtime to receive an unawaited coroutine object.
• File "/app/venv/lib/python3.11/site-packages/starlette/background.py", line 26, in __call__: BackgroundTask attempts to call the stored function but received a coroutine object instead of a callable.

Common Causes

@app.post("/orders")
async def create_order(
    order: OrderCreate,
    background_tasks: BackgroundTasks,
):
    new_order = save_order(order)
    background_tasks.add_task(send_notification(new_order.user_email, "Order placed"))
    return new_order

def notify_user(email: str):
    send_notification(email, "Hello")  # Returns unawaited coroutine

background_tasks.add_task(notify_user, user.email)

background_tasks.add_task(lambda: send_notification(email, subject))

The Fix

Pass the function reference (send_notification) and its arguments as separate parameters to add_task(). BackgroundTasks will call the function with the arguments after the response is sent. Do not call the async function yourself, as that creates a coroutine object instead of letting add_task manage execution.

@app.post("/orders")
async def create_order(
    order: OrderCreate,
    background_tasks: BackgroundTasks,
):
    new_order = save_order(order)
    background_tasks.add_task(send_notification(new_order.user_email, "Order placed"))
    return new_order

@app.post("/orders")
async def create_order(
    order: OrderCreate,
    background_tasks: BackgroundTasks,
):
    new_order = save_order(order)
    background_tasks.add_task(
        send_notification,
        new_order.user_email,
        "Order placed",
    )
    return new_order

Testing the Fix

import pytest
from unittest.mock import patch, AsyncMock
from fastapi.testclient import TestClient
from app.main import app

client = TestClient(app)


def test_create_order_returns_201():
    response = client.post(
        "/orders",
        json={"product_id": 1, "quantity": 2},
    )
    assert response.status_code in (200, 201)


@patch("app.tasks.notifications.send_notification", new_callable=AsyncMock)
def test_background_task_is_called(mock_send):
    response = client.post(
        "/orders",
        json={"product_id": 1, "quantity": 2},
    )
    assert response.status_code in (200, 201)
    mock_send.assert_called_once()


@patch("app.tasks.notifications.send_notification", new_callable=AsyncMock)
def test_background_task_receives_correct_args(mock_send):
    response = client.post(
        "/orders",
        json={"product_id": 1, "quantity": 2},
    )
    args = mock_send.call_args
    assert "Order placed" in str(args)

Run your tests:

pytest tests/test_background_tasks.py -v

Pushing Through CI/CD

git checkout -b fix/fastapi-background-task,git add src/routes/orders.py tests/test_background_tasks.py,git commit -m "fix: pass function reference to add_task instead of coroutine",git push origin fix/fastapi-background-task

Your CI config should look something like this:

name: CI
on:
  pull_request:
    branches: [main]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.11'
          cache: 'pip'
      - run: pip install -r requirements.txt
      - run: pytest --tb=short -q

The Full Manual Process: 18 Steps

Here's every step you just went through to fix this one bug:

1. Notice the error alert or see it in your monitoring tool
2. Open the error dashboard and read the stack trace
3. Identify the file and line number from the stack trace
4. Open your IDE and navigate to the file
5. Read the surrounding code to understand context
6. Reproduce the error locally
7. Identify the root cause
8. Write the fix
9. Run the test suite locally
10. Fix any failing tests
11. Write new tests covering the edge case
12. Run the full test suite again
13. Create a new git branch
14. Commit and push your changes
15. Open a pull request
16. Wait for code review
17. Merge and deploy to production
18. Monitor production to confirm the error is resolved

Total time: 30-60 minutes. For one bug.

pip install bugstack

import bugstack

bugstack.init(api_key=os.environ["BUGSTACK_API_KEY"])

Deploying the Fix (Manual Path)

1. Run the test suite locally to confirm background tasks execute correctly.
2. Open a pull request with the corrected add_task call.
3. Wait for CI checks to pass on the PR.
4. Have a teammate review and approve the PR.
5. Merge to main and verify background task execution in staging logs.

Frequently Asked Questions