Forwarding starlette / ASGI requests as a reverse proxy

[couling]

I'm working through a POC for something and I'm investigating the possibility of using HTTPX as part of what effectively amounts to a reverse proxy. IE an ASGI / Starlette web app that has route which will recieve requests and forward them onto other microservives.

I wanted to know if httpx has anything that can aid transforming http requests from starlette (or raw ASGI) into httpx requests and visa versa with responses. I'm aware there could be quite a lot of complexity with this including chunked request / response bodies and http trailers to name just to edge cases.

Have I missed anything in httpx or supporting libraries that might help interpreting and forwarding ASGI requests?

[s-chudmunge]

httpx has built-in support for interacting with ASGI apps directly via httpx.ASGITransport:

import httpx

# In an ASGI handler or route:
transport = httpx.ASGITransport(app=downstream_asgi_app)
async with httpx.AsyncClient(transport=transport, base_url="http://internal") as client:
    response = await client.get("/target-path")

However, if your downstream services are independent HTTP microservices over a network, you need a reverse-proxy bridge. Rather than building custom request/response translation from scratch, the standard community tools for ASGI/Starlette reverse proxying with HTTPX are:

1. Dedicated proxy packages built on HTTPX

• asgi-proxy-lib / httpx-reverse-proxy: Specifically designed to forward raw ASGI scope, receive, and send streams through HTTPX, handling chunked transfer, headers hop-by-hop filtering, and streaming bodies without buffering the entire payload in memory.

2. Manual forwarding with httpx.AsyncClient streaming

If you want to implement it inside a Starlette route using HTTPX directly:

import httpx
from starlette.requests import Request
from starlette.responses import StreamingResponse

# Hop-by-hop headers that must not be forwarded by a proxy (RFC 2616 / 7230)
HOP_BY_HOP_HEADERS = {
    "connection", "keep-alive", "proxy-authenticate",
    "proxy-authorization", "te", "trailers",
    "transfer-encoding", "upgrade", "content-length"
}

async def reverse_proxy(request: Request, upstream_url: str):
    # Forward headers excluding hop-by-hop
    headers = {
        k: v for k, v in request.headers.items()
        if k.lower() not in HOP_BY_HOP_HEADERS and k.lower() != "host"
    }

    client = httpx.AsyncClient()
    # Stream the incoming ASGI request body directly to upstream
    upstream_req = client.build_request(
        method=request.method,
        url=upstream_url,
        headers=headers,
        content=request.stream(),
    )
    upstream_resp = await client.send(upstream_req, stream=True)

    # Filter response headers
    resp_headers = {
        k: v for k, v in upstream_resp.headers.items()
        if k.lower() not in HOP_BY_HOP_HEADERS
    }

    return StreamingResponse(
        upstream_resp.aiter_raw(),
        status_code=upstream_resp.status_code,
        headers=resp_headers,
        background=httpx.Response.aclose(upstream_resp),
    )

Key things to handle when doing this:

• Streaming bodies: Use request.stream() for the request and upstream_resp.aiter_raw() wrapped in StreamingResponse to avoid loading large payloads into memory.
• Hop-by-hop headers: RFC 7230 requires stripping headers like Transfer-Encoding, Connection, and Keep-Alive.
• Client lifetime: In production, share a pooled httpx.AsyncClient instance stored on app.state or managed via ASGI lifespan rather than creating a new client per request.

[couling]

Looks like an AI generated answer that hasn’t been checked

The links are broken and appear to reference early alpha libraries if they exist.

I would take the information here with caution.

[DENGYaqi]

One correction to the manual streaming example above: background=httpx.Response.aclose(upstream_resp) calls the async method immediately and passes a coroutine to Starlette, rather than scheduling a callable to close the upstream response.

Use Starlette's BackgroundTask with the method, without calling it:

from starlette.background import BackgroundTask

return StreamingResponse(
    upstream_resp.aiter_raw(),
    status_code=upstream_resp.status_code,
    headers=resp_headers,
    background=BackgroundTask(upstream_resp.aclose),
)

This is the pattern in HTTPX's manual streaming documentation. I checked it with HTTPX 0.28.1 and Starlette 1.6.0 using an in-memory upstream and ASGI client: the proxy returned the streamed body, and the upstream response stream was closed afterward. The shared AsyncClient also needs to be closed at application shutdown.