sendrelay 1.7.0__tar.gz

sendrelay-1.7.0/.gitignore

@@ -0,0 +1,16 @@
+# Python
+.venv/
+__pycache__/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+# Swift
+.build/
+.swiftpm/
+Package.resolved
+# Gradle / Android
+.gradle/
+local.properties
+*.iml
+.idea/

sendrelay-1.7.0/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 1.7.0 — 2026-10-29
+
+- First release, versioned with every other Relay SDK (they move together). Matches the shared SDK conformance suite (packages/sdks/conformance).

sendrelay-1.7.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Relay Delivery
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sendrelay-1.7.0/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.5
+Name: sendrelay
+Version: 1.7.0
+Summary: Official Relay server SDK for Python: quotes, deliveries, webhooks and tracking tokens
+Project-URL: Homepage, https://sendrelay.com.ng
+Project-URL: Documentation, https://docs.sendrelay.com.ng/sdks/python-sdk
+Project-URL: Source, https://github.com/SendRelay/relay-sdk-python
+Author: SendRelay
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api,delivery,dispatch,logistics,relay,sdk
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: httpx<1,>=0.25
+Requires-Dist: typing-extensions>=4.7
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: twine>=5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Relay Python SDK
+
+The official server SDK for [Relay](https://sendrelay.com.ng), the delivery API. Quote and create deliveries, read them back with the rider's live ETA, manage webhooks, and mint tracking tokens for your apps.
+
+```bash
+pip install sendrelay
+```
+
+Python 3.9 or newer. Use `Relay` in regular code and `AsyncRelay` with asyncio. Both have the same methods.
+
+## Quick start
+
+```python
+import os
+from sendrelay import Relay
+
+relay = Relay(api_key=os.environ["RELAY_API_KEY"])  # sk_test_... or sk_live_..., server only
+
+stages = [
+    {
+        "type": "PICKUP",
+        "location": {"latitude": 6.5244, "longitude": 3.3792, "address": "12 Marina Road, Lagos"},
+        "items": [{"name": "Phone case", "estimatedValue": 500000, "estimatedWeight": "LIGHT", "estimatedSize": "BOX"}],
+    },
+    {"type": "DROPOFF", "location": {"latitude": 6.4474, "longitude": 3.4723, "address": "22 Admiralty Way, Lekki"}},
+]
+
+quote = relay.tasks.quote({"taskType": "PACKAGE_DELIVERY", "stages": stages})
+print(quote["total"])  # kobo
+
+created = relay.tasks.create(
+    {"taskType": "PACKAGE_DELIVERY", "stages": stages, "quoteId": quote["quoteId"]},
+    idempotency_key="order-1042",  # retries with the same key never create a second delivery
+)
+
+read = relay.tasks.get(created["task"]["id"])
+if read["liveEta"]:
+    print(f"Arriving at stop {read['liveEta']['stageIndex'] + 1} at {read['liveEta']['arrivesAt']}")
+```
+
+Responses are plain dicts with the API's field names (`liveEta`, `totalFee`, ...). `sendrelay.types` has TypedDicts for them.
+
+## Asyncio
+
+```python
+from sendrelay import AsyncRelay
+
+async with AsyncRelay(api_key=os.environ["RELAY_API_KEY"]) as relay:
+    async for task in relay.tasks.list_all(limit=50):
+        print(task["id"], task["status"])
+```
+
+## Webhooks
+
+```python
+from sendrelay import verify_webhook_signature
+
+result = verify_webhook_signature(raw_body, request.headers["X-Relay-Signature"], os.environ["RELAY_WEBHOOK_SECRET"])
+if not result.valid:
+    return 400
+```
+
+Pass the raw request body exactly as received, not re-serialized JSON.
+
+## Errors and retries
+
+- `ApiError` has `status_code`, `code` and `details` from the API.
+- `NetworkError` means the request never got an answer.
+- `ValidationError` means the SDK rejected the input before sending.
+
+Timeouts, 408, 429 and 5xx responses are retried up to 3 times with exponential backoff. Test-mode quota errors are not retried. Change this with `max_retries=` or `retry=RetryConfig(...)`.
+
+## Tracking in your app
+
+Mint a short-lived token on your server and hand it to your app:
+
+```python
+token = relay.auth.create_websocket_token({"scope": [f"task:{task_id}"]})["token"]
+```
+
+Your app then tracks the task live with one of the UI SDKs.
+
+[Full documentation](https://docs.sendrelay.com.ng/sdks/python-sdk)

sendrelay-1.7.0/README.md

@@ -0,0 +1,83 @@
+# Relay Python SDK
+
+The official server SDK for [Relay](https://sendrelay.com.ng), the delivery API. Quote and create deliveries, read them back with the rider's live ETA, manage webhooks, and mint tracking tokens for your apps.
+
+```bash
+pip install sendrelay
+```
+
+Python 3.9 or newer. Use `Relay` in regular code and `AsyncRelay` with asyncio. Both have the same methods.
+
+## Quick start
+
+```python
+import os
+from sendrelay import Relay
+
+relay = Relay(api_key=os.environ["RELAY_API_KEY"])  # sk_test_... or sk_live_..., server only
+
+stages = [
+    {
+        "type": "PICKUP",
+        "location": {"latitude": 6.5244, "longitude": 3.3792, "address": "12 Marina Road, Lagos"},
+        "items": [{"name": "Phone case", "estimatedValue": 500000, "estimatedWeight": "LIGHT", "estimatedSize": "BOX"}],
+    },
+    {"type": "DROPOFF", "location": {"latitude": 6.4474, "longitude": 3.4723, "address": "22 Admiralty Way, Lekki"}},
+]
+
+quote = relay.tasks.quote({"taskType": "PACKAGE_DELIVERY", "stages": stages})
+print(quote["total"])  # kobo
+
+created = relay.tasks.create(
+    {"taskType": "PACKAGE_DELIVERY", "stages": stages, "quoteId": quote["quoteId"]},
+    idempotency_key="order-1042",  # retries with the same key never create a second delivery
+)
+
+read = relay.tasks.get(created["task"]["id"])
+if read["liveEta"]:
+    print(f"Arriving at stop {read['liveEta']['stageIndex'] + 1} at {read['liveEta']['arrivesAt']}")
+```
+
+Responses are plain dicts with the API's field names (`liveEta`, `totalFee`, ...). `sendrelay.types` has TypedDicts for them.
+
+## Asyncio
+
+```python
+from sendrelay import AsyncRelay
+
+async with AsyncRelay(api_key=os.environ["RELAY_API_KEY"]) as relay:
+    async for task in relay.tasks.list_all(limit=50):
+        print(task["id"], task["status"])
+```
+
+## Webhooks
+
+```python
+from sendrelay import verify_webhook_signature
+
+result = verify_webhook_signature(raw_body, request.headers["X-Relay-Signature"], os.environ["RELAY_WEBHOOK_SECRET"])
+if not result.valid:
+    return 400
+```
+
+Pass the raw request body exactly as received, not re-serialized JSON.
+
+## Errors and retries
+
+- `ApiError` has `status_code`, `code` and `details` from the API.
+- `NetworkError` means the request never got an answer.
+- `ValidationError` means the SDK rejected the input before sending.
+
+Timeouts, 408, 429 and 5xx responses are retried up to 3 times with exponential backoff. Test-mode quota errors are not retried. Change this with `max_retries=` or `retry=RetryConfig(...)`.
+
+## Tracking in your app
+
+Mint a short-lived token on your server and hand it to your app:
+
+```python
+token = relay.auth.create_websocket_token({"scope": [f"task:{task_id}"]})["token"]
+```
+
+Your app then tracks the task live with one of the UI SDKs.
+
+[Full documentation](https://docs.sendrelay.com.ng/sdks/python-sdk)

sendrelay-1.7.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "sendrelay"
+version = "1.7.0"
+description = "Official Relay server SDK for Python: quotes, deliveries, webhooks and tracking tokens"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "SendRelay" }]
+requires-python = ">=3.9"
+dependencies = [
+  "httpx>=0.25,<1",
+  "typing_extensions>=4.7",
+]
+keywords = ["relay", "delivery", "logistics", "dispatch", "sdk", "api"]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Typing :: Typed",
+  "Framework :: AsyncIO",
+]
+
+[project.urls]
+Homepage = "https://sendrelay.com.ng"
+Documentation = "https://docs.sendrelay.com.ng/sdks/python-sdk"
+Source = "https://github.com/SendRelay/relay-sdk-python"
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "pytest-asyncio>=0.23", "ruff>=0.6", "mypy>=1.11", "build>=1.2", "twine>=5"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/sendrelay"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.ruff]
+line-length = 120
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]
+# Keep typing.Dict/Optional: annotations must still evaluate on Python 3.9.
+ignore = ["UP006", "UP007", "UP035", "UP045"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+files = ["src/sendrelay"]

sendrelay-1.7.0/src/sendrelay/__init__.py

@@ -0,0 +1,24 @@
+"""Official Relay server SDK for Python.
+
+Quote and create deliveries, read them back with the rider's live ETA, manage webhooks and mint
+tracking tokens for your apps. Use ``Relay`` in regular code and ``AsyncRelay`` with asyncio.
+"""
+
+from ._client import AsyncRelay, Relay
+from ._errors import ApiError, NetworkError, RelayError, ValidationError
+from ._http import RetryConfig
+from ._version import __version__
+from ._webhooks import WebhookSignatureVerification, verify_webhook_signature
+
+__all__ = [
+    "ApiError",
+    "AsyncRelay",
+    "NetworkError",
+    "Relay",
+    "RelayError",
+    "RetryConfig",
+    "ValidationError",
+    "WebhookSignatureVerification",
+    "__version__",
+    "verify_webhook_signature",
+]

sendrelay-1.7.0/src/sendrelay/_client.py

@@ -0,0 +1,333 @@
+from __future__ import annotations
+
+from typing import Any, AsyncIterator, Dict, Iterator, Mapping, Optional, cast
+
+import httpx
+
+from . import _operations as ops
+from ._errors import ValidationError
+from ._http import DEFAULT_API_VERSION, DEFAULT_BASE_URL, Config, Request, RetryConfig, send, send_async
+from ._webhooks import WebhookSignatureVerification, verify_webhook_signature
+from .types import (
+    CancelTaskResponse,
+    CreateTaskResponse,
+    CreateWebhookResponse,
+    GetTaskResponse,
+    ListTasksResponse,
+    ListWebhooksResponse,
+    PresenceResponse,
+    TaskListItem,
+    TaskQuoteResponse,
+    Webhook,
+    WebSocketToken,
+)
+
+Body = Mapping[str, Any]
+
+
+def _config(
+    api_key: str,
+    base_url: Optional[str],
+    api_version: Optional[str],
+    timeout: float,
+    max_retries: Optional[int],
+    retry: Optional[RetryConfig],
+    auto_idempotency: bool,
+    headers: Optional[Dict[str, str]],
+) -> Config:
+    if not api_key:
+        raise ValidationError("API key is required", "api_key")
+    if not (api_key.startswith("sk_live_") or api_key.startswith("sk_test_")):
+        raise ValidationError("Invalid API key format. Must start with sk_live_ or sk_test_", "api_key")
+    retry = retry or RetryConfig()
+    if max_retries is not None:
+        retry.max_retries = max_retries
+    return Config(
+        api_key=api_key,
+        base_url=base_url or DEFAULT_BASE_URL,
+        api_version=api_version or DEFAULT_API_VERSION,
+        timeout=timeout,
+        retry=retry,
+        auto_idempotency=auto_idempotency,
+        headers=dict(headers or {}),
+    )
+
+
+class _Base:
+    _config: Config
+
+    @property
+    def environment(self) -> str:
+        """``"live"`` for a live key, ``"test"`` for a test key."""
+        return "live" if self._config.api_key.startswith("sk_live_") else "test"
+
+
+# ─── Sync ────────────────────────────────────────────────────────────────────
+
+
+class Tasks:
+    def __init__(self, run: Any) -> None:
+        self._run = run
+
+    def quote(self, body: Body) -> TaskQuoteResponse:
+        """Price a delivery without creating it. Pass the ``quoteId`` to ``create`` to lock the price."""
+        return cast(TaskQuoteResponse, self._run(ops.tasks_quote(body)))
+
+    def create(self, body: Body, *, idempotency_key: Optional[str] = None) -> CreateTaskResponse:
+        """Create a delivery. Pass your own ``idempotency_key`` (for example your order ID) so retries
+        never create a second delivery; otherwise one is generated per call."""
+        return cast(CreateTaskResponse, self._run(ops.tasks_create(body, idempotency_key)))
+
+    def list(self, **query: Any) -> ListTasksResponse:
+        """One page of tasks, newest first by default. Filters: ``limit``, ``order``, ``cursor``."""
+        return cast(ListTasksResponse, self._run(ops.tasks_list(query)))
+
+    def list_all(self, **query: Any) -> Iterator[TaskListItem]:
+        """Every task, following the cursor page by page."""
+        cursor: Optional[str] = None
+        while True:
+            page = self.list(**{**query, **({"cursor": cursor} if cursor else {})})
+            yield from page["data"]
+            cursor = page.get("cursor") if page.get("hasMore") else None
+            if not cursor:
+                return
+
+    def get(self, task_id: str) -> GetTaskResponse:
+        """A task, with your ``rating`` of it and the rider's ``liveEta`` while they are on the way."""
+        return cast(GetTaskResponse, self._run(ops.tasks_get(task_id)))
+
+    def cancel(self, task_id: str, body: Optional[Body] = None) -> CancelTaskResponse:
+        return cast(CancelTaskResponse, self._run(ops.tasks_cancel(task_id, body)))
+
+    def assign(self, task_id: str, body: Body) -> Dict[str, Any]:
+        """Offer a manual (``autoAssign: false``) live task to riders from ``available_riders``."""
+        return cast(Dict[str, Any], self._run(ops.tasks_assign(task_id, body)))
+
+    def available_riders(self, task_id: str, **query: Any) -> Dict[str, Any]:
+        return cast(Dict[str, Any], self._run(ops.tasks_available_riders(task_id, query)))
+
+    def rate(self, task_id: str, body: Body) -> Dict[str, Any]:
+        """Rate the rider of a completed task, once. Check ``get(...)["rating"]`` first."""
+        return cast(Dict[str, Any], self._run(ops.tasks_rate(task_id, body)))
+
+    def dispute(self, task_id: str, body: Body) -> Dict[str, Any]:
+        return cast(Dict[str, Any], self._run(ops.tasks_dispute(task_id, body)))
+
+
+class Webhooks:
+    def __init__(self, run: Any) -> None:
+        self._run = run
+
+    def create(self, body: Body) -> CreateWebhookResponse:
+        """Register an endpoint. Store the returned ``secret``: it is shown only once."""
+        return cast(CreateWebhookResponse, self._run(ops.webhooks_create(body)))
+
+    def list(self) -> ListWebhooksResponse:
+        return cast(ListWebhooksResponse, self._run(ops.webhooks_list()))
+
+    def get(self, webhook_id: str) -> Webhook:
+        return cast(Webhook, self._run(ops.webhooks_get(webhook_id)))
+
+    def update(self, webhook_id: str, body: Body) -> Webhook:
+        return cast(Webhook, self._run(ops.webhooks_update(webhook_id, body)))
+
+    def delete(self, webhook_id: str) -> Webhook:
+        return cast(Webhook, self._run(ops.webhooks_delete(webhook_id)))
+
+    @staticmethod
+    def verify_signature(
+        payload: str | bytes, signature_header: str, secret: str, tolerance: int = 300
+    ) -> WebhookSignatureVerification:
+        """Check a delivery's ``X-Relay-Signature`` header against the raw body."""
+        return verify_webhook_signature(payload, signature_header, secret, tolerance)
+
+
+class Auth:
+    def __init__(self, run: Any) -> None:
+        self._run = run
+
+    def create_websocket_token(self, body: Body) -> WebSocketToken:
+        """A short-lived token for an app to track tasks live. ``scope``: ``["task:<id>", ...]``."""
+        return cast(WebSocketToken, self._run(ops.auth_create_websocket_token(body)))
+
+
+class Presence:
+    def __init__(self, run: Any) -> None:
+        self._run = run
+
+    def get(self, **query: Any) -> PresenceResponse:
+        """Anonymous rider availability around a point: ``latitude``, ``longitude``, ``resolution``."""
+        return cast(PresenceResponse, self._run(ops.presence_get(query)))
+
+
+class Relay(_Base):
+    """The Relay server SDK. Keep your API key on your server.
+
+    Example::
+
+        from sendrelay import Relay
+
+        relay = Relay(api_key=os.environ["RELAY_API_KEY"])
+        quote = relay.tasks.quote({"taskType": "PACKAGE_DELIVERY", "stages": [...]})
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: Optional[str] = None,
+        api_version: Optional[str] = None,
+        timeout: float = 30.0,
+        max_retries: Optional[int] = None,
+        retry: Optional[RetryConfig] = None,
+        auto_idempotency: bool = True,
+        headers: Optional[Dict[str, str]] = None,
+        http_client: Optional[httpx.Client] = None,
+    ) -> None:
+        self._config = _config(api_key, base_url, api_version, timeout, max_retries, retry, auto_idempotency, headers)
+        self._owns_client = http_client is None
+        self._http = http_client or httpx.Client(timeout=timeout)
+        self.tasks = Tasks(self._request)
+        self.webhooks = Webhooks(self._request)
+        self.auth = Auth(self._request)
+        self.presence = Presence(self._request)
+
+    def _request(self, request: Request) -> Any:
+        return send(self._config, self._http, request)
+
+    def close(self) -> None:
+        if self._owns_client:
+            self._http.close()
+
+    def __enter__(self) -> Relay:
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+
+# ─── Async ───────────────────────────────────────────────────────────────────
+
+
+class AsyncTasks:
+    def __init__(self, run: Any) -> None:
+        self._run = run
+
+    async def quote(self, body: Body) -> TaskQuoteResponse:
+        return cast(TaskQuoteResponse, await self._run(ops.tasks_quote(body)))
+
+    async def create(self, body: Body, *, idempotency_key: Optional[str] = None) -> CreateTaskResponse:
+        return cast(CreateTaskResponse, await self._run(ops.tasks_create(body, idempotency_key)))
+
+    async def list(self, **query: Any) -> ListTasksResponse:
+        return cast(ListTasksResponse, await self._run(ops.tasks_list(query)))
+
+    async def list_all(self, **query: Any) -> AsyncIterator[TaskListItem]:
+        cursor: Optional[str] = None
+        while True:
+            page = await self.list(**{**query, **({"cursor": cursor} if cursor else {})})
+            for item in page["data"]:
+                yield item
+            cursor = page.get("cursor") if page.get("hasMore") else None
+            if not cursor:
+                return
+
+    async def get(self, task_id: str) -> GetTaskResponse:
+        return cast(GetTaskResponse, await self._run(ops.tasks_get(task_id)))
+
+    async def cancel(self, task_id: str, body: Optional[Body] = None) -> CancelTaskResponse:
+        return cast(CancelTaskResponse, await self._run(ops.tasks_cancel(task_id, body)))
+
+    async def assign(self, task_id: str, body: Body) -> Dict[str, Any]:
+        return cast(Dict[str, Any], await self._run(ops.tasks_assign(task_id, body)))
+
+    async def available_riders(self, task_id: str, **query: Any) -> Dict[str, Any]:
+        return cast(Dict[str, Any], await self._run(ops.tasks_available_riders(task_id, query)))
+
+    async def rate(self, task_id: str, body: Body) -> Dict[str, Any]:
+        return cast(Dict[str, Any], await self._run(ops.tasks_rate(task_id, body)))
+
+    async def dispute(self, task_id: str, body: Body) -> Dict[str, Any]:
+        return cast(Dict[str, Any], await self._run(ops.tasks_dispute(task_id, body)))
+
+
+class AsyncWebhooks:
+    def __init__(self, run: Any) -> None:
+        self._run = run
+
+    async def create(self, body: Body) -> CreateWebhookResponse:
+        return cast(CreateWebhookResponse, await self._run(ops.webhooks_create(body)))
+
+    async def list(self) -> ListWebhooksResponse:
+        return cast(ListWebhooksResponse, await self._run(ops.webhooks_list()))
+
+    async def get(self, webhook_id: str) -> Webhook:
+        return cast(Webhook, await self._run(ops.webhooks_get(webhook_id)))
+
+    async def update(self, webhook_id: str, body: Body) -> Webhook:
+        return cast(Webhook, await self._run(ops.webhooks_update(webhook_id, body)))
+
+    async def delete(self, webhook_id: str) -> Webhook:
+        return cast(Webhook, await self._run(ops.webhooks_delete(webhook_id)))
+
+    verify_signature = staticmethod(Webhooks.verify_signature)
+
+
+class AsyncAuth:
+    def __init__(self, run: Any) -> None:
+        self._run = run
+
+    async def create_websocket_token(self, body: Body) -> WebSocketToken:
+        return cast(WebSocketToken, await self._run(ops.auth_create_websocket_token(body)))
+
+
+class AsyncPresence:
+    def __init__(self, run: Any) -> None:
+        self._run = run
+
+    async def get(self, **query: Any) -> PresenceResponse:
+        return cast(PresenceResponse, await self._run(ops.presence_get(query)))
+
+
+class AsyncRelay(_Base):
+    """The Relay server SDK for asyncio. Same methods as ``Relay``, awaited.
+
+    Example::
+
+        async with AsyncRelay(api_key=os.environ["RELAY_API_KEY"]) as relay:
+            task = await relay.tasks.get(task_id)
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: Optional[str] = None,
+        api_version: Optional[str] = None,
+        timeout: float = 30.0,
+        max_retries: Optional[int] = None,
+        retry: Optional[RetryConfig] = None,
+        auto_idempotency: bool = True,
+        headers: Optional[Dict[str, str]] = None,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> None:
+        self._config = _config(api_key, base_url, api_version, timeout, max_retries, retry, auto_idempotency, headers)
+        self._owns_client = http_client is None
+        self._http = http_client or httpx.AsyncClient(timeout=timeout)
+        self.tasks = AsyncTasks(self._request)
+        self.webhooks = AsyncWebhooks(self._request)
+        self.auth = AsyncAuth(self._request)
+        self.presence = AsyncPresence(self._request)
+
+    async def _request(self, request: Request) -> Any:
+        return await send_async(self._config, self._http, request)
+
+    async def close(self) -> None:
+        if self._owns_client:
+            await self._http.aclose()
+
+    async def __aenter__(self) -> AsyncRelay:
+        return self
+
+    async def __aexit__(self, *_: object) -> None:
+        await self.close()