Client Quickstart

Eager to get started? This page gives a good introduction in how to get started with aiohttp client API.

First, make sure that aiohttp is installed and up-to-date

Let’s get started with some simple examples.

Make a Request

Begin by importing the aiohttp module:

import aiohttp

Now, let’s try to get a web-page. For example let’s query

async with aiohttp.ClientSession() as session:
    async with session.get('') as resp:
        print(await resp.text())

Now, we have a ClientSession called session and a ClientResponse object called resp. We can get all the information we need from the response. The mandatory parameter of ClientSession.get() coroutine is an HTTP url (str or class:yarl.URL instance).

In order to make an HTTP POST request use coroutine:'', data=b'data')

Other HTTP methods are available as well:

session.put('', data=b'data')
session.patch('', data=b'data')


Don’t create a session per request. Most likely you need a session per application which performs all requests altogether.

More complex cases may require a session per site, e.g. one for Github and other one for Facebook APIs. Anyway making a session for every request is a very bad idea.

A session contains a connection pool inside. Connection reusage and keep-alives (both are on by default) may speed up total performance.

Passing Parameters In URLs

You often want to send some sort of data in the URL’s query string. If you were constructing the URL by hand, this data would be given as key/value pairs in the URL after a question mark, e.g. Requests allows you to provide these arguments as a dict, using the params keyword argument. As an example, if you wanted to pass key1=value1 and key2=value2 to, you would use the following code:

params = {'key1': 'value1', 'key2': 'value2'}
async with session.get('',
                       params=params) as resp:
    expect = ''
    assert str(resp.url) == expect

You can see that the URL has been correctly encoded by printing the URL.

For sending data with multiple values for the same key MultiDict may be used as well.

It is also possible to pass a list of 2 item tuples as parameters, in that case you can specify multiple values for each key:

params = [('key', 'value1'), ('key', 'value2')]
async with session.get('',
                       params=params) as r:
    expect == ''
    assert str(r.url) == expect

You can also pass str content as param, but beware – content is not encoded by library. Note that + is not encoded:

async with session.get('',
                       params='key=value+1') as r:
        assert str(r.url) == ''


aiohttp internally performs URL canonization before sending request.

Canonization encodes host part by IDNA codec and applies requoting to path and query parts.

For example URL('путь%30?a=%31') is converted to URL('').

Sometimes canonization is not desirable if server accepts exact representation and does not requote URL itself.

To disable canonization use encoded=True parameter for URL construction:

await session.get(
    URL('', encoded=True))


Passing params overrides encoded=True, never use both options.

Response Content and Status Code

We can read the content of the server’s response and it’s status code. Consider the GitHub time-line again:

async with session.get('') as resp:
    print(await resp.text())

prints out something like:


aiohttp automatically decodes the content from the server. You can specify custom encoding for the text() method:

await resp.text(encoding='windows-1251')

Binary Response Content

You can also access the response body as bytes, for non-text requests:


The gzip and deflate transfer-encodings are automatically decoded for you.

You can enable brotli transfer-encodings support, just install brotlipy.

JSON Request

Any of session’s request methods like request(), ClientSession.get(), etc. accept json parameter:

async with aiohttp.ClientSession() as session:
    async with, json={'test': 'object'})

By default session uses python’s standard json module for serialization. But it is possible to use different serializer. ClientSession accepts json_serialize parameter:

import ujson

async with aiohttp.ClientSession(
        json_serialize=ujson.dumps) as session:
    await, json={'test': 'object'})


ujson library is faster than standard json but slightly incompatible.

JSON Response Content

There’s also a built-in JSON decoder, in case you’re dealing with JSON data:

async with session.get('') as resp:
    print(await resp.json())

In case that JSON decoding fails, json() will raise an exception. It is possible to specify custom encoding and decoder functions for the json() call.


The methods above reads the whole response body into memory. If you are planning on reading lots of data, consider using the streaming response method documented below.

Streaming Response Content

While methods read(), json() and text() are very convenient you should use them carefully. All these methods load the whole response in memory. For example if you want to download several gigabyte sized files, these methods will load all the data in memory. Instead you can use the content attribute. It is an instance of the aiohttp.StreamReader class. The gzip and deflate transfer-encodings are automatically decoded for you:

async with session.get('') as resp:

In general, however, you should use a pattern like this to save what is being streamed to a file:

with open(filename, 'wb') as fd:
    while True:
        chunk = await
        if not chunk:

It is not possible to use read(), json() and text() after explicit reading from content.

More complicated POST requests

Typically, you want to send some form-encoded data – much like an HTML form. To do this, simply pass a dictionary to the data argument. Your dictionary of data will automatically be form-encoded when the request is made:

payload = {'key1': 'value1', 'key2': 'value2'}
async with'',
                        data=payload) as resp:
    print(await resp.text())
  "form": {
    "key2": "value2",
    "key1": "value1"

If you want to send data that is not form-encoded you can do it by passing a bytes instead of a dict. This data will be posted directly and content-type set to ‘application/octet-stream’ by default:

async with, data=b'\x00Binary-data\x00') as resp:

If you want to send JSON data:

async with, json={'example': 'test'}) as resp:

To send text with appropriate content-type just use text attribute

async with, text='Тест') as resp:

POST a Multipart-Encoded File

To upload Multipart-encoded files:

url = ''
files = {'file': open('report.xls', 'rb')}

await, data=files)

You can set the filename and content_type explicitly:

url = ''
data = FormData()
               open('report.xls', 'rb'),

await, data=data)

If you pass a file object as data parameter, aiohttp will stream it to the server automatically. Check StreamReader for supported format information.

Streaming uploads

aiohttp supports multiple types of streaming uploads, which allows you to send large files without reading them into memory.

As a simple case, simply provide a file-like object for your body:

with open('massive-body', 'rb') as f:
   await'', data=f)

Or you can use asynchronous generator:

async def file_sender(file_name=None):
    async with, 'rb') as f:
        chunk = await*1024)
        while chunk:
            yield chunk
            chunk = await*1024)

# Then you can use file_sender as a data provider:

async with'',
                        data=file_sender(file_name='huge_file')) as resp:
    print(await resp.text())

Because the content attribute is a StreamReader (provides async iterator protocol), you can chain get and post requests together:

resp = await session.get('')


Python 3.5 has no native support for asynchronous generators, use async_generator library as workaround.

Deprecated since version 3.1: aiohttp still supports aiohttp.streamer decorator but this approach is deprecated in favor of asynchronous generators as shown above.


aiohttp works with client websockets out-of-the-box.

You have to use the aiohttp.ClientSession.ws_connect() coroutine for client websocket connection. It accepts a url as a first parameter and returns ClientWebSocketResponse, with that object you can communicate with websocket server using response’s methods:

session = aiohttp.ClientSession()
async with session.ws_connect('') as ws:

    async for msg in ws:
        if msg.type == aiohttp.WSMsgType.TEXT:
            if == 'close cmd':
                await ws.close()
                await ws.send_str( + '/answer')
        elif msg.type == aiohttp.WSMsgType.CLOSED:
        elif msg.type == aiohttp.WSMsgType.ERROR:

You must use the only websocket task for both reading (e.g. await ws.receive() or async for msg in ws:) and writing but may have multiple writer tasks which can only send data asynchronously (by await ws.send_str('data') for example).


By default all IO operations have 5min timeout. The timeout may be overridden by passing timeout parameter into ClientSession.get() and family:

async with session.get('', timeout=60) as r:

None or 0 disables timeout check.

The example wraps a client call in async_timeout.timeout() context manager, adding timeout for both connecting and response body reading procedures:

import async_timeout

with async_timeout.timeout(0.001):
    async with session.get('') as r:
        await r.text()


Timeout is cumulative time, it includes all operations like sending request, redirects, response parsing, consuming response, etc.