@@ -69,7 +69,9 @@ Contents
 
     * `Setting the request timeout`_
 
-    * `Configuring the niquests session`_
+    * `Configuring retries`_
+
+    * `Configuring the httpx client`_
 
 * `Development and Testing`_
 
@@ -464,20 +466,45 @@ Pass the ``timeout`` option, in seconds, to override this:
 
 Setting it to ``None`` disables the timeout entirely.
 
-A request that exceeds the timeout raises ``niquests.exceptions.Timeout``.
+A request that exceeds the timeout raises ``httpx.TimeoutException``.
+
+Configuring retries
+^^^^^^^^^^^^^^^^^^^
+
+Connection errors are retried automatically.
+Pass the ``retries`` option to customize retry behavior,
+e.g., to also retry requests answered with specific status codes:
 
-Configuring the niquests session
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+.. code-block:: python
+
+    from seam import Seam, Retry
 
-For control the options above do not cover, pass ``niquests_options``.
-These are handed to the underlying niquests ``Session`` and take
+    seam = Seam(
+        api_key="your-api-key",
+        retries=Retry(
+            total=3,
+            backoff_factor=0.5,
+            status_forcelist=[503],
+            allowed_methods=["POST"],
+        ),
+    )
+
+Configuring the httpx client
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+For control the options above do not cover, pass ``httpx_options``.
+These are handed to the underlying httpx ``Client`` and take
 precedence over the defaults the SDK sets:
 
 .. code-block:: python
 
+    import httpx
+
     seam = Seam(
         api_key="your-api-key",
-        niquests_options={"pool_connections": 20, "pool_maxsize": 25},
+        httpx_options={
+            "limits": httpx.Limits(max_connections=25, max_keepalive_connections=20),
+        },
     )
 
 Development and Testing
 
@@ -13,7 +13,7 @@ include = ["seam/py.typed"]
 [tool.poetry.dependencies]
 python = "^3.10.0"
 dataclasses-json = "^0.6.4"
-niquests = "^3.6.4"
+httpx = "^0.28.1"
 svix = "^1.24.0"
 
 [tool.poetry.group.dev.dependencies]
 
@@ -3,6 +3,7 @@
 
 from .seam import Seam
 from .seam_without_workspace import SeamWithoutWorkspace
+from .retry import Retry
 from .options import SeamInvalidOptionsError
 from .auth import SeamInvalidTokenError
 from .exceptions import (
 
@@ -1,12 +1,11 @@
 from typing import Any, Dict, Optional
-from urllib.parse import urljoin
-import niquests as requests
 from importlib.metadata import version
-from inspect import signature
-from urllib3.util import Retry
 import abc
 
+import httpx
+
 from .constants import DEFAULT_TIMEOUT, LTS_VERSION
+from .retry import Retry, RetryTransport
 from .exceptions import (
     SeamHttpApiError,
     SeamHttpInvalidInputError,
@@ -21,10 +20,6 @@
 
 DEFAULT_RETRIES = Retry()
 
-NIQUESTS_TIMEOUT_DEFAULT = (
-    signature(requests.Session.post).parameters["timeout"].default
-)
-
 
 class AbstractSeamHttpClient(abc.ABC):
     @abc.abstractmethod
@@ -36,55 +31,49 @@ def request(self, method: str, url: str, *args, **kwargs):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def _handle_response(self, response: requests.Response):
+    def _handle_response(self, response: httpx.Response):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def _handle_error_response(self, response: requests.Response):
+    def _handle_error_response(self, response: httpx.Response):
         raise NotImplementedError
 
 
-class SeamHttpClient(requests.Session, AbstractSeamHttpClient):
+class SeamHttpClient(httpx.Client, AbstractSeamHttpClient):
     def __init__(
         self,
         base_url: str,
         auth_headers: Dict[str, str],
         retries: Optional[Retry] = DEFAULT_RETRIES,
         timeout: Optional[float] = DEFAULT_TIMEOUT,
-        niquests_options: Optional[Dict[str, Any]] = None,
+        httpx_options: Optional[Dict[str, Any]] = None,
         **kwargs
     ):
-        # niquests.Session mounts its adapters while initializing, so retries
-        # must be passed through here. Assigning self.retries afterwards leaves
-        # the mounted adapters on their default and the option has no effect.
         options = {
-            "retries": DEFAULT_RETRIES if retries is None else retries,
+            "base_url": base_url,
+            "timeout": timeout,
             **kwargs,
-            **(niquests_options or {}),
+            **(httpx_options or {}),
         }
 
         custom_headers = options.pop("headers", {})
 
-        super().__init__(**options)
-
-        self.base_url = base_url
+        if "transport" not in options:
+            options["transport"] = RetryTransport(
+                DEFAULT_RETRIES if retries is None else retries
+            )
 
-        self.timeout = timeout
+        super().__init__(**options)
 
         headers = {**auth_headers, **custom_headers, **SDK_HEADERS}
         self.headers.update(headers)
 
     def request(self, method, url, *args, **kwargs):
-        url = urljoin(self.base_url, url)
-
-        if kwargs.get("timeout", NIQUESTS_TIMEOUT_DEFAULT) == NIQUESTS_TIMEOUT_DEFAULT:
-            kwargs["timeout"] = self.timeout
-
         response = super().request(method, url, *args, **kwargs)
 
         return self._handle_response(response)
 
-    def _handle_response(self, response: requests.Response):
+    def _handle_response(self, response: httpx.Response):
         if not 200 <= response.status_code < 300:
             self._handle_error_response(response)
 
@@ -93,7 +82,7 @@ def _handle_response(self, response: requests.Response):
 
         return response.text
 
-    def _handle_error_response(self, response: requests.Response):
+    def _handle_error_response(self, response: httpx.Response):
         status_code = response.status_code
         request_id = response.headers.get("seam-request-id")
 
@@ -120,7 +109,7 @@ def _handle_error_response(self, response: requests.Response):
         raise SeamHttpApiError(error_details, status_code, request_id)
 
 
-def is_api_error_response(response: requests.Response) -> bool:
+def is_api_error_response(response: httpx.Response) -> bool:
     try:
         content_type = response.headers.get("content-type", "")
 
@@ -130,7 +119,7 @@ def is_api_error_response(response: requests.Response) -> bool:
             return False
 
         data = response.json()
-    except (ValueError, requests.exceptions.JSONDecodeError):
+    except ValueError:
         return False
 
     if not isinstance(data, dict):
 
@@ -1,6 +1,7 @@
 from typing import Callable, Dict, Any, Tuple, Generator, List
+from json import JSONDecodeError
+from httpx import Response
 from .client import SeamHttpClient
-from niquests import Response, JSONDecodeError
 from .pagination import Pagination
 
 
@@ -34,11 +35,11 @@ def __init__(
 
     def first_page(self) -> Tuple[List[Any], Pagination | None]:
         """Fetches the first page of results."""
-        self.client.hooks["response"].append(
+        self.client.event_hooks["response"].append(
             lambda response: self._cache_pagination(response, self._FIRST_PAGE)
         )
         data = self._request(**self._params)
-        self.client.hooks["response"].pop()
+        self.client.event_hooks["response"].pop()
 
         pagination = self._pagination_cache.get(self._FIRST_PAGE)
 
@@ -56,11 +57,11 @@ def next_page(
             "page_cursor": next_page_cursor,
         }
 
-        self.client.hooks["response"].append(
+        self.client.event_hooks["response"].append(
             lambda response: self._cache_pagination(response, next_page_cursor)
         )
         data = self._request(**params)
-        self.client.hooks["response"].pop()
+        self.client.event_hooks["response"].pop()
 
         pagination = self._pagination_cache.get(next_page_cursor)
 
@@ -95,6 +96,8 @@ def flatten(self) -> Generator[Any, None, None]:
     def _cache_pagination(self, response: Response, page_key: str) -> None:
         """Extracts pagination dict from response, creates Pagination object, and caches it."""
         try:
+            # httpx response hooks fire before the response body is read.
+            response.read()
             response_json = response.json()
             pagination = response_json.get("pagination", {})
         except JSONDecodeError:
 
@@ -0,0 +1,139 @@
+import time
+from dataclasses import dataclass
+from email.utils import parsedate_to_datetime
+from typing import FrozenSet, Optional
+
+import httpx
+
+# Methods safe to retry by default. The Seam API is POST-only, so pass
+# allowed_methods=["POST"] to opt in to retrying API requests on status.
+DEFAULT_ALLOWED_METHODS = frozenset(
+    ["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"]
+)
+
+# Statuses retried when the response includes a Retry-After header,
+# even if they are not in the status_forcelist.
+RETRY_AFTER_STATUS_CODES = frozenset([413, 429, 503])
+
+# Never sleep longer than this between attempts, in seconds.
+BACKOFF_MAX = 120
+
+
+@dataclass(frozen=True)
+class Retry:
+    """Retry behavior for failed requests.
+
+    The fields mirror urllib3.util.Retry, which previous SDK versions
+    accepted for the retries option.
+
+    :ivar total: Number of retries allowed after the initial request.
+        Set to 0 to disable retries.
+    :ivar backoff_factor: Sleep backoff_factor * (2 ** retry_number)
+        seconds between attempts, where retry_number starts at 0.
+    :ivar status_forcelist: Response status codes to retry.
+    :ivar allowed_methods: HTTP methods eligible for retry on status.
+        Connection errors are always eligible, as the request never
+        reached the server. Pass None to allow all methods.
+    :ivar respect_retry_after_header: Honor the Retry-After header on
+        413, 429, and 503 responses.
+    """
+
+    total: int = 10
+    backoff_factor: float = 0
+    status_forcelist: Optional[FrozenSet[int]] = None
+    allowed_methods: Optional[FrozenSet[str]] = DEFAULT_ALLOWED_METHODS
+    respect_retry_after_header: bool = True
+
+    def __post_init__(self):
+        if self.status_forcelist is not None:
+            object.__setattr__(
+                self, "status_forcelist", frozenset(self.status_forcelist)
+            )
+        if self.allowed_methods is not None:
+            object.__setattr__(
+                self,
+                "allowed_methods",
+                frozenset(method.upper() for method in self.allowed_methods),
+            )
+
+    def is_retryable_response(self, method: str, response: httpx.Response) -> bool:
+        if (
+            self.allowed_methods is not None
+            and method.upper() not in self.allowed_methods
+        ):
+            return False
+
+        if (
+            self.status_forcelist is not None
+            and response.status_code in self.status_forcelist
+        ):
+            return True
+
+        return (
+            self.respect_retry_after_header
+            and "retry-after" in response.headers
+            and response.status_code in RETRY_AFTER_STATUS_CODES
+        )
+
+    def get_backoff_time(self, retry_number: int) -> float:
+        return min(BACKOFF_MAX, self.backoff_factor * (2**retry_number))
+
+
+class RetryTransport(httpx.BaseTransport):
+    """Transport that retries requests according to a Retry configuration."""
+
+    def __init__(self, retries: Retry, transport: Optional[httpx.BaseTransport] = None):
+        self.retries = retries
+        self.transport = transport if transport is not None else httpx.HTTPTransport()
+
+    def handle_request(self, request: httpx.Request) -> httpx.Response:
+        retries_left = self.retries.total
+        retry_number = 0
+
+        while True:
+            try:
+                response = self.transport.handle_request(request)
+            except (httpx.ConnectError, httpx.ConnectTimeout):
+                if retries_left <= 0:
+                    raise
+                retry_after = None
+            else:
+                if retries_left <= 0 or not self.retries.is_retryable_response(
+                    request.method, response
+                ):
+                    return response
+                retry_after = parse_retry_after(response)
+                response.close()
+
+            self._sleep(retry_number, retry_after)
+            retries_left -= 1
+            retry_number += 1
+
+    def close(self) -> None:
+        self.transport.close()
+
+    def _sleep(self, retry_number: int, retry_after: Optional[float]) -> None:
+        backoff = self.retries.get_backoff_time(retry_number)
+
+        if retry_after is not None and self.retries.respect_retry_after_header:
+            backoff = max(backoff, min(BACKOFF_MAX, retry_after))
+
+        if backoff > 0:
+            time.sleep(backoff)
+
+
+def parse_retry_after(response: httpx.Response) -> Optional[float]:
+    retry_after = response.headers.get("retry-after")
+
+    if retry_after is None:
+        return None
+
+    if retry_after.isdigit():
+        return float(retry_after)
+
+    try:
+        retry_date = parsedate_to_datetime(retry_after)
+    except (TypeError, ValueError):
+        return None
+
+    return max(0.0, retry_date.timestamp() - time.time())