HTTPX

https://www.python-httpx.org/
Admin
HTTPX is a fully-featured HTTP client for Python 3 that provides sync and async APIs, and support...
Tokens:61,026
Snippets:529
Trust Score:9.8
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### AnyIO example with httpx.AsyncClient

Source: https://www.python-httpx.org/async

Uses the anyio library with httpx.AsyncClient to make a GET request. AnyIO works on top of either asyncio or trio, defaulting to asyncio. The example explicitly selects the trio backend with backend='trio'.

```python
import httpx
import anyio

async def main():
    async with httpx.AsyncClient() as client:
        response = await client.get('https://www.example.com/')
        print(response)

anyio.run(main, backend='trio')

```

--------------------------------

### Install HTTPX CLI

Source: https://www.python-httpx.org/

Install the optional command-line client for HTTPX.

```bash
# The command line client is an optional dependency.
$ pip install 'httpx[cli]'

```

--------------------------------

### Install HTTPX with pip

Source: https://www.python-httpx.org/

Install HTTPX using pip.

```bash
$ pip install httpx

```

--------------------------------

### Install HTTPX development dependencies

Source: https://www.python-httpx.org/contributing

Navigate into the cloned repository and run the install script to set up the project and its dependencies.

```bash
$ cd httpx
$ scripts/install

```

--------------------------------

### Trio example with httpx.AsyncClient

Source: https://www.python-httpx.org/async

Uses the trio library with httpx.AsyncClient to make a GET request. The trio package must be installed to use the Trio backend. The main() coroutine is run with trio.run().

```python
import httpx
import trio

async def main():
    async with httpx.AsyncClient() as client:
        response = await client.get('https://www.example.com/')
        print(response)

trio.run(main)

```

--------------------------------

### Run documentation site locally with scripts/docs

Source: https://www.python-httpx.org/contributing

Starts a local documentation server for previewing changes to the docs.

```shell
$ scripts/docs

```

--------------------------------

### httpx.request() usage example

Source: https://www.python-httpx.org/api

Shows how to make a simple GET request using the httpx.request() helper. The output is a Response object with status 200 OK.

```python
>>> import httpx
>>> response = httpx.request('GET', 'https://httpbin.org/get')
>>> response
<Response [200 OK]>

```

--------------------------------

### Basic httpx.Client usage

Source: https://www.python-httpx.org/api

Creates a client and sends a GET request to example.org. The client can be shared between threads.

```python
>>> client = httpx.Client()
>>> response = client.get('https://example.org')

```

--------------------------------

### Import HTTPX

Source: https://www.python-httpx.org/quickstart

Starts by importing the httpx module.

```python
>>> import httpx

```

--------------------------------

### Install SOCKS support

Source: https://www.python-httpx.org/advanced/proxies

Installs optional SOCKS support for HTTPX via the httpx[socks] extra.

```bash
$ pip install httpx[socks]

```

--------------------------------

### Make a GET request with httpx.get

Source: https://www.python-httpx.org/quickstart

Shows how to make a GET request and displays the response object.

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

```

--------------------------------

### Install HTTPX with brotli and zstd support

Source: https://www.python-httpx.org/

Install HTTPX with optional brotli and zstandard decoders support.

```bash
$ pip install httpx[brotli,zstd]

```

--------------------------------

### Installing httpx and chardet

Source: https://www.python-httpx.org/advanced/text-encodings

Installs httpx and chardet, a package for character-set auto-detection.

```bash
$ pip install httpx
$ pip install chardet

```

--------------------------------

### Install HTTP/2 dependencies with pip install httpx[http2]

Source: https://www.python-httpx.org/http2

Install the optional HTTP/2 dependencies required to enable HTTP/2 support in httpx. Run this command in your terminal before using HTTP/2 features.

```bash
$ pip install httpx[http2]

```

--------------------------------

### .netrc file example

Source: https://www.python-httpx.org/advanced/authentication

Example .netrc file associating credentials with hosts. Used by httpx.NetRCAuth() for basic authentication.

```text
machine example.org
login example-username
password example-password

machine python-httpx.org
login other-username
password other-password
```

--------------------------------

### client.get()

Source: https://www.python-httpx.org/advanced/clients

Demonstrates how to use the client's get method to send requests, including custom headers and configuration merging.

```APIDOC
## [GET] client.get()

### Description
Sends a GET request using the client. Accepts the same arguments as `httpx.get()`.

### Method
GET

### Endpoint
`client.get(url, ...)`

### Parameters
#### Path Parameters
- **url** (string) - Required - The URL to send the request to.

#### Query Parameters
- **params** (dict) - Optional - Query parameters to include in the request. These are merged with client-level params.

#### Request Body
- **headers** (dict) - Optional - Headers to include in the request. These are merged with client-level headers.
- **auth** (tuple) - Optional - Authentication credentials. Overrides client-level auth.

### Request Example
```
client.get('https://example.com', headers={'X-Custom': 'value'})
```

### Response
#### Success Response (200)
- **response** (Response) - The response object.

#### Response Example
```
<Response [200 OK]>
```
```

--------------------------------

### AsyncIO example with httpx.AsyncClient

Source: https://www.python-httpx.org/async

Uses Python's built-in asyncio library with httpx.AsyncClient to make a GET request. The main() coroutine is run with asyncio.run().

```python
import asyncio
import httpx

async def main():
    async with httpx.AsyncClient() as client:
        response = await client.get('https://www.example.com/')
        print(response)

asyncio.run(main())

```

--------------------------------

### httpx.AsyncClient

Source: https://www.python-httpx.org/api

Documentation for the httpx.AsyncClient class, including its constructor parameters, properties, and usage example.

```APIDOC
## [AsyncClient] httpx.AsyncClient

### Description
An asynchronous HTTP client, with connection pooling, HTTP/2, redirects, cookie persistence, etc. It can be shared between tasks.

### Constructor Parameters
- **auth** (optional) - An authentication class to use when sending requests.
- **params** (optional) - Query parameters to include in request URLs, as a string, dictionary, or sequence of two-tuples.
- **headers** (optional) - Dictionary of HTTP headers to include when sending requests.
- **cookies** (optional) - Dictionary of Cookie items to include when sending requests.
- **verify** (optional) - Either `True` to use an SSL context with the default CA bundle, `False` to disable verification, or an instance of `ssl.SSLContext` to use a custom context.
- **http2** (optional) - A boolean indicating if HTTP/2 support should be enabled. Defaults to `False`.
- **proxy** (optional) - A proxy URL where all the traffic should be routed.
- **timeout** (optional) - The timeout configuration to use when sending requests.
- **limits** (optional) - The limits configuration to use.
- **max_redirects** (optional) - The maximum number of redirect responses that should be followed.
- **base_url** (optional) - A URL to use as the base when building request URLs.
- **transport** (optional) - A transport class to use for sending requests over the network.
- **trust_env** (optional) - Enables or disables usage of environment variables for configuration.
- **default_encoding** (optional) - The default encoding to use for decoding response text, if no charset information is included in a response Content-Type header. Set to a callable for automatic character set detection. Default: "utf-8".

### Usage Example
```python
async with httpx.AsyncClient() as client:
    response = await client.get('https://example.org')
```

### Properties
- **headers** - HTTP headers to include when sending requests.
- **cookies** - Cookie values to include when sending requests.
- **params** - Query parameters to include in the URL when sending requests.
- **auth** - Authentication class used when none is passed at the request-level.
```

--------------------------------

### Making a request with httpx.Client

Source: https://www.python-httpx.org/advanced/clients

Shows how to use httpx.Client to send a GET request. The response is a <Response [200 OK]> object.

```python
>>> with httpx.Client() as client:
...     r = client.get('https://example.com')
...
>>> r
<Response [200 OK]>

```

--------------------------------

### Client.get

Source: https://www.python-httpx.org/api

Send a GET request using the httpx.Client instance.

```APIDOC
## Client.get

### Description
Send a `GET` request using the `httpx.Client` instance.

### Method
GET

### Endpoint
`Client.get(url, *, params=None, headers=None, cookies=None, auth=..., follow_redirects=..., timeout=..., extensions=None)`

### Parameters
- **url** (str) - Required - The URL to send the request to.
- **params** (optional) - Query parameters to include in the request.
- **headers** (optional) - HTTP headers to include.
- **cookies** (optional) - Cookies to include.
- **auth** (optional) - Authentication credentials.
- **follow_redirects** (optional) - Whether to follow redirects.
- **timeout** (optional) - Timeout configuration.
- **extensions** (optional) - Request extensions.

### Response
Returns an `httpx.Response` object.

### Example
```python
client = httpx.Client()
response = client.get('https://example.com')
```
```

--------------------------------

### Use base_url to prepend URL to all requests

Source: https://www.python-httpx.org/advanced/clients

Shows how to set base_url on the Client so that relative paths are prepended with the base URL. The example uses httpbin.org and prints the resulting request URL.

```python
>>> with httpx.Client(base_url='http://httpbin.org') as client:
...     r = client.get('/headers')
...
>>> r.request.url
URL('http://httpbin.org/headers')

```

--------------------------------

### Monitor download progress with rich

Source: https://www.python-httpx.org/advanced/clients

Alternate progress bar example using the rich library. Streams a response and updates a rich progress bar with the number of bytes downloaded.

```python
import tempfile
import httpx
import rich.progress

with tempfile.NamedTemporaryFile() as download_file:
    url = "https://speed.hetzner.de/100MB.bin"
    with httpx.stream("GET", url) as response:
        total = int(response.headers["Content-Length"])

        with rich.progress.Progress(
            "[progress.percentage]{task.percentage:>3.0f}%",
            rich.progress.BarColumn(bar_width=None),
            rich.progress.DownloadColumn(),
            rich.progress.TransferSpeedColumn(),
        ) as progress:
            download_task = progress.add_task("Download", total=total)
            for chunk in response.iter_bytes():
                download_file.write(chunk)
                progress.update(download_task, completed=response.num_bytes_downloaded)

```

--------------------------------

### Basic authentication with httpx.BasicAuth

Source: https://www.python-httpx.org/advanced/authentication

Basic authentication example using httpx.BasicAuth with a client-level auth. The response is a 200 OK when the credentials are correct. Basic auth is unencrypted and should typically be used over https.

```python
>>> auth = httpx.BasicAuth(username="finley", password="secret")
>>> client = httpx.Client(auth=auth)
>>> response = client.get("https://httpbin.org/basic-auth/finley/secret")
>>> response
<Response [200 OK]>

```

--------------------------------

### Create image from binary response with PIL and BytesIO

Source: https://www.python-httpx.org/quickstart

Create an image from binary data returned by a request. Requires the Pillow library. The example opens the image from the bytes content using BytesIO.

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

--------------------------------

### Trace httpcore events with extensions

Source: https://www.python-httpx.org/advanced/extensions

Installs a trace callback to monitor internal httpcore events. The callback receives an event name and info dictionary; for async code the handler must be an async def function.

```python
import httpx

def log(event_name, info):
    print(event_name, info)

client = httpx.Client()
response = client.get("https://www.example.com/", extensions={"trace": log})
# connection.connect_tcp.started {'host': 'www.example.com', 'port': 443, 'local_address': None, 'timeout': None}
# connection.connect_tcp.complete {'return_value': <httpcore.backends.sync.SyncStream object at 0x1093f94d0>}
# connection.start_tls.started {'ssl_context': <ssl.SSLContext object at 0x1093ee750>, 'server_hostname': b'www.example.com', 'timeout': None}
# connection.start_tls.complete {'return_value': <httpcore.backends.sync.SyncStream object at 0x1093f9450>}
# http11.send_request_headers.started {'request': <Request [b'GET']>}
# http11.send_request_headers.complete {'return_value': None}
# http11.send_request_body.started {'request': <Request [b'GET']>}
# http11.send_request_body.complete {'return_value': None}
# http11.receive_response_headers.started {'request': <Request [b'GET']>}
# http11.receive_response_headers.complete {'return_value': (b'HTTP/1.1', 200, b'OK', [(b'Age', b'553715'), (b'Cache-Control', b'max-age=604800'), (b'Content-Type', b'text/html; charset=UTF-8'), (b'Date', b'Thu, 21 Oct 2021 17:08:42 GMT'), (b'Etag', b'"3147526947+ident"'), (b'Expires', b'Thu, 28 Oct 2021 17:08:42 GMT'), (b'Last-Modified', b'Thu, 17 Oct 2019 07:18:26 GMT'), (b'Server', b'ECS (nyb/1DCD)'), (b'Vary', b'Accept-Encoding'), (b'X-Cache', b'HIT'), (b'Content-Length', b'1256')])}
# http11.receive_response_body.started {'request': <Request [b'GET']>}
# http11.receive_response_body.complete {'return_value': None}
# http11.response_closed.started {}
# http11.response_closed.complete {'return_value': None}
```

--------------------------------

### Enable httpx debug logging with basicConfig

Source: https://www.python-httpx.org/logging

Configures Python's logging to DEBUG level and makes a GET request to https://www.example.com. The output shows the debug logs from both the httpx and httpcore loggers, including connection, TLS, and HTTP/1.1 request/response events.

```python
import logging
import httpx

logging.basicConfig(
    format="%(levelname)s [%(asctime)s] %(name)s - %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
    level=logging.DEBUG
)

httpx.get("https://www.example.com")

```

```text
DEBUG [2024-09-28 17:27:40] httpcore.connection - connect_tcp.started host='www.example.com' port=443 local_address=None timeout=5.0 socket_options=None
DEBUG [2024-09-28 17:27:41] httpcore.connection - connect_tcp.complete return_value=<httpcore._backends.sync.SyncStream object at 0x101f1e8e0>
DEBUG [2024-09-28 17:27:41] httpcore.connection - start_tls.started ssl_context=SSLContext(verify=True) server_hostname='www.example.com' timeout=5.0
DEBUG [2024-09-28 17:27:41] httpcore.connection - start_tls.complete return_value=<httpcore._backends.sync.SyncStream object at 0x1020f49a0>
DEBUG [2024-09-28 17:27:41] httpcore.http11 - send_request_headers.started request=<Request [b'GET']>
DEBUG [2024-09-28 17:27:41] httpcore.http11 - send_request_headers.complete
DEBUG [2024-09-28 17:27:41] httpcore.http11 - send_request_body.started request=<Request [b'GET']>
DEBUG [2024-09-28 17:27:41] httpcore.http11 - send_request_body.complete
DEBUG [2024-09-28 17:27:41] httpcore.http11 - receive_response_headers.started request=<Request [b'GET']>
DEBUG [2024-09-28 17:27:41] httpcore.http11 - receive_response_headers.complete return_value=(b'HTTP/1.1', 200, b'OK', [(b'Content-Encoding', b'gzip'), (b'Accept-Ranges', b'bytes'), (b'Age', b'407727'), (b'Cache-Control', b'max-age=604800'), (b'Content-Type', b'text/html; charset=UTF-8'), (b'Date', b'Sat, 28 Sep 2024 13:27:42 GMT'), (b'Etag', b'"3147526947+gzip"'), (b'Expires', b'Sat, 05 Oct 2024 13:27:42 GMT'), (b'Last-Modified', b'Thu, 17 Oct 2019 07:18:26 GMT'), (b'Server', b'ECAcc (dcd/7D43)'), (b'Vary', b'Accept-Encoding'), (b'X-Cache', b'HIT'), (b'Content-Length', b'648')])
INFO [2024-09-28 17:27:41] httpx - HTTP Request: GET https://www.example.com "HTTP/1.1 200 OK"
DEBUG [2024-09-28 17:27:41] httpcore.http11 - receive_response_body.started request=<Request [b'GET']>
DEBUG [2024-09-28 17:27:41] httpcore.http11 - receive_response_body.complete
DEBUG [2024-09-28 17:27:41] httpcore.http11 - response_closed.started
DEBUG [2024-09-28 17:27:41] httpcore.http11 - response_closed.complete
DEBUG [2024-09-28 17:27:41] httpcore.connection - close.started
DEBUG [2024-09-28 17:27:41] httpcore.connection - close.complete

```

--------------------------------

### Configure Proxy and create Client

Source: https://www.python-httpx.org/api

Creates a Proxy configuration and passes it to a Client.

```python
>>> proxy = Proxy("http://proxy.example.com:8030")
>>> client = Client(proxy=proxy)
```

--------------------------------

### Send request with custom headers

Source: https://www.python-httpx.org/quickstart

Send a GET request with custom headers using the headers keyword argument. The example sets a custom user-agent header.

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

--------------------------------

### Inspect response status code

Source: https://www.python-httpx.org/quickstart

Inspect the HTTP status code of a response using the status_code attribute. The example shows a successful GET request returning 200.

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

```

--------------------------------

### Set custom timeout with httpx.get

Source: https://www.python-httpx.org/quickstart

Sets a custom network inactivity timeout of 0.001 seconds for a GET request. The default timeout is five seconds; this example shows how to make it more strict.

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

```

--------------------------------

### Domain routing with subdomains (all://*example.com)

Source: https://www.python-httpx.org/advanced/transports

Proxy all requests to 'example.com' and its subdomains using the wildcard pattern 'all://*example.com'.

```python
mounts = {
    "all://*example.com": httpx.HTTPTransport(proxy="http://localhost:8030"),
}

```

--------------------------------

### Open and close an async client with async with

Source: https://www.python-httpx.org/async

Shows the recommended way to open and close an async client using the context manager. This ensures the client is properly closed and benefits from connection pooling. Avoid instantiating multiple clients inside a hot loop; use a single scoped or global client instead.

```python
async with httpx.AsyncClient() as client:
    ...

```

--------------------------------

### Use httpx.Client as a context manager

Source: https://www.python-httpx.org/advanced/clients

Recommended way to use a Client, ensuring connections are cleaned up when leaving the with block.

```python
with httpx.Client() as client:
    ...

```

--------------------------------

### httpx.Client()

Source: https://www.python-httpx.org/advanced/clients

Describes the Client constructor and how to share configuration across requests.

```APIDOC
## [Client] httpx.Client()

### Description
Creates a client instance that allows sending requests and sharing configuration across all outgoing requests.

### Method
Constructor

### Endpoint
`httpx.Client(headers=None, params=None, auth=None, ...)`

### Parameters
#### Constructor Parameters
- **headers** (dict) - Optional - Headers to apply to every request.
- **params** (dict) - Optional - Query parameters to apply to every request.
- **auth** (tuple) - Optional - Authentication credentials to apply to every request.

### Request Example
```
with httpx.Client(headers={'user-agent': 'my-app/0.0.1'}) as client:
    r = client.get('http://httpbin.org/headers')
```

### Response
#### Success Response
- **client** (Client) - The client instance.

#### Response Example
```
<httpx.Client>
```
```

--------------------------------

### Basic GET request with HTTPX

Source: https://www.python-httpx.org/

Shows a basic GET request with HTTPX, including the response object, status code, headers, and text.

```python
>>> import httpx
>>> r = httpx.get('https://www.example.org/')
>>> r
<Response [200 OK]>
>>> r.status_code
200
>>> r.headers['content-type']
'text/html; charset=UTF-8'
>>> r.text
'<!doctype html>\n<html>\n<head>\n<title>Example Domain</title>...'

```

--------------------------------

### AsyncClient.get

Source: https://www.python-httpx.org/api

Sends a GET request using the async client.

```APIDOC
## AsyncClient.get

### Description
Send a `GET` request using the async client.

### Method
GET

### Endpoint
`AsyncClient.get(url, *, params=None, headers=None, cookies=None, auth=..., follow_redirects=..., timeout=..., extensions=None)`

### Parameters
- **url** (str) - Required - The request URL.
- **params** (optional) - Query parameters to include in the request.
- **headers** (optional) - HTTP headers to send.
- **cookies** (optional) - Cookies to include.
- **auth** (optional) - Authentication credentials.
- **follow_redirects** (optional) - Whether to follow redirects.
- **timeout** (optional) - Timeout configuration.
- **extensions** (optional) - Request extensions.

### Response
Returns an `httpx.Response` object.

### Example
```python
import httpx

async with httpx.AsyncClient() as client:
    response = await client.get('https://example.com')
```
```

--------------------------------

### Domain routing for example.com

Source: https://www.python-httpx.org/advanced/transports

Proxy all requests on domain 'example.com' through the specified transport; other requests pass through.

```python
mounts = {
    "all://example.com": httpx.HTTPTransport(proxy="http://localhost:8030"),
}

```

--------------------------------

### httpx.get

Source: https://www.python-httpx.org/api

Sends a GET request using the httpx library.

```APIDOC
## httpx.get

### Description
Sends a `GET` request.

### Method
GET

### Endpoint
`httpx.get(url, *, params=None, headers=None, cookies=None, auth=None, proxy=None, follow_redirects=False, verify=True, timeout=Timeout(timeout=5.0), trust_env=True)`

### Parameters
- **url** (str) - Required - The URL to send the request to.
- **params** (optional) - Optional - Query parameters to include in the request.
- **headers** (optional) - Optional - HTTP headers to include.
- **cookies** (optional) - Optional - Cookies to include.
- **auth** (optional) - Optional - Authentication credentials.
- **proxy** (optional) - Optional - Proxy configuration.
- **follow_redirects** (bool) - Optional - Whether to follow redirects. Defaults to `False`.
- **verify** (bool) - Optional - Whether to verify SSL certificates. Defaults to `True`.
- **timeout** (Timeout) - Optional - Timeout configuration. Defaults to `Timeout(timeout=5.0)`.
- **trust_env** (bool) - Optional - Whether to trust environment variables. Defaults to `True`.

### Notes
- The `data`, `files`, `json`, and `content` parameters are not available on this function, as `GET` requests should not include a request body.
- See `httpx.request` for full parameter details.
```

--------------------------------

### Make an async GET request with httpx.AsyncClient

Source: https://www.python-httpx.org/async

Shows how to make an asynchronous GET request using the AsyncClient context manager. The response is awaited and the client is automatically closed when the block exits. Use IPython or Python 3.9+ with `python -m asyncio` to run this interactively.

```python
>>> async with httpx.AsyncClient() as client:
...     r = await client.get('https://www.example.com/')
...
>>> r
<Response [200 OK]>

```

--------------------------------

### client.post()

Source: https://www.python-httpx.org/advanced/clients

Demonstrates how to use the client's post method to send requests, accepting the same arguments as `httpx.post()`.

```APIDOC
## [POST] client.post()

### Description
Sends a POST request using the client. Accepts the same arguments as `httpx.post()`.

### Method
POST

### Endpoint
`client.post(url, ...)`

### Parameters
#### Path Parameters
- **url** (string) - Required - The URL to send the request to.

#### Query Parameters
- **params** (dict) - Optional - Query parameters to include in the request. These are merged with client-level params.

#### Request Body
- **headers** (dict) - Optional - Headers to include in the request. These are merged with client-level headers.
- **auth** (tuple) - Optional - Authentication credentials. Overrides client-level auth.

### Request Example
```
client.post('https://example.com', headers={'X-Custom': 'value'})
```

### Response
#### Success Response (200)
- **response** (Response) - The response object.

#### Response Example
```
<Response [200 OK]>
```
```

--------------------------------

### Instantiate AsyncClient with HTTP/2 enabled

Source: https://www.python-httpx.org/http2

Create an httpx.AsyncClient with http2=True to enable HTTP/2 support. This is useful for highly concurrent requests, though HTTP/1.1 remains the default for robustness.

```python
client = httpx.AsyncClient(http2=True)
...
```

--------------------------------

### Configure a SOCKS5 proxy

Source: https://www.python-httpx.org/advanced/proxies

Configures a client to use a SOCKS5 proxy with credentials. Requires the optional socks extra to be installed.

```python
httpx.Client(proxy='socks5://user:pass@host:port')

```

--------------------------------

### Domain routing for strict subdomains (all://*.example.com)

Source: https://www.python-httpx.org/advanced/transports

Proxy all requests to strict subdomains of 'example.com' using 'all://*.example.com'; 'example.com' itself and other requests pass through.

```python
mounts = {
    "all://*.example.com": httpx.HTTPTransport(proxy="http://localhost:8030"),
}

```

--------------------------------

### Mock requests to a domain with mounts

Source: https://www.python-httpx.org/advanced/transports

Mock requests to a given domain by mounting a MockTransport on the 'all://example.org' pattern. Other requests are unaffected.

```python
# All requests to "example.org" should be mocked out.
# Other requests occur as usual.
def handler(request):
    return httpx.Response(200, json={"text": "Hello, World!"})

mounts = {"all://example.org": httpx.MockTransport(handler)}
client = httpx.Client(mounts=mounts)

```

--------------------------------

### Enable redirect following on an httpx.Client

Source: https://www.python-httpx.org/compatibility

Instantiate an httpx.Client with follow_redirects=True to enable automatic redirect following for all requests made by that client.

```python
client = httpx.Client(follow_redirects=True)

```

--------------------------------

### Get header value with r.headers['Content-Type'] and .get()

Source: https://www.python-httpx.org/quickstart

Retrieve a header value using either bracket indexing or the .get() method. Both are case-insensitive.

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

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

```

--------------------------------

### Dispatch Request instance with Client.send()

Source: https://www.python-httpx.org/advanced/clients

Shows how to send a previously built Request instance using a Client and the .send() method.

```python
with httpx.Client() as client:
    response = client.send(request)
    ...

```

--------------------------------

### Chain raise_for_status() inline

Source: https://www.python-httpx.org/quickstart

Use raise_for_status() inline to chain method calls. The example shows assigning the response and then calling .json() on the result.

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

```

--------------------------------

### Create an httpx.Client

Source: https://www.python-httpx.org/compatibility

The HTTPX equivalent of requests.Session. Use httpx.Client to create a client instance with shared settings.

```python
client = httpx.Client(**kwargs)

```

--------------------------------

### Send binary data with content parameter

Source: https://www.python-httpx.org/quickstart

Use the content parameter to send binary data as bytes. The example posts a bytes object to httpbin.org/post.

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

```

--------------------------------

### Starlette Application for ASGI Transport

Source: https://www.python-httpx.org/advanced/transports

Defines a Starlette application with a single route that returns an HTML response. This app is used with ASGITransport in the following example.

```python
from starlette.applications import Starlette
from starlette.responses import HTMLResponse
from starlette.routing import Route


async def hello(request):
    return HTMLResponse("Hello World!")


app = Starlette(routes=[Route("/", hello)])

```

--------------------------------

### Configure Client with certifi SSL context

Source: https://www.python-httpx.org/advanced/ssl

Configures a Client instance with an SSL context that uses the certifi CA bundle, equivalent to the default verify=True behavior. Use this when you need to pass an SSL context for more complex configurations.

```python
import certifi
import httpx
import ssl

# This SSL context is equivelent to the default `verify=True`.
ctx = ssl.create_default_context(cafile=certifi.where())
client = httpx.Client(verify=ctx)

```

--------------------------------

### Domain routing for HTTP on example.com

Source: https://www.python-httpx.org/advanced/transports

Proxy HTTP requests on domain 'example.com' through the specified transport; HTTPS and other requests pass through.

```python
mounts = {
    "http://example.com": httpx.HTTPTransport(proxy="http://localhost:8030"),
}

```

--------------------------------

### Compare status code with httpx.codes.OK

Source: https://www.python-httpx.org/quickstart

Use the httpx.codes shortcut to compare status codes by their text phrase. The example checks if the status code is OK (200).

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

```

--------------------------------

### No-proxy support with None proxy URL

Source: https://www.python-httpx.org/advanced/transports

Define no-proxy support by passing None as the proxy URL for a specific pattern. Requests to 'example.com' bypass the proxy, while all others use the default proxy.

```python
mounts = {
    # Route requests through a proxy by default...
    "all://": httpx.HTTPTransport(proxy="http://localhost:8031"),
    # Except those for "example.com".
    "all://example.com": None,
}

```

--------------------------------

### Raise exception for non-2xx response with raise_for_status()

Source: https://www.python-httpx.org/quickstart

Call raise_for_status() on a response with a non-2xx status code to raise an HTTPStatusError exception. The example shows a 404 response and the resulting traceback.

```python
>>> 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

```

--------------------------------

### Simplified proxy configuration with httpx.Client

Source: https://www.python-httpx.org/troubleshooting

A simpler way to set the proxy for all requests using a single proxy string.

```python
proxy = "http://myproxy.org"
with httpx.Client(proxy=proxy) as client:
  ...

```

--------------------------------

### Use system certificate stores with truststore

Source: https://www.python-httpx.org/advanced/ssl

Uses the truststore package to create an SSL context that supports system certificate stores. Pass this context to httpx.Client to use system certificates for verification.

```python
import ssl
import truststore
import httpx

# Use system certificate stores.
ctx = truststore.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
client = httpx.Client(verify=ctx)

```

--------------------------------

### Digest authentication with httpx.DigestAuth

Source: https://www.python-httpx.org/quickstart

Provides Digest authentication by instantiating a DigestAuth object with plaintext username and password, then passing it as the auth argument. The example shows a successful 200 OK response.

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

```

--------------------------------

### Make a POST request with httpx.post

Source: https://www.python-httpx.org/quickstart

Shows how to make a POST request with form data.

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

```

--------------------------------

### Modify request headers with build_request()

Source: https://www.python-httpx.org/advanced/clients

Demonstrates using .build_request() to create a Request with client-level headers, then modifying the request headers before sending. The example deletes the X-Api-Key header for a particular request.

```python
headers = {"X-Api-Key": "...", "X-Client-ID": "ABC123"}

with httpx.Client(headers=headers) as client:
    request = client.build_request("GET", "https://api.example.com")

    print(request.headers["X-Client-ID"])  # "ABC123"

    # Don't send the API key for this particular request.
    del request.headers["X-Api-Key"]

    response = client.send(request)
    ...

```
Tokens:
Raw