webglean 0.1.0__tar.gz

webglean-0.1.0/.gitignore

@@ -0,0 +1,14 @@
+node_modules
+.next
+dist
+.env
+.env.local
+drizzle/
+.DS_Store
+playwright-report/
+test-results/
+*.tsbuildinfo
+.venv/
+__pycache__/
+*.egg-info/
+.pytest_cache/

webglean-0.1.0/LICENSE

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

webglean-0.1.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: webglean
+Version: 0.1.0
+Summary: Official Python client for the WebGlean API
+Project-URL: Homepage, https://webglean.dev/docs/sdks
+Project-URL: Documentation, https://webglean.dev/docs/sdks
+Project-URL: Repository, https://github.com/qubomax/webglean
+Project-URL: Issues, https://github.com/qubomax/webglean/issues
+License: MIT
+License-File: LICENSE
+Keywords: ai-agents,crawler,llm,markdown,rag,scraping,web-scraping,webglean
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# webglean
+
+Official Python client for the [WebGlean](https://webglean.dev) API.
+
+```bash
+pip install webglean
+```
+
+```python
+from webglean import WebGlean
+
+client = WebGlean(api_key="wg_your_key")  # or set WEBGLEAN_API_KEY
+
+result = client.scrape("https://example.com")
+print(result["markdown"])
+```
+
+`WebGlean` also works as a context manager (`with WebGlean(...) as client:`), which closes the underlying HTTP connection pool on exit.
+
+## Methods
+
+| Method | Endpoint |
+|---|---|
+| `scrape(url, ...)` | `POST /v1/scrape` |
+| `crawl(url, ...)` / `get_crawl(id)` / `crawl_and_wait(id, ...)` | `POST /v1/crawl`, `GET /v1/crawl/:id` |
+| `extract(url, schema=, prompt=)` | `POST /v1/extract` |
+| `map(url, ...)` | `POST /v1/map` |
+| `search(query, ...)` | `POST /v1/search` |
+| `create_monitor(url, ...)` / `list_monitors()` / `get_monitor(id)` / `delete_monitor(id)` | `POST/GET/DELETE /v1/monitor` |
+| `batch_scrape(urls=, items=, ...)` / `get_batch(id)` / `batch_scrape_and_wait(id, ...)` | `POST /v1/batch/scrape`, `GET /v1/batch/scrape/:id` |
+
+`crawl_and_wait` and `batch_scrape_and_wait` poll every 2s by default (`poll_interval`, `timeout` in seconds) until the job finishes, raising `WebGleanError` (status `0`) on timeout.
+
+## Errors
+
+Any non-2xx response raises `WebGleanError`, with `.status` and the message set from the API's error body.
+
+## Development
+
+```bash
+python3 -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```

webglean-0.1.0/README.md

@@ -0,0 +1,44 @@
+# webglean
+
+Official Python client for the [WebGlean](https://webglean.dev) API.
+
+```bash
+pip install webglean
+```
+
+```python
+from webglean import WebGlean
+
+client = WebGlean(api_key="wg_your_key")  # or set WEBGLEAN_API_KEY
+
+result = client.scrape("https://example.com")
+print(result["markdown"])
+```
+
+`WebGlean` also works as a context manager (`with WebGlean(...) as client:`), which closes the underlying HTTP connection pool on exit.
+
+## Methods
+
+| Method | Endpoint |
+|---|---|
+| `scrape(url, ...)` | `POST /v1/scrape` |
+| `crawl(url, ...)` / `get_crawl(id)` / `crawl_and_wait(id, ...)` | `POST /v1/crawl`, `GET /v1/crawl/:id` |
+| `extract(url, schema=, prompt=)` | `POST /v1/extract` |
+| `map(url, ...)` | `POST /v1/map` |
+| `search(query, ...)` | `POST /v1/search` |
+| `create_monitor(url, ...)` / `list_monitors()` / `get_monitor(id)` / `delete_monitor(id)` | `POST/GET/DELETE /v1/monitor` |
+| `batch_scrape(urls=, items=, ...)` / `get_batch(id)` / `batch_scrape_and_wait(id, ...)` | `POST /v1/batch/scrape`, `GET /v1/batch/scrape/:id` |
+
+`crawl_and_wait` and `batch_scrape_and_wait` poll every 2s by default (`poll_interval`, `timeout` in seconds) until the job finishes, raising `WebGleanError` (status `0`) on timeout.
+
+## Errors
+
+Any non-2xx response raises `WebGleanError`, with `.status` and the message set from the API's error body.
+
+## Development
+
+```bash
+python3 -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```

webglean-0.1.0/examples/basic_usage.py

@@ -0,0 +1,20 @@
+import os
+
+from webglean import WebGlean
+
+client = WebGlean(
+    api_key=os.environ.get("WEBGLEAN_API_KEY", "wg_your_key"),
+    base_url=os.environ.get("WEBGLEAN_BASE_URL", "https://api.webglean.dev"),
+)
+
+scraped = client.scrape("https://example.com")
+print(scraped["markdown"])
+
+crawl_id = client.crawl("https://example.com", max_pages=5)
+crawl = client.crawl_and_wait(crawl_id)
+print(f"Crawled {crawl['pagesCrawled']} pages")
+
+result = client.map("https://example.com")
+print(f"Found {result['total']} URLs")
+
+client.close()

webglean-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "webglean"
+version = "0.1.0"
+description = "Official Python client for the WebGlean API"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+keywords = ["webglean", "scraping", "web-scraping", "crawler", "markdown", "llm", "rag", "ai-agents"]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+]
+dependencies = [
+    "httpx>=0.27",
+]
+
+[project.urls]
+Homepage = "https://webglean.dev/docs/sdks"
+Documentation = "https://webglean.dev/docs/sdks"
+Repository = "https://github.com/qubomax/webglean"
+Issues = "https://github.com/qubomax/webglean/issues"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "respx>=0.21",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/webglean"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

webglean-0.1.0/src/webglean/__init__.py

@@ -0,0 +1,31 @@
+from .client import WebGlean
+from .errors import WebGleanError
+from .types import (
+    BatchResultItem,
+    BatchStatus,
+    CrawlPage,
+    CrawlStatus,
+    MapResult,
+    Monitor,
+    MonitorChange,
+    MonitorDetail,
+    ScrapeMetadata,
+    ScrapeResult,
+    SearchResultItem,
+)
+
+__all__ = [
+    "WebGlean",
+    "WebGleanError",
+    "ScrapeResult",
+    "ScrapeMetadata",
+    "CrawlStatus",
+    "CrawlPage",
+    "MapResult",
+    "SearchResultItem",
+    "Monitor",
+    "MonitorDetail",
+    "MonitorChange",
+    "BatchStatus",
+    "BatchResultItem",
+]

webglean-0.1.0/src/webglean/_http.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+import httpx
+
+from .errors import WebGleanError
+
+
+class HttpClient:
+    def __init__(self, base_url: str, api_key: str, timeout: float) -> None:
+        self._client = httpx.Client(
+            base_url=base_url,
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=timeout,
+        )
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        json_body: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        res = self._client.request(method, path, json=json_body)
+
+        try:
+            body: Dict[str, Any] = res.json()
+        except ValueError:
+            raise WebGleanError(f"Invalid JSON response (HTTP {res.status_code})", res.status_code)
+
+        if res.status_code >= 400 or body.get("success") is False:
+            raise WebGleanError(
+                body.get("error") or f"Request failed with HTTP {res.status_code}",
+                res.status_code,
+            )
+
+        return body
+
+    def close(self) -> None:
+        self._client.close()

webglean-0.1.0/src/webglean/client.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+import os
+import time
+from typing import Any, Dict, List, Optional
+
+from ._http import HttpClient
+from .errors import WebGleanError
+from .types import (
+    BatchStatus,
+    CrawlStatus,
+    MapResult,
+    Monitor,
+    MonitorDetail,
+    ScrapeResult,
+    SearchResultItem,
+)
+
+DEFAULT_BASE_URL = "https://api.webglean.dev"
+
+
+class WebGlean:
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 120.0,
+    ) -> None:
+        resolved_key = api_key or os.environ.get("WEBGLEAN_API_KEY")
+        if not resolved_key:
+            raise ValueError(
+                "WebGlean: an api_key is required (pass it directly or set WEBGLEAN_API_KEY)"
+            )
+        self._http = HttpClient(base_url, resolved_key, timeout)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> "WebGlean":
+        return self
+
+    def __exit__(self, *exc_info: Any) -> None:
+        self.close()
+
+    # ── Scrape ──────────────────────────────────────────────────────────
+
+    def scrape(
+        self,
+        url: str,
+        format: str = "markdown",
+        only_main_content: bool = True,
+    ) -> ScrapeResult:
+        body = self._http.request(
+            "POST",
+            "/v1/scrape",
+            {"url": url, "formats": [format], "onlyMainContent": only_main_content},
+        )
+        return body["data"]
+
+    # ── Crawl ───────────────────────────────────────────────────────────
+
+    def crawl(
+        self,
+        url: str,
+        max_depth: int = 2,
+        max_pages: int = 10,
+        include_paths: Optional[List[str]] = None,
+        exclude_paths: Optional[List[str]] = None,
+    ) -> str:
+        body = self._http.request(
+            "POST",
+            "/v1/crawl",
+            {
+                "url": url,
+                "maxDepth": max_depth,
+                "maxPages": max_pages,
+                "includePaths": include_paths or [],
+                "excludePaths": exclude_paths or [],
+            },
+        )
+        return body["id"]
+
+    def get_crawl(self, crawl_id: str) -> CrawlStatus:
+        body = self._http.request("GET", f"/v1/crawl/{crawl_id}")
+        return body["data"]
+
+    def crawl_and_wait(
+        self, crawl_id: str, poll_interval: float = 2.0, timeout: float = 600.0
+    ) -> CrawlStatus:
+        return self._poll_until(
+            lambda: self.get_crawl(crawl_id),
+            lambda status: status["status"] in ("done", "failed"),
+            poll_interval,
+            timeout,
+        )
+
+    # ── Extract ─────────────────────────────────────────────────────────
+
+    def extract(
+        self,
+        url: str,
+        schema: Optional[Dict[str, Any]] = None,
+        prompt: Optional[str] = None,
+    ) -> Any:
+        if not schema and not prompt:
+            raise ValueError("WebGlean.extract: provide at least one of schema, prompt")
+        body = self._http.request(
+            "POST", "/v1/extract", {"url": url, "schema": schema, "prompt": prompt}
+        )
+        return body["data"]
+
+    # ── Map ─────────────────────────────────────────────────────────────
+
+    def map(self, url: str, max_urls: int = 100, search: Optional[str] = None) -> MapResult:
+        """Unlike every other endpoint, /v1/map's response is not wrapped in `data`."""
+        body = self._http.request(
+            "POST", "/v1/map", {"url": url, "maxUrls": max_urls, "search": search}
+        )
+        return {"links": body["links"], "total": body["total"]}
+
+    # ── Search ──────────────────────────────────────────────────────────
+
+    def search(
+        self,
+        query: str,
+        num_results: int = 5,
+        country: Optional[str] = None,
+        lang: Optional[str] = None,
+    ) -> List[SearchResultItem]:
+        """A result item can have markdown=None + error set for a page that
+        individually failed to scrape, even though the overall call
+        succeeded — that's returned as-is, not raised."""
+        body = self._http.request(
+            "POST",
+            "/v1/search",
+            {"query": query, "numResults": num_results, "country": country, "lang": lang},
+        )
+        return body["data"]
+
+    # ── Monitor ─────────────────────────────────────────────────────────
+
+    def create_monitor(
+        self, url: str, interval: str = "daily", webhook_url: Optional[str] = None
+    ) -> Monitor:
+        body = self._http.request(
+            "POST",
+            "/v1/monitor",
+            {"url": url, "interval": interval, "webhookUrl": webhook_url},
+        )
+        return body["data"]
+
+    def list_monitors(self) -> List[Monitor]:
+        body = self._http.request("GET", "/v1/monitor")
+        return body["data"]
+
+    def get_monitor(self, monitor_id: str) -> MonitorDetail:
+        body = self._http.request("GET", f"/v1/monitor/{monitor_id}")
+        return body["data"]
+
+    def delete_monitor(self, monitor_id: str) -> None:
+        self._http.request("DELETE", f"/v1/monitor/{monitor_id}")
+
+    # ── Batch scrape ────────────────────────────────────────────────────
+
+    def batch_scrape(
+        self,
+        urls: Optional[List[str]] = None,
+        items: Optional[List[Dict[str, Any]]] = None,
+        format: str = "markdown",
+        only_main_content: bool = True,
+    ) -> str:
+        if not urls and not items:
+            raise ValueError("WebGlean.batch_scrape: provide either urls or items")
+        payload: Dict[str, Any] = {"format": format, "onlyMainContent": only_main_content}
+        if items:
+            payload["items"] = items
+        else:
+            payload["urls"] = urls
+        body = self._http.request("POST", "/v1/batch/scrape", payload)
+        return body["id"]
+
+    def get_batch(self, batch_id: str) -> BatchStatus:
+        body = self._http.request("GET", f"/v1/batch/scrape/{batch_id}")
+        return {
+            "status": body["status"],
+            "total": body["total"],
+            "completed": body["completed"],
+            "failed": body["failed"],
+            "creditsUsed": body["creditsUsed"],
+            "results": body["results"],
+        }
+
+    def batch_scrape_and_wait(
+        self, batch_id: str, poll_interval: float = 2.0, timeout: float = 1200.0
+    ) -> BatchStatus:
+        return self._poll_until(
+            lambda: self.get_batch(batch_id),
+            lambda status: status["status"] == "done",
+            poll_interval,
+            timeout,
+        )
+
+    # ── Internal ────────────────────────────────────────────────────────
+
+    def _poll_until(self, fetch_status, is_done, poll_interval: float, timeout: float):
+        deadline = time.monotonic() + timeout
+        while True:
+            status = fetch_status()
+            if is_done(status):
+                return status
+            if time.monotonic() >= deadline:
+                raise WebGleanError(f"Timed out after {timeout}s waiting for job to finish", 0)
+            time.sleep(poll_interval)

webglean-0.1.0/src/webglean/errors.py

@@ -0,0 +1,10 @@
+class WebGleanError(Exception):
+    """Raised for any non-2xx response from the WebGlean API, and for
+    client-side polling timeouts (status 0)."""
+
+    def __init__(self, message: str, status: int) -> None:
+        super().__init__(message)
+        self.status = status
+
+    def __repr__(self) -> str:
+        return f"WebGleanError(status={self.status!r}, message={str(self)!r})"

webglean-0.1.0/src/webglean/types.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, TypedDict
+
+
+class ScrapeMetadata(TypedDict, total=False):
+    title: Optional[str]
+    description: Optional[str]
+    url: Optional[str]
+    statusCode: Optional[int]
+
+
+class ScrapeResult(TypedDict):
+    markdown: str
+    html: str
+    text: str
+    metadata: ScrapeMetadata
+
+
+class CrawlPage(TypedDict):
+    url: str
+    markdown: str
+    html: str
+    text: str
+    metadata: ScrapeMetadata
+
+
+class CrawlStatus(TypedDict):
+    id: str
+    url: str
+    status: str  # "pending" | "processing" | "done" | "failed"
+    pagesCrawled: int
+    maxPages: int
+    creditsUsed: int
+    createdAt: str
+    completedAt: Optional[str]
+    pages: List[CrawlPage]
+
+
+class MapResult(TypedDict):
+    links: List[str]
+    total: int
+
+
+class SearchResultItem(TypedDict):
+    url: str
+    title: str
+    snippet: str
+    markdown: Optional[str]
+    """None if this specific page failed to scrape — check `error` in that case."""
+    error: Optional[str]
+
+
+class Monitor(TypedDict):
+    id: str
+    url: str
+    interval: str  # "hourly" | "daily" | "weekly"
+    status: str  # "active" | "paused" | "cancelled"
+    createdAt: str
+
+
+class MonitorChange(TypedDict):
+    id: str
+    detectedAt: str
+    snapshot: str
+
+
+class MonitorDetail(Monitor):
+    changes: List[MonitorChange]
+
+
+class BatchResultItem(TypedDict, total=False):
+    id: str
+    """Only present if you supplied an id via `items`."""
+    url: str
+    status: str  # "pending" | "processing" | "done" | "failed"
+    data: ScrapeResult
+    """Only present when status is "done"."""
+    error: str
+    """Only present when status is "failed"."""
+
+
+class BatchStatus(TypedDict):
+    status: str  # "pending" | "processing" | "done"
+    total: int
+    completed: int
+    failed: int
+    creditsUsed: int
+    results: List[BatchResultItem]
+
+
+BatchScrapeItem = Dict[str, Any]  # {"id": Optional[str], "url": str}

webglean-0.1.0/tests/test_client.py

@@ -0,0 +1,151 @@
+import httpx
+import pytest
+import respx
+
+from webglean import WebGlean, WebGleanError
+
+BASE = "https://api.webglean.dev"
+
+
+def test_requires_api_key(monkeypatch):
+    monkeypatch.delenv("WEBGLEAN_API_KEY", raising=False)
+    with pytest.raises(ValueError, match="api_key is required"):
+        WebGlean()
+
+
+def test_falls_back_to_env_var(monkeypatch):
+    monkeypatch.setenv("WEBGLEAN_API_KEY", "wg_from_env")
+    WebGlean()  # should not raise
+
+
+@respx.mock
+def test_scrape_sends_singular_format_and_unwraps_data():
+    route = respx.post(f"{BASE}/v1/scrape").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "success": True,
+                "data": {"markdown": "# Hi", "html": "<h1>Hi</h1>", "text": "Hi", "metadata": {"title": "Hi"}},
+            },
+        )
+    )
+    client = WebGlean(api_key="wg_test")
+
+    result = client.scrape("https://example.com", format="markdown")
+
+    assert result == {"markdown": "# Hi", "html": "<h1>Hi</h1>", "text": "Hi", "metadata": {"title": "Hi"}}
+    sent = route.calls.last.request
+    assert sent.headers["Authorization"] == "Bearer wg_test"
+    import json as jsonlib
+    assert jsonlib.loads(sent.content) == {
+        "url": "https://example.com",
+        "formats": ["markdown"],
+        "onlyMainContent": True,
+    }
+
+
+@respx.mock
+def test_raises_webglean_error_on_non_2xx():
+    respx.post(f"{BASE}/v1/scrape").mock(
+        return_value=httpx.Response(401, json={"success": False, "error": "Invalid or missing API key"})
+    )
+    client = WebGlean(api_key="wg_bad")
+
+    with pytest.raises(WebGleanError) as exc_info:
+        client.scrape("https://example.com")
+
+    assert exc_info.value.status == 401
+    assert str(exc_info.value) == "Invalid or missing API key"
+
+
+@respx.mock
+def test_crawl_returns_just_the_id():
+    respx.post(f"{BASE}/v1/crawl").mock(return_value=httpx.Response(202, json={"success": True, "id": "crawl_1"}))
+    client = WebGlean(api_key="wg_test")
+
+    assert client.crawl("https://example.com") == "crawl_1"
+
+
+@respx.mock
+def test_map_reads_links_total_from_top_level():
+    respx.post(f"{BASE}/v1/map").mock(
+        return_value=httpx.Response(200, json={"success": True, "links": ["https://example.com/a"], "total": 1})
+    )
+    client = WebGlean(api_key="wg_test")
+
+    assert client.map("https://example.com") == {"links": ["https://example.com/a"], "total": 1}
+
+
+@respx.mock
+def test_search_returns_per_item_null_error_as_is():
+    respx.post(f"{BASE}/v1/search").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "success": True,
+                "data": [
+                    {"url": "https://good.com", "title": "Good", "snippet": "...", "markdown": "# Good", "error": None},
+                    {"url": "https://bad.com", "title": "Bad", "snippet": "...", "markdown": None, "error": "Page failed to load"},
+                ],
+            },
+        )
+    )
+    client = WebGlean(api_key="wg_test")
+
+    results = client.search("test")
+
+    assert results[1] == {
+        "url": "https://bad.com",
+        "title": "Bad",
+        "snippet": "...",
+        "markdown": None,
+        "error": "Page failed to load",
+    }
+
+
+def test_extract_raises_locally_without_schema_or_prompt():
+    client = WebGlean(api_key="wg_test")
+    with pytest.raises(ValueError, match="at least one of schema, prompt"):
+        client.extract("https://example.com")
+
+
+def test_batch_scrape_raises_locally_without_urls_or_items():
+    client = WebGlean(api_key="wg_test")
+    with pytest.raises(ValueError, match="provide either urls or items"):
+        client.batch_scrape()
+
+
+@respx.mock
+def test_delete_monitor_returns_none():
+    respx.delete(f"{BASE}/v1/monitor/mon_1").mock(return_value=httpx.Response(200, json={"success": True}))
+    client = WebGlean(api_key="wg_test")
+
+    assert client.delete_monitor("mon_1") is None
+
+
+@respx.mock
+def test_crawl_and_wait_polls_until_terminal():
+    respx.get(f"{BASE}/v1/crawl/crawl_1").mock(
+        side_effect=[
+            httpx.Response(200, json={"success": True, "data": {"id": "crawl_1", "status": "processing"}}),
+            httpx.Response(200, json={"success": True, "data": {"id": "crawl_1", "status": "done"}}),
+        ]
+    )
+    client = WebGlean(api_key="wg_test")
+
+    result = client.crawl_and_wait("crawl_1", poll_interval=0)
+
+    assert result == {"id": "crawl_1", "status": "done"}
+
+
+@respx.mock
+def test_crawl_and_wait_raises_on_timeout():
+    respx.get(f"{BASE}/v1/crawl/crawl_1").mock(
+        return_value=httpx.Response(200, json={"success": True, "data": {"id": "crawl_1", "status": "processing"}})
+    )
+    client = WebGlean(api_key="wg_test")
+
+    with pytest.raises(WebGleanError) as exc_info:
+        client.crawl_and_wait("crawl_1", poll_interval=0, timeout=0)
+
+    assert exc_info.value.status == 0