Every place a captcha
stands in your way

capsolv is a drop-in solving API. Send a captcha, poll for the result, get a token back — then submit that token to the target site yourself. The wire format is identical to 2captcha and CapSolver, so existing clients work unchanged: just change the base URL and key.

import requests, time
BASE = "https://THIS_HOST"          # point any 2captcha / CapSolver client here
KEY  = "cr_live_xxx"                 # your API key == clientKey

t = requests.post(BASE+"/createTask", json={"clientKey":KEY,"task":{
  "type":"AntiTurnstileTaskProxyLess","websiteURL":"https://site.com",
  "websiteKey":"0x4AAA..."}}).json()["taskId"]

while True:
    r = requests.post(BASE+"/getTaskResult", json={"clientKey":KEY,"taskId":t}).json()
    if r.get("status") == "ready":
        token = r["solution"]["token"]; break
    time.sleep(2)
# -> submit `token` from the SAME session/proxy that requested it

Most anti-bot walls in front of scrapers are captcha/JS challenges: Cloudflare Turnstile, DataDome, PerimeterX, AWS WAF, plus reCAPTCHA on search and listing pages. Solve the challenge, inject the returned token, and keep crawling.

1. Detect the challenge — look for the sitekey (e.g. data-sitekey) and page URL.
2. createTask with the matching task type and those params.
3. Poll getTaskResult until ready and read the token.
4. Replay the request with the token in the expected field/header, from the same IP.

# Hit a page guarded by Cloudflare Turnstile, solve, then replay with the token
task = {"type":"AntiTurnstileTaskProxyLess",
        "websiteURL":"https://target.com/listing",
        "websiteKey":"0x4AAA..."}          # the data-sitekey on the page
token = solve(task)                        # createTask -> poll (see Overview)
r = session.get("https://target.com/listing",
                headers={"cf-turnstile-response": token})

Sign-up and verification flows are usually gated by hCaptcha, reCAPTCHA, FunCaptcha (Arkose) or GeeTest. Solve the gate as part of your registration pipeline; pair with an inbox/SMS step for full PVA (phone-verified accounts).

1. Load the signup page and read the captcha sitekey.
2. solve() the matching task type.
3. Submit the form with the token in the captcha field (h-captcha-response, g-recaptcha-response, …).
4. Complete any email/SMS verification with your inbox provider.

task = {"type":"HCaptchaTaskProxyLess",
        "websiteURL":"https://app.com/signup",
        "websiteKey":"a1b2c3-..."}
token = solve(task)
# post the signup form with the hCaptcha token
session.post("https://app.com/signup", data={
    "email":email, "password":pw, "h-captcha-response":token})

Drops, queues and checkout pages defend with the heaviest stacks — Akamai, PerimeterX, DataDome, Kasada, FunCaptcha. Latency is everything, so run solves concurrently and pre-warm tokens before the drop.

1. Open many concurrent createTask calls (the API is async — fan out).
2. Pre-warm a buffer of tokens just before the release.
3. Submit checkout with the freshest token from the same session.
4. Retry instantly on rejection with the next token.

# Pre-warm a pool of tokens so checkout never waits on a solve
from concurrent.futures import ThreadPoolExecutor
pool = ThreadPoolExecutor(max_workers=20)
tokens = [pool.submit(solve, task) for _ in range(20)]
# ... grab tokens[i].result() the instant a drop goes live

Automated end-to-end tests break when a real captcha sits in the flow. Solve it inside your Playwright, Selenium, Cypress or Puppeteer suite so CI can exercise the whole journey — login, checkout, signup — on staging or production you own.

1. Read the sitekey from the rendered page in your test.
2. solve() the matching task type.
3. Inject the token into the response field and dispatch any change event.
4. Continue the test — submit and assert the result.

# Playwright: solve a reCAPTCHA v2 in your own E2E test
sitekey = page.get_attribute(".g-recaptcha", "data-sitekey")
token = solve({"type":"ReCaptchaV2TaskProxyLess",
               "websiteURL":page.url, "websiteKey":sitekey})
page.evaluate("""t => {
  document.getElementById("g-recaptcha-response").value = t;
}""", token)
page.click("button[type=submit]")

Search-engine results, ad placement checks and brand-safety crawls trip reCAPTCHA and regional walls like Yandex SmartCaptcha. Solve on demand to keep rank-tracking and ad verification pipelines flowing.

1. Crawl the SERP/ad page; on a challenge, capture sitekey + URL.
2. solve() and replay with the token from a matching geo proxy.
3. Parse results and record rank / ad position.

task = {"type":"ReCaptchaV2TaskProxyLess",
        "websiteURL":"https://www.google.com/search?q=...",
        "websiteKey":"6Lc_..."}
token = solve(task)
# replay the SERP request with the token + your residential proxy

Marketplaces, travel and retail sites sit behind DataDome, PerimeterX, Akamai and Imperva. Fold solving into your scheduled crawl so price, stock and assortment data keeps updating without manual intervention.

1. Schedule the crawl; detect interstitials per request.
2. Solve only when challenged (most requests won’t be).
3. Cache tokens per domain/session where the site allows it.

for url in product_urls:
    html = fetch(url)
    if is_challenge(html):                 # DataDome / PerimeterX interstitial
        token = solve(detect_task(html))
        html  = fetch(url, token=token)
    yield parse_price(html)

Login, posting and engagement flows on large social platforms lean heavily on FunCaptcha (Arkose) and hCaptcha. The integration is the same — solve the gate, submit the token — just expect FunCaptcha to dominate.

1. Trigger the captcha (login / action), capture the sitekey or public key.
2. solve() the FunCaptcha/hCaptcha task.
3. Submit with the token; respect per-account rate limits and proxies.

A few habits make integrations fast, cheap and reliable across every use case above.

def solve(task, tries=3, timeout=120):
    for _ in range(tries):
        t = post("/createTask", {"clientKey":KEY,"task":task})
        if t.get("errorId"): continue            # bad params / no balance
        tid, start = t["taskId"], time.time()
        while time.time() - start < timeout:
            r = post("/getTaskResult", {"clientKey":KEY,"taskId":tid})
            if r.get("status") == "ready": return r["solution"]
            if r.get("errorId"): break            # solve failed -> retry
            time.sleep(2)
    raise RuntimeError("solve failed")