AsyncClient() blocked event loop

[ClericPy]

import asyncio
import time
from httpx import AsyncClient


async def main():
    start = time.time()
    async_client = AsyncClient()
    #! here we see that creating AsyncClient() is blocking
    # Executing <Task pending name='Task-1' coro=<main() running at c:\apps\github\morebuiltins\temp4.py:18> cb=[_run_until_complete_cb() at c:\Users\apps\AppData\Local\Programs\Python\Python313\Lib\asyncio\base_events.py:181] created at c:\Users\apps\AppData\Local\Programs\Python\Python313\Lib\asyncio\runners.py:100> took 0.624 seconds
    print("create client:", round(time.time() - start, 6), flush=True)
    # create client: 0.6s, and this blocked event loop
    start = time.time()
    async with async_client as req:
        await req.get("https://httpbin.org/delay/1")

    # non-block init if
    # c = await asyncio.to_thread(AsyncClient)


# debug=True to see the blocking time
asyncio.run(main(), debug=True)

AsyncClient() itself is a synchronous function. Placing it inside an async def coroutine will block the main thread's event loop — you can see a warning by enabling asyncio's debug mode.

Currently, this problem is solved in two ways: either using asyncio.to_thread to avoid blocking during lazy initialization, or sharing the object after it has been asynchronously initialized.

Should there be an official, native solution to non-blockingly initialize it within an async def coroutine using the syntax async with AsyncClient() as client:?

[amasen02]

Here is an exact profiling breakdown of what is happening under the hood, why it blocks for 100–600ms on initial instantiation, and the recommended patterns to resolve it.

Profiling: Where the 0.6s goes

Running Python's cProfile on AsyncClient() reveals the exact bottleneck:

ncalls  tottime  cumtime  filename:lineno(function)
     1    0.000    0.217  httpx/_client.py:1353(__init__)
     1    0.000    0.216  httpx/_transports/default.py:280(__init__)
     1    0.000    0.137  httpx/_config.py:23(create_ssl_context)
     1    0.135    0.135  {method 'load_verify_locations' of '_ssl._SSLContext' objects}
 141/3    0.001    0.081  <frozen importlib._bootstrap>:1349(_find_and_load) (httpcore import)

The blocking time comes almost entirely from two synchronous OS operations:

1. load_verify_locations: By default, verify=True calls create_ssl_context(), which reads the root certificate bundle (certifi PEM file or Windows CryptoAPI store) from disk and parses hundreds of X.509 certificates synchronously into OpenSSL's memory.
2. Lazy Module Imports: httpcore and its underlying connection backends (anyio, sniffio) are imported lazily inside _init_transport when the first client is instantiated.

---

Why AsyncClient should NOT be instantiated per-request

In HTTPX (and asynchronous networking in general), AsyncClient manages a connection pool. Creating an AsyncClient inside a coroutine or request handler (async with AsyncClient() as client: ...) causes three critical issues:

1. Event loop stalls: You pay the SSL disk I/O and certificate parsing overhead on every single request.
2. Zero connection reuse: The HTTP/1.1 keep-alive connection pool and HTTP/2 multiplexing streams are discarded as soon as the block exits.
3. Socket exhaustion (TIME_WAIT): Rapidly opening and closing clients can exhaust available OS ports.

---

Recommended Solutions

1. The Production Pattern: Long-Lived Client (Singleton / Lifespan)

Treat AsyncClient as an application-level dependency that lives across the lifespan of your service (e.g. FastAPI lifespan, a global worker pool, or class instance):

import asyncio
from contextlib import asynccontextmanager
from httpx import AsyncClient

class AppState:
    client: AsyncClient

state = AppState()

async def startup():
    # Initialize once at application start -- event loop is not yet handling traffic
    state.client = AsyncClient(timeout=10.0)

async def shutdown():
    await state.client.aclose()

async def fetch_item():
    # Zero init overhead, uses existing keep-alive connections:
    response = await state.client.get("https://httpbin.org/delay/1")
    return response.json()

2. Pre-create the SSL Context if multiple clients are strictly required

If your architecture truly requires spinning up separate clients, you can eliminate ~80% of the initialization delay by creating the SSL context once and reusing it:

import httpx

# Create SSL context once at module import time (or in a worker thread)
SHARED_SSL_CONTEXT = httpx.create_ssl_context()

async def worker():
    # Bypasses disk reading and cert parsing:
    async with httpx.AsyncClient(verify=SHARED_SSL_CONTEXT) as client:
        await client.get("https://httpbin.org/get")

3. Offload to Thread (asyncio.to_thread) for Ad-Hoc Scripts

If running in an ad-hoc script where client creation must occur inside an active event loop and cannot be moved to startup, offloading the synchronous SSL file I/O to a worker thread via asyncio.to_thread is the cleanest approach:

client = await asyncio.to_thread(httpx.AsyncClient, verify=SHARED_SSL_CONTEXT)