capturekitdev 0.1.0__tar.gz

capturekitdev-0.1.0/.gitignore

@@ -0,0 +1,14 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+build/
+dist/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+.env
+.DS_Store

capturekitdev-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CaptureKit
+
+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.

capturekitdev-0.1.0/PKG-INFO

@@ -0,0 +1,215 @@
+Metadata-Version: 2.5
+Name: capturekitdev
+Version: 0.1.0
+Summary: Official Python SDK for the CaptureKit screenshot API.
+Project-URL: Homepage, https://www.capturekit.dev
+Project-URL: Documentation, https://app.capturekit.dev/openapi
+Project-URL: Repository, https://github.com/capturekitdev/capturekit-python
+Project-URL: Issues, https://github.com/capturekitdev/capturekit-python/issues
+Author-email: CaptureKit <contact@capturekit.dev>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api,capturekit,screenshot-api,sdk,url-to-pdf,web-content,website-screenshot
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: httpx<1,>=0.27
+Provides-Extra: dev
+Requires-Dist: build<2,>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.13; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.3; extra == 'dev'
+Requires-Dist: ruff<1,>=0.8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# CaptureKit Python SDK
+
+The official Python SDK for the [CaptureKit](https://www.capturekit.dev) screenshot API.
+
+Capture websites as PNG, JPEG, WebP or PDF, extract their content, or analyse them with AI.
+
+The SDK exposes **7 typed methods**, one per documented endpoint, with blocking and `asyncio` clients built on [HTTPX](https://www.python-httpx.org/), plus a generic `request()`.
+
+## Requirements
+
+- Python 3.11 or newer
+
+## Installation
+
+```sh
+pip install capturekitdev
+```
+
+## Get your API key
+
+[Sign up for CaptureKit](https://app.capturekit.dev/register) or sign in, then copy your API key from the [dashboard](https://app.capturekit.dev). The client reads the `CAPTUREKIT_API_KEY` environment variable when no key is passed.
+
+## Quick start
+
+```python
+import os
+
+from capturekit import CaptureKitClient
+
+with CaptureKitClient(os.environ["CAPTUREKIT_API_KEY"]) as client:
+    response = client.content(url="https://example.com")
+    print(response.data)
+```
+
+Keyword arguments mirror the [API reference](https://app.capturekit.dev/openapi). Python keywords get a trailing underscore (`from_=`), and the wire name is used on the request.
+
+## Binary responses
+
+Endpoints that can return a file (image, PDF…) return a `JsonResponse` or a `BinaryResponse`:
+
+```python
+from capturekit import BinaryResponse
+
+response = client.capture(url="https://example.com", format="png")
+if isinstance(response, BinaryResponse):
+    with open("screenshot.png", "wb") as file:
+        file.write(response.bytes)
+```
+
+## Async jobs
+
+Any call accepts `is_async: true` (useful past the 60-second server limit): the response is then a `job_id`. `wait_for_job()` polls `GET /v1/jobs/{id}` until the job reaches a terminal status (`CompletedJob`, `Error`, `NotFound`, `BadRequest`):
+
+```python
+submitted = client.content(url="https://example.com", is_async=True)
+job = client.wait_for_job(
+    submitted.data["job_id"],
+    on_progress=lambda j: print(j["status"], j.get("progress")),
+)
+print(job.data)
+```
+
+## Async I/O
+
+```python
+import asyncio
+
+from capturekit import AsyncCaptureKitClient
+
+
+async def main() -> None:
+    async with AsyncCaptureKitClient() as client:
+        response = await client.content(url="https://example.com")
+        print(response.data)
+
+
+asyncio.run(main())
+```
+
+## GET or POST
+
+Methods use GET when the endpoint supports it (parameters in the query string). POST sends the same parameters as a JSON body:
+
+```python
+from capturekit import RequestOptions
+
+client.analyze(url="test", request_options=RequestOptions(method="POST"))
+```
+
+`None` values are omitted, `False` and `0` are sent, and sequences repeat the parameter name.
+
+## Any endpoint
+
+```python
+response = client.request("GET", "/v1/usage")
+```
+
+## Errors
+
+```python
+from capturekit import CaptureKitAPIError
+
+try:
+    client.content(url="https://example.com")
+except CaptureKitAPIError as error:
+    print(error.status, error, error.response_body)
+```
+
+| Error | When |
+| --- | --- |
+| `CaptureKitConfigurationError` | Missing API key, invalid options, unsupported method, closed client. |
+| `CaptureKitSerializationError` | A required parameter is missing or a value can't be sent. |
+| `CaptureKitTransportError` | Network failure or timeout. |
+| `CaptureKitAPIError` | Non-2xx status (`status`, `error_message`, `response_body`, `raw_response`). |
+| `CaptureKitResponseDecodingError` | A success response could not be decoded. |
+
+All of them extend `CaptureKitError`.
+
+## Retries
+
+Requests are retried up to 3 times after a network error, a `408`, `500`, `502`, `503` or `504`, or a rate limit — which the API returns as `401` (or `429`) with a `Rate limit exceeded` message. Per-key quota errors (`…: quota daily`) are not retried, nor are `400`, `402`, `404` or client-side timeouts. The delay starts at 1 second and grows 1.5× per retry (capped at 30 seconds); a `Retry-After` header wins.
+
+```python
+client = CaptureKitClient(max_retries=5, retry_delay=0.5)
+
+# or for one request
+client.content(url="https://example.com", request_options=RequestOptions(max_retries=0))
+```
+
+## Batch requests
+
+`batch()` runs a function per item on 10 threads (`concurrency`) and returns one `BatchResult` per item, in input order. A failing item never stops the others. `AsyncCaptureKitClient.batch()` does the same with `asyncio`.
+
+```python
+inputs = ["https://example.com", "https://www.capturekit.dev", "https://github.com"]
+results = client.batch(inputs, lambda url: client.content(url=url), concurrency=5)
+
+for result in results:
+    if result.ok:
+        print(result.value.data)
+    else:
+        print(inputs[result.index], result.error)
+```
+
+| Constant | Default | Description |
+| --- | --- | --- |
+| `DEFAULT_CONCURRENCY` | `10` | Tasks run at the same time by batch |
+| `DEFAULT_TIMEOUT` | `120.0` | Request timeout (seconds) |
+| `MAX_RETRIES` | `3` | Retry attempts after a network error, a 408/5xx or a rate limit |
+| `RETRY_BACKOFF_FACTOR` | `1.5` | Exponential backoff multiplier |
+| `DEFAULT_RETRY_DELAY` | `1.0` | Delay before the first retry (seconds) |
+
+## Timeouts and custom HTTPX clients
+
+```python
+import httpx
+
+from capturekit import CaptureKitClient, RequestOptions
+
+client = CaptureKitClient(timeout=60)  # seconds, default 120, None disables
+client.content(url="https://example.com", request_options=RequestOptions(timeout=30))
+
+# Bring your own HTTPX client (proxies, limits, event hooks…). You keep ownership of it.
+http_client = httpx.Client(proxy="http://localhost:8080")
+client = CaptureKitClient(http_client=http_client)
+```
+
+## Endpoints
+
+7 methods, generated from the [OpenAPI document](https://app.capturekit.dev/openapi).
+
+| Method | HTTP | Description |
+| --- | --- | --- |
+| `analyze()` | GET / POST `/v1/analyze` | AI Content API analyzes any webpage and returns AI insights summary, value proposition, features, categories, use cases, and optional conta… |
+| `capture()` | GET / POST `/v1/capture` | Browser-like Screenshot API that captures webpages as PNG/JPEG/WebP or PDF for previews, QA, reporting, monitoring, and archiving no headle… |
+| `content()` | GET / POST `/v1/content` | CaptureKit Content API extracts structured webpage data, metadata, links, HTML/Markdown: in one request for SEO, monitoring, indexing and a… |
+| `jobs()` | GET `/v1/jobs/{id}` | Poll the status, progress (0–100) and result of a job started with is_async=true. Polling is free. Poll until status is terminal: Completed… |
+| `stats()` | GET `/v1/stats` | Infrastructure health for an engine or endpoint over the last hour. Not scoped to your account or tenant. Enabled per account: HTTP 403 mea… |
+| `usage()` | GET `/v1/usage` | Retrieve real-time usage statistics and credit balance for your CaptureKit account. |
+| `website_crawler()` | GET / POST `/v1/website/crawler` | Website Crawler API fetches raw HTML from any webpage in request mode (no rendering) for fast scraping, audits, monitoring, and link/metada… |
+
+## License
+
+MIT — see [LICENSE](LICENSE).

capturekitdev-0.1.0/README.md

@@ -0,0 +1,184 @@
+# CaptureKit Python SDK
+
+The official Python SDK for the [CaptureKit](https://www.capturekit.dev) screenshot API.
+
+Capture websites as PNG, JPEG, WebP or PDF, extract their content, or analyse them with AI.
+
+The SDK exposes **7 typed methods**, one per documented endpoint, with blocking and `asyncio` clients built on [HTTPX](https://www.python-httpx.org/), plus a generic `request()`.
+
+## Requirements
+
+- Python 3.11 or newer
+
+## Installation
+
+```sh
+pip install capturekitdev
+```
+
+## Get your API key
+
+[Sign up for CaptureKit](https://app.capturekit.dev/register) or sign in, then copy your API key from the [dashboard](https://app.capturekit.dev). The client reads the `CAPTUREKIT_API_KEY` environment variable when no key is passed.
+
+## Quick start
+
+```python
+import os
+
+from capturekit import CaptureKitClient
+
+with CaptureKitClient(os.environ["CAPTUREKIT_API_KEY"]) as client:
+    response = client.content(url="https://example.com")
+    print(response.data)
+```
+
+Keyword arguments mirror the [API reference](https://app.capturekit.dev/openapi). Python keywords get a trailing underscore (`from_=`), and the wire name is used on the request.
+
+## Binary responses
+
+Endpoints that can return a file (image, PDF…) return a `JsonResponse` or a `BinaryResponse`:
+
+```python
+from capturekit import BinaryResponse
+
+response = client.capture(url="https://example.com", format="png")
+if isinstance(response, BinaryResponse):
+    with open("screenshot.png", "wb") as file:
+        file.write(response.bytes)
+```
+
+## Async jobs
+
+Any call accepts `is_async: true` (useful past the 60-second server limit): the response is then a `job_id`. `wait_for_job()` polls `GET /v1/jobs/{id}` until the job reaches a terminal status (`CompletedJob`, `Error`, `NotFound`, `BadRequest`):
+
+```python
+submitted = client.content(url="https://example.com", is_async=True)
+job = client.wait_for_job(
+    submitted.data["job_id"],
+    on_progress=lambda j: print(j["status"], j.get("progress")),
+)
+print(job.data)
+```
+
+## Async I/O
+
+```python
+import asyncio
+
+from capturekit import AsyncCaptureKitClient
+
+
+async def main() -> None:
+    async with AsyncCaptureKitClient() as client:
+        response = await client.content(url="https://example.com")
+        print(response.data)
+
+
+asyncio.run(main())
+```
+
+## GET or POST
+
+Methods use GET when the endpoint supports it (parameters in the query string). POST sends the same parameters as a JSON body:
+
+```python
+from capturekit import RequestOptions
+
+client.analyze(url="test", request_options=RequestOptions(method="POST"))
+```
+
+`None` values are omitted, `False` and `0` are sent, and sequences repeat the parameter name.
+
+## Any endpoint
+
+```python
+response = client.request("GET", "/v1/usage")
+```
+
+## Errors
+
+```python
+from capturekit import CaptureKitAPIError
+
+try:
+    client.content(url="https://example.com")
+except CaptureKitAPIError as error:
+    print(error.status, error, error.response_body)
+```
+
+| Error | When |
+| --- | --- |
+| `CaptureKitConfigurationError` | Missing API key, invalid options, unsupported method, closed client. |
+| `CaptureKitSerializationError` | A required parameter is missing or a value can't be sent. |
+| `CaptureKitTransportError` | Network failure or timeout. |
+| `CaptureKitAPIError` | Non-2xx status (`status`, `error_message`, `response_body`, `raw_response`). |
+| `CaptureKitResponseDecodingError` | A success response could not be decoded. |
+
+All of them extend `CaptureKitError`.
+
+## Retries
+
+Requests are retried up to 3 times after a network error, a `408`, `500`, `502`, `503` or `504`, or a rate limit — which the API returns as `401` (or `429`) with a `Rate limit exceeded` message. Per-key quota errors (`…: quota daily`) are not retried, nor are `400`, `402`, `404` or client-side timeouts. The delay starts at 1 second and grows 1.5× per retry (capped at 30 seconds); a `Retry-After` header wins.
+
+```python
+client = CaptureKitClient(max_retries=5, retry_delay=0.5)
+
+# or for one request
+client.content(url="https://example.com", request_options=RequestOptions(max_retries=0))
+```
+
+## Batch requests
+
+`batch()` runs a function per item on 10 threads (`concurrency`) and returns one `BatchResult` per item, in input order. A failing item never stops the others. `AsyncCaptureKitClient.batch()` does the same with `asyncio`.
+
+```python
+inputs = ["https://example.com", "https://www.capturekit.dev", "https://github.com"]
+results = client.batch(inputs, lambda url: client.content(url=url), concurrency=5)
+
+for result in results:
+    if result.ok:
+        print(result.value.data)
+    else:
+        print(inputs[result.index], result.error)
+```
+
+| Constant | Default | Description |
+| --- | --- | --- |
+| `DEFAULT_CONCURRENCY` | `10` | Tasks run at the same time by batch |
+| `DEFAULT_TIMEOUT` | `120.0` | Request timeout (seconds) |
+| `MAX_RETRIES` | `3` | Retry attempts after a network error, a 408/5xx or a rate limit |
+| `RETRY_BACKOFF_FACTOR` | `1.5` | Exponential backoff multiplier |
+| `DEFAULT_RETRY_DELAY` | `1.0` | Delay before the first retry (seconds) |
+
+## Timeouts and custom HTTPX clients
+
+```python
+import httpx
+
+from capturekit import CaptureKitClient, RequestOptions
+
+client = CaptureKitClient(timeout=60)  # seconds, default 120, None disables
+client.content(url="https://example.com", request_options=RequestOptions(timeout=30))
+
+# Bring your own HTTPX client (proxies, limits, event hooks…). You keep ownership of it.
+http_client = httpx.Client(proxy="http://localhost:8080")
+client = CaptureKitClient(http_client=http_client)
+```
+
+## Endpoints
+
+7 methods, generated from the [OpenAPI document](https://app.capturekit.dev/openapi).
+
+| Method | HTTP | Description |
+| --- | --- | --- |
+| `analyze()` | GET / POST `/v1/analyze` | AI Content API analyzes any webpage and returns AI insights summary, value proposition, features, categories, use cases, and optional conta… |
+| `capture()` | GET / POST `/v1/capture` | Browser-like Screenshot API that captures webpages as PNG/JPEG/WebP or PDF for previews, QA, reporting, monitoring, and archiving no headle… |
+| `content()` | GET / POST `/v1/content` | CaptureKit Content API extracts structured webpage data, metadata, links, HTML/Markdown: in one request for SEO, monitoring, indexing and a… |
+| `jobs()` | GET `/v1/jobs/{id}` | Poll the status, progress (0–100) and result of a job started with is_async=true. Polling is free. Poll until status is terminal: Completed… |
+| `stats()` | GET `/v1/stats` | Infrastructure health for an engine or endpoint over the last hour. Not scoped to your account or tenant. Enabled per account: HTTP 403 mea… |
+| `usage()` | GET `/v1/usage` | Retrieve real-time usage statistics and credit balance for your CaptureKit account. |
+| `website_crawler()` | GET / POST `/v1/website/crawler` | Website Crawler API fetches raw HTML from any webpage in request mode (no rendering) for fast scraping, audits, monitoring, and link/metada… |
+
+## License
+
+MIT — see [LICENSE](LICENSE).

capturekitdev-0.1.0/examples/README.md

@@ -0,0 +1,13 @@
+# Examples
+
+```sh
+pip install capturekitdev
+export CAPTUREKIT_API_KEY="YOUR_API_KEY"
+python examples/json_response.py
+```
+
+- `json_response.py` — call the featured endpoint and print the JSON result.
+- `binary_response.py` — save a binary response to a file.
+- `async_client.py` — use `AsyncCaptureKitClient`.
+- `any_endpoint.py` — call any path with `request()` and handle API errors.
+- `wait_for_job.py` — start an async job and wait for its result.

capturekitdev-0.1.0/examples/any_endpoint.py

@@ -0,0 +1,11 @@
+"""Call any path with request() and handle API errors."""
+
+from capturekit import CaptureKitAPIError, CaptureKitClient, JsonResponse
+
+with CaptureKitClient() as client:  # reads CAPTUREKIT_API_KEY
+    try:
+        response = client.request("GET", "/v1/usage")
+        if isinstance(response, JsonResponse):
+            print(response.data)
+    except CaptureKitAPIError as error:
+        print(f"HTTP {error.status}: {error}")

capturekitdev-0.1.0/examples/async_client.py

@@ -0,0 +1,14 @@
+"""Use the asyncio client."""
+
+import asyncio
+
+from capturekit import AsyncCaptureKitClient
+
+
+async def main() -> None:
+    async with AsyncCaptureKitClient() as client:  # reads CAPTUREKIT_API_KEY
+        response = await client.content(url="https://example.com")
+        print(response.data)
+
+
+asyncio.run(main())

capturekitdev-0.1.0/examples/binary_response.py

@@ -0,0 +1,14 @@
+"""Save a binary response to a file."""
+
+import os
+
+from capturekit import BinaryResponse, CaptureKitClient
+
+with CaptureKitClient(os.environ["CAPTUREKIT_API_KEY"]) as client:
+    response = client.capture(url="https://example.com", format="png")
+    if isinstance(response, BinaryResponse):
+        with open("screenshot.png", "wb") as file:
+            file.write(response.bytes)
+        print(f"Saved screenshot.png ({response.content_type}, {len(response.bytes)} bytes)")
+    else:
+        print(response.data)

capturekitdev-0.1.0/examples/json_response.py

@@ -0,0 +1,10 @@
+"""Call the featured endpoint and print the JSON result."""
+
+import json
+import os
+
+from capturekit import CaptureKitClient
+
+with CaptureKitClient(os.environ["CAPTUREKIT_API_KEY"]) as client:
+    response = client.content(url="https://example.com")
+    print(json.dumps(response.data, indent=2))

capturekitdev-0.1.0/examples/wait_for_job.py

@@ -0,0 +1,11 @@
+"""Start an async job and wait for its result."""
+
+from capturekit import CaptureKitClient
+
+with CaptureKitClient() as client:  # reads CAPTUREKIT_API_KEY
+    submitted = client.content(url="https://example.com", is_async=True)
+    job = client.wait_for_job(
+        submitted.data["job_id"],
+        on_progress=lambda j: print(j["status"], j.get("progress")),
+    )
+    print(job.data)

capturekitdev-0.1.0/pyproject.toml

@@ -0,0 +1,79 @@
+[build-system]
+requires = ["hatchling>=1.26,<2"]
+build-backend = "hatchling.build"
+
+[project]
+name = "capturekitdev"
+version = "0.1.0"
+description = "Official Python SDK for the CaptureKit screenshot API."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+  { name = "CaptureKit", email = "contact@capturekit.dev" },
+]
+keywords = [
+  "screenshot-api",
+  "website-screenshot",
+  "url-to-pdf",
+  "web-content",
+  "api",
+  "sdk",
+  "capturekit",
+]
+classifiers = [
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Internet :: WWW/HTTP",
+  "Typing :: Typed",
+]
+dependencies = [
+  "httpx>=0.27,<1",
+]
+
+[project.optional-dependencies]
+dev = [
+  "build>=1.2,<2",
+  "mypy>=1.13",
+  "pytest>=8.3",
+  "pytest-asyncio>=0.24",
+  "ruff>=0.8,<1",
+]
+
+[project.urls]
+Homepage = "https://www.capturekit.dev"
+Documentation = "https://app.capturekit.dev/openapi"
+Repository = "https://github.com/capturekitdev/capturekit-python"
+Issues = "https://github.com/capturekitdev/capturekit-python/issues"
+
+[tool.hatch.build.targets.sdist]
+include = ["/examples", "/src", "/tests", "/LICENSE", "/README.md", "/pyproject.toml"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/capturekit"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+files = ["src", "tests", "examples"]
+
+[tool.pytest.ini_options]
+addopts = "-ra"
+asyncio_mode = "strict"
+asyncio_default_fixture_loop_scope = "function"
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 100
+src = ["src", "tests", "examples"]
+extend-exclude = ["*.md"]
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "I", "UP", "B"]

capturekitdev-0.1.0/src/capturekit/__init__.py

@@ -0,0 +1,61 @@
+"""Official Python SDK for the CaptureKit API."""
+
+from ._endpoints import ENDPOINTS
+from ._version import __version__
+from .client import (
+    DEFAULT_BASE_URL,
+    DEFAULT_CONCURRENCY,
+    DEFAULT_RETRY_DELAY,
+    DEFAULT_TIMEOUT,
+    MAX_RETRIES,
+    RETRY_BACKOFF_FACTOR,
+    AsyncCaptureKitClient,
+    CaptureKitClient,
+)
+from .errors import (
+    CaptureKitAPIError,
+    CaptureKitConfigurationError,
+    CaptureKitError,
+    CaptureKitJobTimeoutError,
+    CaptureKitResponseDecodingError,
+    CaptureKitSerializationError,
+    CaptureKitTransportError,
+)
+from .models import (
+    APIResponse,
+    BatchResult,
+    BinaryResponse,
+    EndpointDefinition,
+    HTTPMethod,
+    JsonResponse,
+    RawResponse,
+    RequestOptions,
+)
+
+__all__ = [
+    "APIResponse",
+    "AsyncCaptureKitClient",
+    "BatchResult",
+    "BinaryResponse",
+    "DEFAULT_BASE_URL",
+    "DEFAULT_CONCURRENCY",
+    "DEFAULT_RETRY_DELAY",
+    "DEFAULT_TIMEOUT",
+    "MAX_RETRIES",
+    "RETRY_BACKOFF_FACTOR",
+    "ENDPOINTS",
+    "EndpointDefinition",
+    "HTTPMethod",
+    "JsonResponse",
+    "RawResponse",
+    "RequestOptions",
+    "CaptureKitAPIError",
+    "CaptureKitClient",
+    "CaptureKitConfigurationError",
+    "CaptureKitError",
+    "CaptureKitJobTimeoutError",
+    "CaptureKitResponseDecodingError",
+    "CaptureKitSerializationError",
+    "CaptureKitTransportError",
+    "__version__",
+]