Async HTTP client calls in FastAPI - Performance & Optimization

Performance: Async HTTP client calls

HIGH IMPACT

This affects how quickly the server can handle multiple HTTP requests without blocking, improving response time and throughput.

Making multiple HTTP requests to external APIs in a FastAPI endpoint

FastAPI

import httpx
import asyncio
from fastapi import FastAPI

app = FastAPI()

@app.get('/data')
async def get_data():
    async with httpx.AsyncClient() as client:
        response1, response2 = await asyncio.gather(
            client.get('https://api.example.com/one'),
            client.get('https://api.example.com/two')
        )
    return {'one': response1.json(), 'two': response2.json()}

Async HTTP client allows concurrent requests without blocking, improving response time and server throughput.

📈 Performance GainNon-blocking calls, parallel requests reduce total wait time, improves INP

Making multiple HTTP requests to external APIs in a FastAPI endpoint

FastAPI

import requests
from fastapi import FastAPI

app = FastAPI()

@app.get('/data')
def get_data():
    response1 = requests.get('https://api.example.com/one')
    response2 = requests.get('https://api.example.com/two')
    return {'one': response1.json(), 'two': response2.json()}

The requests library is synchronous and blocks the server while waiting for each HTTP call, causing slow response and poor concurrency.

📉 Performance CostBlocks event loop, increases response time linearly with each request, reduces throughput

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Synchronous HTTP calls (requests)	N/A (server-side)	Blocks event loop	Delays response rendering	[X] Bad
Async HTTP calls with httpx.AsyncClient	N/A (server-side)	Non-blocking event loop	Faster response rendering	[OK] Good

Rendering Pipeline

Async HTTP calls in FastAPI do not block the event loop, allowing the server to handle other requests while waiting for external responses. This reduces server-side waiting time and improves responsiveness.

→Server Request Handling

→Event Loop

→Network I/O

⚠️ BottleneckBlocking synchronous HTTP calls cause the event loop to wait, delaying all other tasks.

Core Web Vital Affected

INP

This affects how quickly the server can handle multiple HTTP requests without blocking, improving response time and throughput.

Optimization Tips

1Avoid synchronous HTTP calls in async FastAPI endpoints to prevent blocking.

2Use httpx.AsyncClient with asyncio.gather for concurrent HTTP requests.

3Monitor server event loop responsiveness to ensure non-blocking behavior.

Performance Quiz - 3 Questions

Why are synchronous HTTP client calls in FastAPI endpoints bad for performance?

A They use too much memory.

B They block the event loop, delaying other requests.

C They cause layout shifts in the browser.

D They increase CSS selector complexity.

DevTools: Network and Performance panels

How to check: Use the Network panel to observe request timing and the Performance panel to see if the main thread is blocked during HTTP calls.

What to look for: Look for long blocking times or queued tasks in the Performance panel indicating synchronous blocking; shorter wait times and parallel requests indicate good async usage.

Practice

1. What is the main benefit of using async HTTP client calls in a FastAPI application?

easy

A. They allow the app to handle other tasks while waiting for the HTTP response.

B. They make the HTTP response faster from the server side.

C. They automatically cache all HTTP responses.

D. They convert HTTP calls into database queries.

Solution

1. Step 1: Understand async behavior in FastAPI

   Async calls let the app continue working without waiting for the HTTP response, improving responsiveness.

2. Step 2: Identify the benefit of async HTTP client calls

   This means the app can handle other requests or tasks while waiting, making it efficient.

3. Final Answer:

   They allow the app to handle other tasks while waiting for the HTTP response. -> Option A

4. Quick Check:

   Async calls improve responsiveness = B [OK]

Hint: Async means non-blocking wait for HTTP response [OK]

Common Mistakes:

• Thinking async makes server response faster
• Confusing async with caching
• Believing async converts HTTP to database calls

2. Which of the following is the correct way to create an async HTTP client call using httpx in FastAPI?

easy

A. async with httpx.AsyncClient() as client: response = await client.get('https://example.com')

B. response = httpx.get('https://example.com')

C. client = httpx.Client(); response = client.get('https://example.com')

D. client = httpx.AsyncClient(); response = client.get('https://example.com')

Solution

1. Step 1: Identify async client usage

   Using async with ensures proper resource management for async clients.

2. Step 2: Use await to wait for the async HTTP call

   The call to client.get() must be awaited to get the response asynchronously.

3. Final Answer:

   async with httpx.AsyncClient() as client: response = await client.get('https://example.com') -> Option A

4. Quick Check:

   Use async with and await for async calls = C [OK]

Hint: Use async with and await for async HTTP calls [OK]

Common Mistakes:

• Using httpx.Client instead of AsyncClient for async calls
• Not using await with async client.get()
• Not using async with for client context

3. What will be the output of this FastAPI async function when called?

import httpx
from fastapi import FastAPI
app = FastAPI()

@app.get('/data')
async def get_data():
    async with httpx.AsyncClient() as client:
        response = await client.get('https://httpbin.org/get')
    return {'status_code': response.status_code}

medium

A. SyntaxError in async function

B. {'status_code': '200'}

C. RuntimeError due to missing await

D. {'status_code': 200}

Solution

1. Step 1: Analyze the async HTTP call

   The function uses await with client.get(), so it correctly waits for the response.

2. Step 2: Check the returned data

   The response status code is an integer 200 for a successful HTTP GET, returned inside a dictionary.

3. Final Answer:

   {'status_code': 200} -> Option D

4. Quick Check:

   Awaited async call returns status 200 = A [OK]

Hint: Await async calls to get response object correctly [OK]

Common Mistakes:

• Returning status code as string instead of int
• Forgetting await causing runtime errors
• Syntax errors from incorrect async usage

4. Identify the error in this FastAPI async HTTP client code:

import httpx
from fastapi import FastAPI
app = FastAPI()

@app.get('/info')
async def get_info():
    client = httpx.AsyncClient()
    response = client.get('https://httpbin.org/get')
    return {'status': response.status_code}

medium

A. Using httpx.Client instead of AsyncClient

B. Missing await before client.get() call

C. Missing async keyword in function definition

D. Incorrect return type, should return string

Solution

1. Step 1: Check async call usage

   The client.get() is an async method and must be awaited to get the response.

2. Step 2: Identify missing await

   Without await, the code returns a coroutine object, causing errors when accessing status_code.

3. Final Answer:

   Missing await before client.get() call -> Option B

4. Quick Check:

   Async calls require await = A [OK]

Hint: Always await async client.get() calls [OK]

Common Mistakes:

• Not awaiting async HTTP calls
• Using sync client in async function
• Forgetting async keyword on function

5. You want to fetch data from two different URLs concurrently in a FastAPI async endpoint. Which code correctly achieves this using httpx.AsyncClient?

hard

A. async with httpx.AsyncClient() as client:
r1 = await client.get(url1)
r2 = await client.get(url2)
return {'r1': r1.status_code, 'r2': r2.status_code}

B. async with httpx.AsyncClient() as client:
r1, r2 = await client.get(url1), await client.get(url2)
return {'r1': r1.status_code, 'r2': r2.status_code}

C. async with httpx.AsyncClient() as client:
import asyncio
r1, r2 = await asyncio.gather(client.get(url1), client.get(url2))
return {'r1': r1.status_code, 'r2': r2.status_code}

D. client = httpx.AsyncClient()
r1 = client.get(url1)
r2 = client.get(url2)
return {'r1': r1.status_code, 'r2': r2.status_code}

Solution

1. Step 1: Understand concurrency with async HTTP calls

   To run multiple async calls concurrently, use asyncio.gather() to await them together.

2. Step 2: Check code correctness

   async with httpx.AsyncClient() as client: import asyncio r1, r2 = await asyncio.gather(client.get(url1), client.get(url2)) return {'r1': r1.status_code, 'r2': r2.status_code} uses asyncio.gather() inside async with context, correctly awaiting both calls concurrently.

3. Final Answer:

   async with httpx.AsyncClient() as client: import asyncio r1, r2 = await asyncio.gather(client.get(url1), client.get(url2)) return {'r1': r1.status_code, 'r2': r2.status_code} -> Option C

4. Quick Check:

   Use asyncio.gather for concurrent async calls = D [OK]

Hint: Use asyncio.gather to await multiple async calls concurrently [OK]

Common Mistakes:

• Awaiting calls sequentially losing concurrency
• Not awaiting calls causing coroutine errors
• Not using async with for client context