Noble TLS

You can explicitly manage cookies at the Go layer and control the lifecycle of the session to free up memory and connections. Use session.get_cookies(url) to retrieve cookies and session.add_cookies(url, list_of_dicts) to inject them. Always call await session.close() when finished, or await Session.close_all() to clean up all active sessions.

session = noble_tls.Session(client=Client.CHROME_133)

# Do your work...
res = await session.get("https://example.com")

# Manage cookies in the Go session directly
cookies = await session.get_cookies("https://example.com")
await session.add_cookies("https://example.com", [
    {"name": "sid", "value": "abc", "domain": "example.com", "path": "/"},
])

# Free Go memory and connections when done
await session.close()

# Or nuke everything at once
await Session.close_all()

Because Noble TLS relies on binary dependencies, you must manually include them when freezing your application. Use the --add-binary flag with the correct path and delimiter for your platform.

# Linux - Ubuntu / x86
--add-binary '{path_to_library}/tls_client/dependencies/tls-client-x86.so:tls_client/dependencies'

# Linux Alpine / AMD64
--add-binary '{path_to_library}/tls_client/dependencies/tls-client-amd64.so:tls_client/dependencies'

# MacOS M1 and older
--add-binary '{path_to_library}/tls_client/dependencies/tls-client-x86.dylib:tls_client/dependencies'

# MacOS M2
--add-binary '{path_to_library}/tls_client/dependencies/tls-client-arm64.dylib:tls_client/dependencies'

# Windows
--add-binary '{path_to_library}/tls_client/dependencies/tls-client-64.dll;tls_client/dependencies'

Install the library using the standard Python package manager:

pip install noble-tls

Noble TLS follows a syntax similar to requests. You should call noble_tls.update_if_necessary() to ensure the underlying TLS client libraries are up to date. Use noble_tls.Session with a Client profile to initiate requests.

import asyncio
import noble_tls
from noble_tls import Client

async def main():
    await noble_tls.update_if_necessary()
    session = noble_tls.Session(
        client=Client.CHROME_133,
        random_tls_extension_order=True
    )
    res = await session.get(
        "https://www.example.com/",
        headers={"key1": "value1"},
        proxy="http://user:password@host:port"
    )
    print(res.status_code)
    print(res.used_protocol)
    print(res.text)

    await session.close()

asyncio.run(main())

Noble TLS supports HTTP/3 (QUIC) with protocol racing, which mimics Chrome's behavior by giving HTTP/2 a 300ms head start. You can configure h3_settings, h3_settings_order, h3_pseudo_header_order, and h3_send_grease_frames. To disable HTTP/3 entirely, set disable_http3=True in the Session constructor.

session = noble_tls.Session(
    ja3_string="...",
    protocol_racing=True,
    h3_settings={"QPACK_MAX_TABLE_CAPACITY": 4096},
    h3_settings_order=["QPACK_MAX_TABLE_CAPACITY"],
    h3_pseudo_header_order=":[ :method", ":authority", ":scheme", ":path"],
    h3_send_grease_frames=True,
)

The default_headers parameter in Session accepts a dictionary where values are lists (multi-value format). These headers act as a fallback when no specific headers are provided on a request.

session = noble_tls.Session(
    client=Client.CHROME_133,
    default_headers={"Accept": ["text/html", "application/json"]},
)

Every response object includes a used_protocol attribute which returns a Protocol enum indicating the protocol used for the connection (e.g., Protocol.HTTP_2 or Protocol.HTTP_3).

from noble_tls import Protocol

res = await session.get("https://example.com")
print(res.used_protocol)  # Protocol.HTTP_2

if res.used_protocol == Protocol.HTTP_3:
    print("Running over QUIC")