A Practical Guide to aiohttp: Building High-Performance HTTP Clients and Servers with Asynchronous Programming

“Requests allows us to elegantly send requests synchronously, while aiohttp opens the door to the asynchronous world.”

🧠 What is aiohttp?

<span>aiohttp</span> is the most popular asynchronous HTTP client and server framework in Python, built on top of <span>asyncio</span>. It performs excellently in scenarios involving high concurrency requests, real-time communication, and microservice interfaces.

You can think of it as:

• An asynchronous version of <span>requests</span> (client)
• A lightweight asynchronous version of <span>Flask</span> (server)

📦 Quick Installation

pip install aiohttp

🚀 Practical Application Scenarios

We will master <span>aiohttp</span> through the following four real scenarios:

1. Concurrent web scraping (client)
2. Asynchronous API aggregation (client)
3. Building a RESTful API (server)
4. Setting up a WebSocket communication service (server)

✅ Scenario 1: Asynchronous Concurrent Web Scraping

Compared to <span>requests</span>, which can only send one request at a time, <span>aiohttp</span> can send dozens or even hundreds of requests simultaneously.

import asyncio
import aiohttp

async def fetch(url, session):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = [f"https://httpbin.org/delay/1?i={i}" for i in range(10)]
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(url, session) for url in urls]
        responses = await asyncio.gather(*tasks)
        print(f"Fetched {len(responses)} web pages")

asyncio.run(main())

🧪 Test Result: 10 requests completed in about 1 second (nearly 10 times faster than synchronous).

✅ Scenario 2: API Aggregation Middleware

async def get_weather(session):
    async with session.get("https://api.weatherapi.com/xxx") as resp:
        return await resp.json()

async def get_news(session):
    async with session.get("https://api.newsapi.org/xxx") as resp:
        return await resp.json()

async def aggregate_data():
    async with aiohttp.ClientSession() as session:
        weather, news = await asyncio.gather(
            get_weather(session),
            get_news(session)
        )
        return {"weather": weather, "news": news}

✅ Suitable for aggregating multiple third-party APIs to return a unified result, significantly improving response speed.

✅ Scenario 3: Building an Asynchronous RESTful Server

from aiohttp import web

async def handle(request):
    return web.json_response({"message": "Hello aiohttp!"})

app = web.Application()
app.add_routes([web.get("/", handle)])

if __name__ == '__main__':
    web.run_app(app, port=8080)

🌐 Access: http://localhost:8080/

✅ Scenario 4: WebSocket Real-Time Communication

from aiohttp import web

async def websocket_handler(request):
    ws = web.WebSocketResponse()
    await ws.prepare(request)

    async for msg in ws:
        if msg.type == web.WSMsgType.TEXT:
            await ws.send_str(f"You said: {msg.data}")

    return ws

app = web.Application()
app.router.add_get("/ws", websocket_handler)
web.run_app(app)

💬 After the client connects, real-time bidirectional communication is possible, making it ideal for:

• Chat systems
• Real-time data push
• Collaborative editing

🛡️ Some Advanced Features of aiohttp

• Supports connection pools, timeouts, and retry mechanisms
• Supports middleware (interceptors)
• Supports Cookies, Headers, and authentication mechanisms
• Perfectly integrates with <span>asyncio</span> for task queues and timeout control

🧠 aiohttp vs requests vs httpx

Feature	requests ✅	aiohttp ✅	httpx ✅
Sync Support	✅	❌	✅
Async Support	❌	✅	✅
Client Performance	Medium	High	High
Server Functionality	❌	✅	❌
WebSocket Support	❌	✅	❌

👉 If you are using asyncio, choose aiohttp; in the synchronous world, requests still reign supreme.

✅ Practical Tips Collection

1. Set Timeout

   timeout = aiohttp.ClientTimeout(total=5)
   async with aiohttp.ClientSession(timeout=timeout) as session:
       ...
   

2. Set Connection Pool Size

   connector = aiohttp.TCPConnector(limit=10)
   session = aiohttp.ClientSession(connector=connector)
   

3. Set Retry Mechanism (with tenacity)

   from tenacity import retry
   
   @retry
   async def robust_fetch(...):
       ...
   

4. Packet Capture Debugging

   import logging
   logging.basicConfig(level=logging.DEBUG)
   

📚 Recommended Learning Resources

• Official aiohttp Documentation
• “Python Asynchronous Programming in Practice”
• Project Recommendation: FastAPI (built on Starlette + aiohttp)

🔚 Conclusion

• <span>aiohttp</span> is one of the most mature asynchronous HTTP frameworks in Python.
• Supports high-concurrency client scraping, API aggregation, WebSocket, and API microservices.
• Lightweight and efficient, suitable for various scenarios such as asynchronous microservice architecture, scraping platforms, and real-time systems.

If you are using asyncio but haven’t used aiohttp, it’s like having a car but still walking.

If you found this helpful,📌 please click “Like” + Save and feel free to follow the WeChat public account “Python Module Master” for more practical content 🚀