barebidi 0.1.0__tar.gz

barebidi-0.1.0/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(uv sync *)",
+      "Bash(uv run *)"
+    ]
+  }
+}

barebidi-0.1.0/.dockerignore

@@ -0,0 +1,12 @@
+.git
+.venv
+**/__pycache__
+.pytest_cache
+*.egg-info
+dist
+build
+
+# Proxy lists carry credentials: never in git nor in the image
+docker/*.txt
+*proxies*.txt
+webshare*.txt

barebidi-0.1.0/.gitignore

@@ -0,0 +1,14 @@
+.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+*.egg-info/
+dist/
+build/
+
+
+# Proxy lists carry credentials: never in git nor in the image
+docker/*.txt
+*proxies*.txt
+webshare*.txt
+.DS_Store

barebidi-0.1.0/Dockerfile

@@ -0,0 +1,51 @@
+# Ubuntu with Firefox that, seen from a web page, looks like an ordinary Ubuntu desktop: a screen with a top
+# bar and a maximized window, a sound device, Ubuntu's fonts, video codecs and WebGL. For running
+# barebidi (and its tests) on servers.
+#
+#   docker build -t barebidi .
+#   docker run --rm --shm-size=2g barebidi                                   # the test suite
+#   docker run --rm --shm-size=2g -e TZ=America/New_York barebidi python your_script.py
+#
+# Firefox needs more shared memory than Docker's default 64 MB, hence --shm-size. Set TZ (and the browser's
+# locale) to match where your IP or proxy is. Use Browser(headless=False): on Linux, headless Firefox has no
+# WebGL at all and detectors find it less like a desktop.
+FROM ubuntu:24.04 AS system
+ENV DEBIAN_FRONTEND=noninteractive
+# Firefox from Mozilla's own repository: Ubuntu's package is only a wrapper around the snap.
+RUN apt-get update \
+ && apt-get install -y --no-install-recommends ca-certificates curl \
+ && install -d -m 0755 /etc/apt/keyrings \
+ && curl -fsSL https://packages.mozilla.org/apt/repo-signing-key.gpg -o /etc/apt/keyrings/packages.mozilla.org.asc \
+ && echo "deb [signed-by=/etc/apt/keyrings/packages.mozilla.org.asc] https://packages.mozilla.org/apt mozilla main" > /etc/apt/sources.list.d/mozilla.list \
+ && printf 'Package: *\nPin: origin packages.mozilla.org\nPin-Priority: 1000\n' > /etc/apt/preferences.d/mozilla \
+ && apt-get update \
+ && apt-get install -y --no-install-recommends \
+      firefox python3 tini tzdata \
+      xvfb xauth jwm pulseaudio \
+      libgl1-mesa-dri libegl1 libgl1 libavcodec60 \
+      fonts-ubuntu fonts-dejavu-core fonts-liberation2 fonts-noto-color-emoji \
+ && apt-get purge -y curl && apt-get autoremove -y \
+ && rm -rf /var/lib/apt/lists/*
+
+FROM system AS build
+COPY --from=ghcr.io/astral-sh/uv:0.9.27 /uv /usr/local/bin/uv
+ENV UV_PYTHON=/usr/bin/python3 UV_PYTHON_DOWNLOADS=never
+WORKDIR /app
+COPY pyproject.toml uv.lock ./
+RUN uv sync --frozen --no-install-project
+COPY . .
+RUN uv sync --frozen
+RUN uv run --with camoufox python -m camoufox fetch
+
+FROM system
+COPY docker/desktop /usr/local/bin/desktop
+COPY --from=ghcr.io/astral-sh/uv:0.9.27 /uv /usr/local/bin/uv
+RUN useradd --create-home scraper
+COPY --chown=scraper docker/jwmrc /home/scraper/.jwmrc
+COPY --from=build --chown=scraper /app /app
+COPY --from=build --chown=scraper /root/.cache/camoufox /home/scraper/.cache/camoufox
+USER scraper
+WORKDIR /app
+ENV PATH=/app/.venv/bin:$PATH UV_PYTHON=/usr/bin/python3 UV_PYTHON_DOWNLOADS=never
+ENTRYPOINT ["tini", "--", "desktop"]
+CMD ["python", "-m", "pytest", "-q", "-p", "no:cacheprovider"]

barebidi-0.1.0/LICENSE

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

barebidi-0.1.0/PKG-INFO

@@ -0,0 +1,213 @@
+Metadata-Version: 2.5
+Name: barebidi
+Version: 0.1.0
+Summary: Async Firefox automation for Python, speaking WebDriver BiDi directly, no driver binaries.
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: websockets>=13
+Description-Content-Type: text/markdown
+
+BAREBIDI
+========
+
+### Async Firefox automation for Python, speaking WebDriver BiDi straight to the browser
+
+- **built for Firefox**: the regular Firefox you download from Mozilla, nothing patched
+- no driver binaries: no geckodriver, no Selenium
+- no Playwright-style browser builds: it drives the Firefox you already have
+- one dependency: `websockets`
+
+WebDriver BiDi is the W3C standard for browser automation, the successor of both classic WebDriver and the
+Chrome DevTools Protocol. Firefox speaks it natively: barebidi opens a websocket to Firefox and talks to it
+directly, so there is nothing in between to install, keep in sync or get detected.
+
+Most automation tools are Chrome-first and treat Firefox as an afterthought. barebidi is the other way
+around: every feature is built and tested against Firefox, including its quirks with cross-site iframes,
+closed shadow roots and input routing. Chrome support may come later; Firefox is the point.
+
+### Some features
+
+- `tab.select(css)`, `tab.find(text)`, `tab.xpath(expr)`, all waiting until the element appears
+- chainable queries: `await tab.select("form").select("button").click()`
+- mouse and keyboard input with human timings and trajectories, on by default
+- elements inside cross-site iframes and closed shadow roots, the ones scripts can't reach
+- proxies with credentials (no password prompt), plus per-context locale and time zone
+- isolated browser contexts: separate cookies, storage and proxy in one browser
+- network: intercept, block or modify requests, wait for responses, extra headers
+- dialogs (alert, confirm, prompt), file uploads and downloads
+- cookies: read, set, clear
+- every protocol type generated from the spec's CDDL, so your editor knows the shape of every message
+
+# Installation
+
+barebidi needs Firefox installed, from Mozilla (on Ubuntu, not the snap). It finds it in the usual places;
+otherwise set `FIREFOX_PATH` or pass `executable_path=`. On a headless server, run Firefox under Xvfb (or use
+`headless=True`).
+
+```
+pip install barebidi
+```
+
+To update:
+
+```
+pip install -U barebidi
+```
+
+# Usage examples
+
+The browser starts with sensible defaults: a temporary profile, stealth and human input on. Everything is
+async, and the browser closes itself when the `async with` block ends.
+
+## Simple
+
+```python
+import asyncio
+import barebidi as bb
+
+async def main():
+    async with bb.Browser() as browser:
+        tab = await browser.get("https://example.com")
+        print(await tab.title())
+
+        ... further code ...
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Or without the block, nodriver style:
+
+```python
+browser = await bb.start()
+tab = await browser.get("https://example.com")
+...
+await browser.stop()
+```
+
+## Custom starting options
+
+```python
+browser = await bb.start(
+    headless=True,
+    screen=(1920, 1080),                    # headless only; a real window keeps the real screen
+    profile="/path/to/profile",             # keep cookies and storage between runs
+    proxy="http://user:pass@host:8080",     # credentials are handled for you
+    locale="en-US",
+    timezone="America/New_York",
+    executable_path="/path/to/firefox",     # or set FIREFOX_PATH
+    args=["--some-firefox-arg"],
+    prefs={"some.pref": True},              # Firefox about:config prefs
+    downloads="/path/to/downloads",
+    humanize=True,                          # human-like mouse and keyboard
+)
+```
+
+## Finding and using elements
+
+```python
+tab = await browser.get("https://example.com/login")
+
+await tab.select("input[name=user]").type("me@example.com")
+await tab.select("input[name=password]").type("secret")
+await tab.find("Sign in").click()
+
+items = await tab.select_all(".item")
+for item in items:
+    print(await item.text(), await item.get_attribute("href"))
+```
+
+Inside an iframe or a shadow root:
+
+```python
+frame = await tab.frame("widget.example.org")         # by URL
+button = await frame.select("button")
+
+root = await (await tab.select("my-component")).shadow_root()
+await root.select("input").type("hello")
+```
+
+## Network
+
+```python
+async with tab.expect_response("/api/items") as expected:
+    await tab.find("Load more").click()
+items = await expected.response.json()
+
+await tab.block(resource_types=["image", "font"])
+await tab.set_extra_headers({"X-Debug": "1"})
+```
+
+## Dialogs, uploads and downloads
+
+```python
+async def answer(dialog):
+    await dialog.accept("Barebidi")
+
+await tab.on_dialog(answer)
+
+await tab.select("input[type=file]").set_files("report.pdf")
+
+async with tab.expect_download() as expected:
+    await tab.find("Export CSV").click()
+path = await expected.download.path()
+```
+
+## Separate identities in one browser
+
+```python
+us = await browser.new_context(proxy="http://user:pass@us-proxy:8080", locale="en-US", timezone="America/Chicago")
+de = await browser.new_context(proxy="http://user:pass@de-proxy:8080", locale="de-DE", timezone="Europe/Berlin")
+
+await us.get("https://example.com")
+await de.get("https://example.com")   # different cookies, storage, IP, language and clock
+```
+
+## Raw protocol
+
+Anything barebidi doesn't wrap is one call away:
+
+```python
+result = await tab.send("browsingContext.captureScreenshot", {"context": tab.id, "origin": "document"})
+```
+
+# Note: driving Camoufox
+
+[Camoufox](https://github.com/daijro/camoufox) is a patched Firefox build. Since it is still Firefox and
+still speaks WebDriver BiDi, barebidi drives it like any other Firefox: point `executable_path` at its binary.
+
+1. Download Camoufox with its own tool:
+
+   ```
+   pip install camoufox
+   python -m camoufox fetch
+   ```
+
+2. Find the binary it downloaded:
+
+   - macOS: `~/Library/Caches/camoufox/browsers/official/<version>/Camoufox.app/Contents/MacOS/camoufox`
+   - Linux: `~/.cache/camoufox/browsers/official/<version>/camoufox`
+
+3. Start barebidi with that path. Turn barebidi's own stealth off: Camoufox handles that part itself.
+
+   ```python
+   browser = await bb.start(executable_path="/path/to/camoufox", stealth=False)
+   ```
+
+4. Optionally, pass Camoufox its settings as JSON in the `CAMOU_CONFIG_1` environment variable through
+   `env=`. A config longer than 32767 characters goes in pieces: `CAMOU_CONFIG_1`, `CAMOU_CONFIG_2`, ...
+   See Camoufox's documentation for the available keys.
+
+   ```python
+   import json
+
+   config = {"navigator.hardwareConcurrency": 8}
+   browser = await bb.start(
+       executable_path="/path/to/camoufox",
+       stealth=False,
+       env={"CAMOU_CONFIG_1": json.dumps(config)},
+   )
+   ```
+
+The `camoufox` package is only needed to download the browser; barebidi doesn't depend on it.

barebidi-0.1.0/README.md

@@ -0,0 +1,203 @@
+BAREBIDI
+========
+
+### Async Firefox automation for Python, speaking WebDriver BiDi straight to the browser
+
+- **built for Firefox**: the regular Firefox you download from Mozilla, nothing patched
+- no driver binaries: no geckodriver, no Selenium
+- no Playwright-style browser builds: it drives the Firefox you already have
+- one dependency: `websockets`
+
+WebDriver BiDi is the W3C standard for browser automation, the successor of both classic WebDriver and the
+Chrome DevTools Protocol. Firefox speaks it natively: barebidi opens a websocket to Firefox and talks to it
+directly, so there is nothing in between to install, keep in sync or get detected.
+
+Most automation tools are Chrome-first and treat Firefox as an afterthought. barebidi is the other way
+around: every feature is built and tested against Firefox, including its quirks with cross-site iframes,
+closed shadow roots and input routing. Chrome support may come later; Firefox is the point.
+
+### Some features
+
+- `tab.select(css)`, `tab.find(text)`, `tab.xpath(expr)`, all waiting until the element appears
+- chainable queries: `await tab.select("form").select("button").click()`
+- mouse and keyboard input with human timings and trajectories, on by default
+- elements inside cross-site iframes and closed shadow roots, the ones scripts can't reach
+- proxies with credentials (no password prompt), plus per-context locale and time zone
+- isolated browser contexts: separate cookies, storage and proxy in one browser
+- network: intercept, block or modify requests, wait for responses, extra headers
+- dialogs (alert, confirm, prompt), file uploads and downloads
+- cookies: read, set, clear
+- every protocol type generated from the spec's CDDL, so your editor knows the shape of every message
+
+# Installation
+
+barebidi needs Firefox installed, from Mozilla (on Ubuntu, not the snap). It finds it in the usual places;
+otherwise set `FIREFOX_PATH` or pass `executable_path=`. On a headless server, run Firefox under Xvfb (or use
+`headless=True`).
+
+```
+pip install barebidi
+```
+
+To update:
+
+```
+pip install -U barebidi
+```
+
+# Usage examples
+
+The browser starts with sensible defaults: a temporary profile, stealth and human input on. Everything is
+async, and the browser closes itself when the `async with` block ends.
+
+## Simple
+
+```python
+import asyncio
+import barebidi as bb
+
+async def main():
+    async with bb.Browser() as browser:
+        tab = await browser.get("https://example.com")
+        print(await tab.title())
+
+        ... further code ...
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Or without the block, nodriver style:
+
+```python
+browser = await bb.start()
+tab = await browser.get("https://example.com")
+...
+await browser.stop()
+```
+
+## Custom starting options
+
+```python
+browser = await bb.start(
+    headless=True,
+    screen=(1920, 1080),                    # headless only; a real window keeps the real screen
+    profile="/path/to/profile",             # keep cookies and storage between runs
+    proxy="http://user:pass@host:8080",     # credentials are handled for you
+    locale="en-US",
+    timezone="America/New_York",
+    executable_path="/path/to/firefox",     # or set FIREFOX_PATH
+    args=["--some-firefox-arg"],
+    prefs={"some.pref": True},              # Firefox about:config prefs
+    downloads="/path/to/downloads",
+    humanize=True,                          # human-like mouse and keyboard
+)
+```
+
+## Finding and using elements
+
+```python
+tab = await browser.get("https://example.com/login")
+
+await tab.select("input[name=user]").type("me@example.com")
+await tab.select("input[name=password]").type("secret")
+await tab.find("Sign in").click()
+
+items = await tab.select_all(".item")
+for item in items:
+    print(await item.text(), await item.get_attribute("href"))
+```
+
+Inside an iframe or a shadow root:
+
+```python
+frame = await tab.frame("widget.example.org")         # by URL
+button = await frame.select("button")
+
+root = await (await tab.select("my-component")).shadow_root()
+await root.select("input").type("hello")
+```
+
+## Network
+
+```python
+async with tab.expect_response("/api/items") as expected:
+    await tab.find("Load more").click()
+items = await expected.response.json()
+
+await tab.block(resource_types=["image", "font"])
+await tab.set_extra_headers({"X-Debug": "1"})
+```
+
+## Dialogs, uploads and downloads
+
+```python
+async def answer(dialog):
+    await dialog.accept("Barebidi")
+
+await tab.on_dialog(answer)
+
+await tab.select("input[type=file]").set_files("report.pdf")
+
+async with tab.expect_download() as expected:
+    await tab.find("Export CSV").click()
+path = await expected.download.path()
+```
+
+## Separate identities in one browser
+
+```python
+us = await browser.new_context(proxy="http://user:pass@us-proxy:8080", locale="en-US", timezone="America/Chicago")
+de = await browser.new_context(proxy="http://user:pass@de-proxy:8080", locale="de-DE", timezone="Europe/Berlin")
+
+await us.get("https://example.com")
+await de.get("https://example.com")   # different cookies, storage, IP, language and clock
+```
+
+## Raw protocol
+
+Anything barebidi doesn't wrap is one call away:
+
+```python
+result = await tab.send("browsingContext.captureScreenshot", {"context": tab.id, "origin": "document"})
+```
+
+# Note: driving Camoufox
+
+[Camoufox](https://github.com/daijro/camoufox) is a patched Firefox build. Since it is still Firefox and
+still speaks WebDriver BiDi, barebidi drives it like any other Firefox: point `executable_path` at its binary.
+
+1. Download Camoufox with its own tool:
+
+   ```
+   pip install camoufox
+   python -m camoufox fetch
+   ```
+
+2. Find the binary it downloaded:
+
+   - macOS: `~/Library/Caches/camoufox/browsers/official/<version>/Camoufox.app/Contents/MacOS/camoufox`
+   - Linux: `~/.cache/camoufox/browsers/official/<version>/camoufox`
+
+3. Start barebidi with that path. Turn barebidi's own stealth off: Camoufox handles that part itself.
+
+   ```python
+   browser = await bb.start(executable_path="/path/to/camoufox", stealth=False)
+   ```
+
+4. Optionally, pass Camoufox its settings as JSON in the `CAMOU_CONFIG_1` environment variable through
+   `env=`. A config longer than 32767 characters goes in pieces: `CAMOU_CONFIG_1`, `CAMOU_CONFIG_2`, ...
+   See Camoufox's documentation for the available keys.
+
+   ```python
+   import json
+
+   config = {"navigator.hardwareConcurrency": 8}
+   browser = await bb.start(
+       executable_path="/path/to/camoufox",
+       stealth=False,
+       env={"CAMOU_CONFIG_1": json.dumps(config)},
+   )
+   ```
+
+The `camoufox` package is only needed to download the browser; barebidi doesn't depend on it.

barebidi-0.1.0/detection/behavior.py

@@ -0,0 +1,24 @@
+"""deviceandbrowserinfo.com interactions test: fills its login form like a person, then reads the verdict.
+
+    uv run python detection/behavior.py
+"""
+
+import asyncio
+
+from common import page_text, run, settle, verdict_and_flags
+
+NAME = "deviceandbrowserinfo (comportamiento)"
+URL = "https://deviceandbrowserinfo.com/are_you_a_bot_interactions"
+
+
+async def check(tab) -> str:
+    await settle(tab, URL, 2)
+    await tab.select("#email").type("maria.lopez@example.com")
+    await tab.select("#password").type("Secreta123!")
+    await tab.select("#loginForm button[type=submit]").click()
+    await asyncio.sleep(4)
+    return verdict_and_flags(await page_text(tab))
+
+
+if __name__ == "__main__":
+    run((NAME, check))

barebidi-0.1.0/detection/browserscan.py

@@ -0,0 +1,25 @@
+"""browserscan.net bot detection: an overall Normal/Robot verdict plus one per check.
+
+    uv run python detection/browserscan.py
+"""
+
+from common import page_text, run, settle
+
+NAME = "browserscan.net"
+URL = "https://www.browserscan.net/bot-detection"
+VERDICTS = ("Normal", "Robot")
+
+
+async def check(tab) -> str:
+    await settle(tab, URL, 8)
+    lines = [line.strip() for line in (await page_text(tab)).splitlines() if line.strip()]
+    start = lines.index("Bot Detection") if "Bot Detection" in lines else 0
+    verdict = next((line for line in lines[start : start + 6] if line in VERDICTS), "sin veredicto")
+    robots = [lines[i - 1] for i, line in enumerate(lines) if line == "Robot" and i > start + 1]
+    for label in robots:
+        print(f"  Robot: {label}")
+    return verdict + (f" (Robot en: {', '.join(robots)})" if robots else "")
+
+
+if __name__ == "__main__":
+    run((NAME, check))

barebidi-0.1.0/detection/cloudflare.py

@@ -0,0 +1,79 @@
+"""Cloudflare: scrapingcourse.com's bot challenge, and a click on nowsecure.nl's Turnstile checkbox.
+
+nowsecure.nl has no challenge anymore (curl gets in too) and its Turnstile widget uses one of Cloudflare's
+test sitekeys, which give every visitor the same answer. So that check measures our click, not detection:
+a checkbox inside a cross-site iframe, behind two closed shadow roots, on a 3D cube that never stops moving.
+
+    uv run python detection/cloudflare.py
+"""
+
+import asyncio
+import re
+
+from common import page_text, passes_cloudflare, run
+
+SCRAPINGCOURSE = "https://www.scrapingcourse.com/antibot-challenge"
+NOWSECURE = "https://nowsecure.nl/"
+TEST_SITEKEY = re.compile(r"[123]x0{20}[A-Z]{2}")  # e.g. 3x00000000000000000000FF: always asks for the click
+ON_SCREEN = "function () { const r = this.getBoundingClientRect(); return r.width > 0 && r.bottom > 0 && r.top < innerHeight }"
+
+
+async def scrapingcourse(tab) -> str:
+    await asyncio.wait_for(tab.get(SCRAPINGCOURSE, wait="interactive"), 60)
+    how = await passes_cloudflare(tab)
+    if how is None:
+        return "NO superado: sigue en el challenge de Cloudflare"
+    await asyncio.sleep(2)
+    text = await page_text(tab)
+    return f"superado {how}" if "bypassed" in text.lower() else f"cargó, pero sin el mensaje de éxito: {text[:120]!r}"
+
+
+async def nowsecure(tab) -> str:
+    await asyncio.wait_for(tab.get(NOWSECURE, wait="interactive"), 60)
+    if await passes_cloudflare(tab) is None:
+        return "NO superado: sigue en el challenge de Cloudflare"
+    widget = await turnstile_on_screen(tab)
+    await (await turnstile_checkbox(widget)).click()
+    token = await turnstile_token(widget)
+    if not token:
+        return "casilla pulsada, pero Turnstile no dio token"
+    sitekey = await widget.get_attribute("data-sitekey") or ""
+    note = f" (sitekey de prueba {sitekey}: mide el clic, no la detección)" if TEST_SITEKEY.fullmatch(sitekey) else ""
+    return f"casilla pulsada, token {token[:40]}{note}"
+
+
+async def turnstile_on_screen(tab):
+    # nowsecure.nl has a second widget in its reflection, out of view.
+    for widget in await tab.select_all(".cf-turnstile", timeout=20):
+        if await widget.call(ON_SCREEN, isolated=True):
+            return widget
+    raise RuntimeError("no hay ningún Turnstile a la vista")
+
+
+async def turnstile_checkbox(widget, timeout: float = 30):
+    """Turnstile hides its iframe in a closed shadow root, and the checkbox in another one inside the iframe."""
+    loop = asyncio.get_running_loop()
+    deadline = loop.time() + timeout
+    while loop.time() < deadline:
+        for element in await widget.select_all("div"):
+            if host_root := await element.shadow_root():
+                frame = await (await host_root.select("iframe")).content_frame()
+                if root := await (await frame.select("body", timeout=timeout)).shadow_root():
+                    return await root.select("input[type=checkbox]", timeout=deadline - loop.time())
+        await asyncio.sleep(0.25)  # the widget is still loading
+    raise TimeoutError(f"la casilla de Turnstile no apareció en {timeout}s")
+
+
+async def turnstile_token(widget, timeout: float = 15) -> str:
+    response = await widget.select("[name=cf-turnstile-response]")
+    for _ in range(int(timeout / 0.25)):
+        if token := await response.get_property("value"):
+            return token
+        await asyncio.sleep(0.25)
+    return ""
+
+
+CHECKS = [("Cloudflare: scrapingcourse.com", scrapingcourse), ("Cloudflare: nowsecure.nl", nowsecure)]
+
+if __name__ == "__main__":
+    run(*CHECKS)