CapSolver Pricing 2026: reCAPTCHA v2 Cost Per 1000 Solves

—

If you’re solving reCAPTCHA v2 at scale, CapSolver pricing for reCAPTCHA v2 per 1000 solves is one of the first numbers you’ll want pinned down before committing to a pipeline. the math compounds fast: 100k daily solves at $1.50/1000 costs $150/day, or ~$4,500/month. get the rate wrong and your cost model is broken before you write a single line of scraper code.

what CapSolver actually charges for reCAPTCHA v2 in 2026

CapSolver’s published rate for standard reCAPTCHA v2 (image-click challenge, non-enterprise) sits at $0.80 per 1,000 solves as of Q1 2026. that’s the token-based task type (NoCaptchaTaskProxyless), where CapSolver uses its own proxy pool. if you pass your own proxies (NoCaptchaTask), the rate drops slightly to around $0.70 per 1,000 because you’re absorbing the proxy cost.

enterprise reCAPTCHA v2 (served by Google’s enterprise API, common on fintech and e-commerce checkout pages) is priced separately at $2.00-$2.50 per 1,000, reflecting the harder challenge and lower solve confidence. CapSolver doesn’t always distinguish this in the dashboard — you’ll see it show up as failed or timed-out solves if you’re sending enterprise challenges to the standard endpoint, which silently drains your balance.

the full CapSolver pricing breakdown across all task types covers image tasks, funcaptcha, hCaptcha, and Cloudflare Turnstile — reCAPTCHA v2 is only one line in a longer pricing sheet, but it’s usually the highest-volume one.

how CapSolver v2 rates compare to the main alternatives

pricing alone doesn’t tell you much without solve rate and latency context. here’s a realistic 2026 snapshot across the major CAPTCHA-solving APIs:

provider	reCAPTCHA v2 ($/1k)	enterprise v2 ($/1k)	avg solve time	solve rate (claimed)
CapSolver	$0.80	$2.20	8-15s	99%+
2captcha	$1.00	$3.00	20-40s	97%
AntiCaptcha	$0.90	$2.50	15-30s	98%
DeathByCaptcha	$1.39	n/a	10-20s	96%
NopeCHA (token)	$0.60	$1.80	5-10s	95%

CapSolver is not the cheapest (NopeCHA edges it out on standard v2) but it’s faster and the API reliability is meaningfully better under burst load. for pipelines doing 50k+ solves/day, the 30-40% speed advantage over 2captcha compounds into real throughput gains.

integrating CapSolver reCAPTCHA v2 in a scraper

the API itself is a two-step polling loop. here’s a minimal Python example using requests:

import requests, time

API_KEY = "your_capsolver_key"
SITE_KEY = "6LcR_okUAAAAAPYr..."
PAGE_URL  = "https://target-site.com/login"

def solve_recaptcha_v2(site_key, page_url):
    task_resp = requests.post("https://api.capsolver.com/createTask", json={
        "clientKey": API_KEY,
        "task": {
            "type": "NoCaptchaTaskProxyless",
            "websiteURL": page_url,
            "websiteKey": site_key,
        }
    }).json()

    task_id = task_resp["taskId"]

    for _ in range(30):
        time.sleep(3)
        result = requests.post("https://api.capsolver.com/getTaskResult", json={
            "clientKey": API_KEY,
            "taskId": task_id
        }).json()
        if result.get("status") == "ready":
            return result["solution"]["gRecaptchaResponse"]
    raise TimeoutError("solve timeout")

a few things to watch:

poll interval: 3s is fine; polling faster wastes requests and doesn’t speed up solves
task type: swap NoCaptchaTaskProxyless to NoCaptchaTask and add proxyType, proxyAddress, proxyPort if you’re routing through residential IPs you control
token TTL: reCAPTCHA v2 tokens expire in ~120 seconds. submit immediately after solve or you’ll get ERROR_TOKEN_EXPIRED on the target site

where costs blow up unexpectedly

most teams underestimate their actual cost because they only count successful solves. three common ways the bill grows:

enterprise challenges routed to the standard endpoint: you pay for the attempt even if CapSolver returns a low-confidence or failed token. add challenge type detection before dispatching.
token expiry waste: if your downstream request pipeline is slow (rate-limit backoff, retry queues), tokens expire before use. you’re paying twice for the same page.
retry loops without dedup: a naive scraper that retries on any non-200 response can solve the same CAPTCHA 3-5x for a single page load.

this gets worse on sites protected by Akamai Bot Manager layered on top of reCAPTCHA — the CAPTCHA solve gets through but Akamai blocks the subsequent request anyway. understanding the fingerprint vs rate-limit distinction in Akamai 403 errors helps you avoid burning CAPTCHA budget on sessions that were never going to succeed.

when reCAPTCHA v2 is the wrong layer to target

sometimes the CAPTCHA solve is not the bottleneck. if you’re scraping Cloudflare-protected targets, the TLS fingerprint check runs before any CAPTCHA challenge is served. a failed JA4 check at the edge means you never get a reCAPTCHA in the first place — you just get a 403 or silent block. understanding the Cloudflare JA4 fingerprint format tells you whether your client is leaking bot signals before the challenge layer even loads.

similarly, rate-limit blocks (HTTP 429 / Cloudflare error 1015) are often mistaken for CAPTCHA-related failures. you can burn hundreds of solves thinking you have a CAPTCHA problem when the real issue is request cadence. if you need a browser-level solution that handles both Cloudflare fingerprinting and CAPTCHA in the same session, Anchor Browser is worth evaluating — it manages TLS and browser fingerprint matching natively, which reduces the scenario where you solve the CAPTCHA and still get blocked.

quick checklist before scaling CAPTCHA spend:

confirm the target actually serves reCAPTCHA v2 (not enterprise, not v3 scoring)
verify your session passes TLS/JA4 checks independently of the CAPTCHA
log token-use latency to catch expiry waste
track solve-success vs. downstream-request-success separately

bottom line

at $0.80 per 1,000 solves, CapSolver is a solid mid-market choice for reCAPTCHA v2 — faster than 2captcha, cheaper than DeathByCaptcha, and reliable enough under burst load. the real cost leverage is in cutting waste: enterprise misrouting, expired tokens, and CAPTCHA solves on sessions that are blocked at a different layer. DRT covers these tradeoffs across the full anti-bot stack, so if you’re building or auditing a scraping pipeline, cross-reference the pricing numbers against your actual infrastructure constraints before locking in a provider.