QuickStart

First, start by importing HTTPX:

>>> import httpx

Now, let’s try to get a webpage.

>>> r = httpx.get('https://httpbin.org/get')
>>> r
<Response [200 OK]>

Similarly, to make an HTTP POST request:

>>> r = httpx.post('https://httpbin.org/post', data={'key': 'value'})

The PUT, DELETE, HEAD, and OPTIONS requests all follow the same style:

>>> r = httpx.put('https://httpbin.org/put', data={'key': 'value'})
>>> r = httpx.delete('https://httpbin.org/delete')
>>> r = httpx.head('https://httpbin.org/get')
>>> r = httpx.options('https://httpbin.org/get')

Passing Parameters in URLs

To include URL query parameters in the request, use the params keyword:

>>> params = {'key1': 'value1', 'key2': 'value2'}
>>> r = httpx.get('https://httpbin.org/get', params=params)

To see how the values get encoding into the URL string, we can inspect the resulting URL that was used to make the request:

>>> r.url
URL('https://httpbin.org/get?key2=value2&key1=value1')

You can also pass a list of items as a value:

>>> params = {'key1': 'value1', 'key2': ['value2', 'value3']}
>>> r = httpx.get('https://httpbin.org/get', params=params)
>>> r.url
URL('https://httpbin.org/get?key1=value1&key2=value2&key2=value3')

Response Content

HTTPX will automatically handle decoding the response content into Unicode text.

>>> r = httpx.get('https://www.example.org/')
>>> r.text
'<!doctype html>\n<html>\n<head>\n<title>Example Domain</title>...'

You can inspect what encoding will be used to decode the response.

>>> r.encoding
'UTF-8'

In some cases the response may not contain an explicit encoding, in which case HTTPX will attempt to automatically determine an encoding to use.

>>> r.encoding
None
>>> r.text
'<!doctype html>\n<html>\n<head>\n<title>Example Domain</title>...'

If you need to override the standard behaviour and explicitly set the encoding to use, then you can do that too.

>>> r.encoding = 'ISO-8859-1'

Binary Response Content

The response content can also be accessed as bytes, for non-text responses:

>>> r.content
b'<!doctype html>\n<html>\n<head>\n<title>Example Domain</title>...'

Any gzip and deflate HTTP response encodings will automatically be decoded for you. If brotlipy is installed, then the brotli response encoding will be supported. If zstandard is installed, then zstd response encodings will also be supported.

For example, to create an image from binary data returned by a request, you can use the following code:

>>> from PIL import Image
>>> from io import BytesIO
>>> i = Image.open(BytesIO(r.content))

JSON Response Content

Often Web API responses will be encoded as JSON.

>>> r = httpx.get('https://api.github.com/events')
>>> r.json()
[{u'repository': {u'open_issues': 0, u'url': 'https://github.com/...' ...  }}]

Custom Headers

To include additional headers in the outgoing request, use the headers keyword argument:

>>> url = 'https://httpbin.org/headers'
>>> headers = {'user-agent': 'my-app/0.0.1'}
>>> r = httpx.get(url, headers=headers)

Sending Form Encoded Data

Some types of HTTP requests, such as POST and PUT requests, can include data in the request body. One common way of including that is as form-encoded data, which is used for HTML forms.

>>> data = {'key1': 'value1', 'key2': 'value2'}
>>> r = httpx.post("https://httpbin.org/post", data=data)
>>> print(r.text)
{
  ...
  "form": {
    "key2": "value2",
    "key1": "value1"
  },
  ...
}

Form encoded data can also include multiple values from a given key.

>>> data = {'key1': ['value1', 'value2']}
>>> r = httpx.post("https://httpbin.org/post", data=data)
>>> print(r.text)
{
  ...
  "form": {
    "key1": [
      "value1",
      "value2"
    ]
  },
  ...
}

Sending Multipart File Uploads and/or Data

You can also upload files, using HTTP multipart encoding:

>>> files = {'upload-file': open('report.xls', 'rb')}
>>> r = httpx.post("https://httpbin.org/post", files=files)
>>> print(r.text)
{
  ...
  "files": {
    "upload-file": "<... binary content ...>"
  },
  ...
}

You can also explicitly set the filename and content type, by using a tuple of items for the file value:

>>> files = {'upload-file': ('report.xls', open('report.xls', 'rb'), 'application/vnd.ms-excel')}
>>> r = httpx.post("https://httpbin.org/post", files=files)
>>> print(r.text)
{
  ...
  "files": {
    "upload-file": "<... binary content ...>"
  },
  ...
}

If you need to include non-file data fields in the multipart form, use the data=... parameter:

>>> data = {'message': 'Hello, world!'}
>>> files = {'file': open('report.xls', 'rb')}
>>> r = httpx.post("https://httpbin.org/post", data=data, files=files)
>>> print(r.text)
{
  ...
  "files": {
    "file": "<... binary content ...>"
  },
  "form": {
    "message": "Hello, world!",
  },
  ...
}

If you need to send non-file data only, you can do so by using a tuple of items for the field value without a filename:

>>> files = {'some-field': (None, "field-value")}
>>> r = httpx.post("https://httpbin.org/post", files=files)
>>> print(r.text)
{
  ...
  "files": {},
  "form": {
    "some-field": "field-value"
  },
  ...
}

Sending JSON Encoded Data

Form encoded data is okay if all you need is a simple key-value data structure. For more complicated data structures you'll often want to use JSON encoding instead.

>>> data = {'integer': 123, 'boolean': True, 'list': ['a', 'b', 'c']}
>>> r = httpx.post("https://httpbin.org/post", json=data)
>>> print(r.text)
{
  ...
  "json": {
    "boolean": true,
    "integer": 123,
    "list": [
      "a",
      "b",
      "c"
    ]
  },
  ...
}

Sending Binary Request Data

For other encodings, you should use the content=... parameter, passing either a bytes type or a generator that yields bytes.

>>> content = b'Hello, world'
>>> r = httpx.post("https://httpbin.org/post", content=content)

You may also want to set a custom Content-Type header when uploading binary data.

Response Status Codes

We can inspect the HTTP status code of the response:

>>> r = httpx.get('https://httpbin.org/get')
>>> r.status_code
200

HTTPX also includes an easy shortcut for accessing status codes by their text phrase.

>>> r.status_code == httpx.codes.OK
True

We can raise an exception for any responses which are not a 2xx success code:

>>> not_found = httpx.get('https://httpbin.org/status/404')
>>> not_found.status_code
404
>>> not_found.raise_for_status()
Traceback (most recent call last):
  File "/Users/tomchristie/GitHub/encode/httpcore/httpx/models.py", line 837, in raise_for_status
    raise HTTPStatusError(message, response=self)
httpx._exceptions.HTTPStatusError: 404 Client Error: Not Found for url: https://httpbin.org/status/404
For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404

Any successful response codes will return the Response instance rather than raising an exception.

>>> r.raise_for_status()

The method returns the response instance, allowing you to use it inline. For example:

>>> r = httpx.get('...').raise_for_status()
>>> data = httpx.get('...').raise_for_status().json()

Response Headers

The response headers are available as a dictionary-like interface.

>>> r.headers
Headers({
    'content-encoding': 'gzip',
    'transfer-encoding': 'chunked',
    'connection': 'close',
    'server': 'nginx/1.0.4',
    'x-runtime': '148ms',
    'etag': '"e1ca502697e5c9317743dc078f67693f"',
    'content-type': 'application/json'
})

The Headers data type is case-insensitive, so you can use any capitalization.

>>> r.headers['Content-Type']
'application/json'

>>> r.headers.get('content-type')
'application/json'

Multiple values for a single response header are represented as a single comma-separated value, as per RFC 7230:

A recipient MAY combine multiple header fields with the same field name into one “field-name: field-value” pair, without changing the semantics of the message, by appending each subsequent field-value to the combined field value in order, separated by a comma.

Streaming Responses

For large downloads you may want to use streaming responses that do not load the entire response body into memory at once.

You can stream the binary content of the response...

>>> with httpx.stream("GET", "https://www.example.com") as r:
...     for data in r.iter_bytes():
...         print(data)

Or the text of the response...

>>> with httpx.stream("GET", "https://www.example.com") as r:
...     for text in r.iter_text():
...         print(text)

Or stream the text, on a line-by-line basis...

>>> with httpx.stream("GET", "https://www.example.com") as r:
...     for line in r.iter_lines():
...         print(line)

HTTPX will use universal line endings, normalising all cases to \n.

In some cases you might want to access the raw bytes on the response without applying any HTTP content decoding. In this case any content encoding that the web server has applied such as gzip, deflate, brotli, or zstd will not be automatically decoded.

>>> with httpx.stream("GET", "https://www.example.com") as r:
...     for chunk in r.iter_raw():
...         print(chunk)

If you're using streaming responses in any of these ways then the response.content and response.text attributes will not be available, and will raise errors if accessed. However you can also use the response streaming functionality to conditionally load the response body:

>>> with httpx.stream("GET", "https://www.example.com") as r:
...     if int(r.headers['Content-Length']) < TOO_LONG:
...         r.read()
...         print(r.text)

Cookies

Any cookies that are set on the response can be easily accessed:

>>> r = httpx.get('https://httpbin.org/cookies/set?chocolate=chip')
>>> r.cookies['chocolate']
'chip'

To include cookies in an outgoing request, use the cookies parameter:

>>> cookies = {"peanut": "butter"}
>>> r = httpx.get('https://httpbin.org/cookies', cookies=cookies)
>>> r.json()
{'cookies': {'peanut': 'butter'}}

Cookies are returned in a Cookies instance, which is a dict-like data structure with additional API for accessing cookies by their domain or path.

>>> cookies = httpx.Cookies()
>>> cookies.set('cookie_on_domain', 'hello, there!', domain='httpbin.org')
>>> cookies.set('cookie_off_domain', 'nope.', domain='example.org')
>>> r = httpx.get('http://httpbin.org/cookies', cookies=cookies)
>>> r.json()
{'cookies': {'cookie_on_domain': 'hello, there!'}}

Redirection and History

By default, HTTPX will not follow redirects for all HTTP methods, although this can be explicitly enabled.

For example, GitHub redirects all HTTP requests to HTTPS.

>>> r = httpx.get('http://github.com/')
>>> r.status_code
301
>>> r.history
[]
>>> r.next_request
<Request('GET', 'https://github.com/')>

You can modify the default redirection handling with the follow_redirects parameter:

>>> r = httpx.get('http://github.com/', follow_redirects=True)
>>> r.url
URL('https://github.com/')
>>> r.status_code
200
>>> r.history
[<Response [301 Moved Permanently]>]

The history property of the response can be used to inspect any followed redirects. It contains a list of any redirect responses that were followed, in the order in which they were made.

Timeouts

HTTPX defaults to including reasonable timeouts for all network operations, meaning that if a connection is not properly established then it should always raise an error rather than hanging indefinitely.

The default timeout for network inactivity is five seconds. You can modify the value to be more or less strict:

>>> httpx.get('https://github.com/', timeout=0.001)

You can also disable the timeout behavior completely...

>>> httpx.get('https://github.com/', timeout=None)

For advanced timeout management, see Timeout fine-tuning.

Authentication

HTTPX supports Basic and Digest HTTP authentication.

To provide Basic authentication credentials, pass a 2-tuple of plaintext str or bytes objects as the auth argument to the request functions:

>>> httpx.get("https://example.com", auth=("my_user", "password123"))

To provide credentials for Digest authentication you'll need to instantiate a DigestAuth object with the plaintext username and password as arguments. This object can be then passed as the auth argument to the request methods as above:

>>> auth = httpx.DigestAuth("my_user", "password123")
>>> httpx.get("https://example.com", auth=auth)
<Response [200 OK]>

Exceptions

HTTPX will raise exceptions if an error occurs.

The most important exception classes in HTTPX are RequestError and HTTPStatusError.

The RequestError class is a superclass that encompasses any exception that occurs while issuing an HTTP request. These exceptions include a .request attribute.

try:
    response = httpx.get("https://www.example.com/")
except httpx.RequestError as exc:
    print(f"An error occurred while requesting {exc.request.url!r}.")

The HTTPStatusError class is raised by response.raise_for_status() on responses which are not a 2xx success code. These exceptions include both a .request and a .response attribute.

response = httpx.get("https://www.example.com/")
try:
    response.raise_for_status()
except httpx.HTTPStatusError as exc:
    print(f"Error response {exc.response.status_code} while requesting {exc.request.url!r}.")

There is also a base class HTTPError that includes both of these categories, and can be used to catch either failed requests, or 4xx and 5xx responses.

You can either use this base class to catch both categories...

try:
    response = httpx.get("https://www.example.com/")
    response.raise_for_status()
except httpx.HTTPError as exc:
    print(f"Error while requesting {exc.request.url!r}.")

Or handle each case explicitly...

try:
    response = httpx.get("https://www.example.com/")
    response.raise_for_status()
except httpx.RequestError as exc:
    print(f"An error occurred while requesting {exc.request.url!r}.")
except httpx.HTTPStatusError as exc:
    print(f"Error response {exc.response.status_code} while requesting {exc.request.url!r}.")

For a full list of available exceptions, see Exceptions (API Reference).

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

quickstart.md

quickstart.md

QuickStart

Passing Parameters in URLs

Response Content

Binary Response Content

JSON Response Content

Custom Headers

Sending Form Encoded Data

Sending Multipart File Uploads and/or Data

Sending JSON Encoded Data

Sending Binary Request Data

Response Status Codes

Response Headers

Streaming Responses

Cookies

Redirection and History

Timeouts

Authentication

Exceptions

Files

quickstart.md

Latest commit

History

quickstart.md

File metadata and controls

QuickStart

Passing Parameters in URLs

Response Content

Binary Response Content

JSON Response Content

Custom Headers

Sending Form Encoded Data

Sending Multipart File Uploads and/or Data

Sending JSON Encoded Data

Sending Binary Request Data

Response Status Codes

Response Headers

Streaming Responses

Cookies

Redirection and History

Timeouts

Authentication

Exceptions