Solve hCaptcha in Scrapling.

pip install "scrapling[fetchers]" nonecap
scrapling install

import os

from nonecap import NoneCap
from scrapling.fetchers import StealthyFetcher

nc = NoneCap(api_key=os.environ["NONECAP_KEY"])

# Writes the token into the hCaptcha response fields. hCaptcha's drop-in mode
# reuses reCAPTCHA's old g-recaptcha-response field name, so it is set too when
# present; the value is still the hCaptcha token. Invisible widgets submit
# from data-callback, so the callback is fired if the page has one.
INJECT_JS = """(token) => {
    for (const name of ["h-captcha-response", "g-recaptcha-response"]) {
        const el = document.querySelector('textarea[name="' + name + '"]');
        if (el) el.value = token;
    }
    const cb = document.querySelector("[data-callback]")
        ?.getAttribute("data-callback");
    if (cb && typeof window[cb] === "function") window[cb](token);
}"""

result = {}


def solve_hcaptcha(page):
    try:
        widget = page.locator("[data-sitekey]")
        if widget.count() == 0:
            return  # no hCaptcha on this page

        # 1. Read the sitekey off the rendered widget.
        sitekey = widget.first.get_attribute("data-sitekey")

        # 2. Get a real token. nc.solve() submits the job and long-polls
        #    until it reaches a terminal state.
        solve = nc.solve(
            type="hcaptcha",
            sitekey=sitekey,
            url=page.url,
            user_agent=page.evaluate("navigator.userAgent"),
        )

        # 3. Inject it into the page.
        page.evaluate(INJECT_JS, solve.token)

        # 4. Submit and wait for the next page to load.
        with page.expect_navigation():
            page.click("button[type=submit]")
        result["solve"] = solve
    except Exception as exc:
        result["error"] = exc


response = StealthyFetcher.fetch(
    "https://target.example/login",
    page_action=solve_hcaptcha,
    network_idle=True,
)
if "error" in result:
    raise result["error"]

# response is the page after the form went through.
print(response.status, response.url)
print(response.css("h1::text").get())

from scrapling.fetchers import StealthySession

# One browser for the whole run; solve_hcaptcha only acts on pages
# that render a widget.
with StealthySession(network_idle=True) as session:
    for url in ["https://target.example/login", "https://target.example/signup"]:
        result.clear()
        response = session.fetch(url, page_action=solve_hcaptcha)
        if "error" in result:
            raise result["error"]
        print(url, response.status)

import os

from nonecap import NoneCap
from scrapling.fetchers import FetcherSession

nc = NoneCap(api_key=os.environ["NONECAP_KEY"])

with FetcherSession(impersonate="chrome") as session:
    page = session.get("https://target.example/signup")

    # 1. Read the sitekey, plus the form's own fields (CSRF token and so on).
    sitekey = page.css("[data-sitekey]::attr(data-sitekey)").get()
    fields = {
        field.attrib["name"]: field.attrib.get("value", "")
        for field in page.css("form input[name]")
    }
    fields["email"] = "you@example.com"

    # 2. Get a real token.
    solve = nc.solve(type="hcaptcha", sitekey=sitekey, url=page.url)

    # 3. The token goes in the form body under both field names.
    fields["h-captcha-response"] = solve.token
    fields["g-recaptcha-response"] = solve.token

    # 4. Submit with the solve's user agent: some sites refuse a token
    #    sent from a different browser version.
    action = page.urljoin(page.css("form::attr(action)").get(""))
    headers = {"User-Agent": solve.user_agent} if solve.user_agent else {}
    submitted = session.post(action, data=fields, headers=headers)
    print(submitted.status, submitted.css("h1::text").get())

from urllib.parse import parse_qs, urlparse

# Some pages never put data-sitekey in the DOM and pass the key straight
# to hcaptcha.render(). Read it off the api.js script tag instead:
sitekey = page.css("[data-sitekey]::attr(data-sitekey)").get()
if sitekey is None:
    src = page.css("script[src*='hcaptcha.com/1/api.js']::attr(src)").get()
    sitekey = parse_qs(urlparse(src).query)["sitekey"][0]

# Enterprise sitekeys also need the per-challenge rqdata blob. Capture
# the value the page passes into hcaptcha.render() / execute(), then
# forward it with the enterprise type:
solve = nc.solve(
    type="hcaptcha_enterprise",
    sitekey=sitekey,
    url=page.url,
    rqdata=rqdata,  # the fresh, IP-bound challenge blob
)

import asyncio
import os

from nonecap import AsyncNoneCap
from scrapling.fetchers import AsyncStealthySession

nc = AsyncNoneCap(api_key=os.environ["NONECAP_KEY"])
errors = []


async def solve_hcaptcha(page):
    try:
        widget = page.locator("[data-sitekey]")
        if await widget.count() == 0:
            return
        sitekey = await widget.first.get_attribute("data-sitekey")
        solve = await nc.solve(
            type="hcaptcha",
            sitekey=sitekey,
            url=page.url,
            user_agent=await page.evaluate("navigator.userAgent"),
        )
        await page.evaluate(INJECT_JS, solve.token)  # INJECT_JS from the full example
        async with page.expect_navigation():
            await page.click("button[type=submit]")
    except Exception as exc:
        errors.append(exc)  # Scrapling only logs it, as in the sync example


async def main(urls):
    async with AsyncStealthySession(network_idle=True, max_pages=5) as session:
        pages = await asyncio.gather(
            *(session.fetch(url, page_action=solve_hcaptcha) for url in urls)
        )
    if errors:
        raise errors[0]
    return pages